Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2025-01-07 08:34:59 +00:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity
cec1de3f35
llvm-capstone/flang/module/__ppc_intrinsics.f90

1912 lines
80 KiB
Fortran
Raw Blame History

!===-- module/__ppc_intrinsics.f90 -----------------------------------------===!
!
! 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
!
!===------------------------------------------------------------------------===!
module __ppc_intrinsics
private
! fmadd, fmsub, fnmadd, fnmsub
abstract interface
elemental real(4) function func_r4r4r4r4(a, x, y)
real(4), intent(in) :: a, x, y
end function func_r4r4r4r4
elemental real(8) function func_r8r8r8r8(a, x, y)
real(8), intent(in) :: a, x, y
end function func_r8r8r8r8
!--------------------
! Vector intrinsic
!--------------------
!! ================ 1 argument function interface ================
! vector(i) function f(vector(i))
#define ELEM_FUNC_VIVI(VKIND) \
elemental vector(integer(VKIND)) function elem_func_vi##VKIND##vi##VKIND(arg1); \
vector(integer(VKIND)), intent(in) :: arg1; \
end function ;
! vector(u) function f(vector(u))
#define ELEM_FUNC_VUVU(VKIND) \
elemental vector(unsigned(VKIND)) function elem_func_vu##VKIND##vu##VKIND(arg1); \
vector(unsigned(VKIND)), intent(in) :: arg1; \
end function ;
! vector(r) function f(vector(r))
#define ELEM_FUNC_VRVR_2(VKIND1, VKIND2) \
elemental vector(real(VKIND1)) function elem_func_vr##VKIND1##vr##VKIND2(arg1); \
vector(real(VKIND2)), intent(in) :: arg1; \
end function ;
#define ELEM_FUNC_VRVR(VKIND) ELEM_FUNC_VRVR_2(VKIND, VKIND)
! vector(i) function f(i)
#define ELEM_FUNC_VII_2(RKIND, VKIND) \
elemental vector(integer(RKIND)) function elem_func_vi##RKIND##i##VKIND(arg1); \
integer(VKIND), intent(in) :: arg1; \
end function ;
#define ELEM_FUNC_VII(VKIND) ELEM_FUNC_VII_2(VKIND, VKIND)
! vector(r) function f(r)
#define ELEM_FUNC_VRR(VKIND) \
elemental vector(real(VKIND)) function elem_func_vr##VKIND##r##VKIND(arg1); \
real(VKIND), intent(in) :: arg1; \
end function ;
ELEM_FUNC_VIVI(1) ELEM_FUNC_VIVI(2) ELEM_FUNC_VIVI(4) ELEM_FUNC_VIVI(8)
ELEM_FUNC_VUVU(1)
ELEM_FUNC_VRVR_2(4,8) ELEM_FUNC_VRVR_2(8,4)
ELEM_FUNC_VRVR(4) ELEM_FUNC_VRVR(8)
ELEM_FUNC_VII_2(4,1) ELEM_FUNC_VII_2(4,2) ELEM_FUNC_VII_2(4,8)
ELEM_FUNC_VII(1) ELEM_FUNC_VII(2) ELEM_FUNC_VII(4) ELEM_FUNC_VII(8)
ELEM_FUNC_VRR(4) ELEM_FUNC_VRR(8)
#undef ELEM_FUNC_VRR
#undef ELEM_FUNC_VII
#undef ELEM_FUNC_VII_2
#undef ELEM_FUNC_VRVR
#undef ELEM_FUNC_VRVR_2
#undef ELEM_FUNC_VUVU
#undef ELEM_FUNC_VIVI
!! ================ 2 arguments function interface ================
! vector(i) function f(vector(i), vector(i))
#define ELEM_FUNC_VIVIVI(VKIND) \
elemental vector(integer(VKIND)) function elem_func_vi##VKIND##vi##VKIND##vi##VKIND(arg1, arg2); \
vector(integer(VKIND)), intent(in) :: arg1, arg2; \
end function ;
! vector(u) function f(vector(i), vector(i))
#define ELEM_FUNC_VUVIVI(VKIND) \
elemental vector(unsigned(VKIND)) function elem_func_vu##VKIND##vi##VKIND##vi##VKIND(arg1, arg2); \
vector(integer(VKIND)), intent(in) :: arg1, arg2; \
end function ;
! vector(i) function f(vector(i), vector(u))
#define ELEM_FUNC_VIVIVU_2(VKIND1, VKIND2) \
elemental vector(integer(VKIND1)) function elem_func_vi##VKIND1##vi##VKIND1##vu##VKIND2(arg1, arg2); \
vector(integer(VKIND1)), intent(in) :: arg1; \
vector(unsigned(VKIND2)), intent(in) :: arg2; \
end function ;
#define ELEM_FUNC_VIVIVU(VKIND) ELEM_FUNC_VIVIVU_2(VKIND, VKIND)
! vector(u) function f(vector(u), vector(u))
#define ELEM_FUNC_VUVUVU_2(VKIND1, VKIND2) \
elemental vector(unsigned(VKIND1)) function elem_func_vu##VKIND1##vu##VKIND1##vu##VKIND2(arg1, arg2); \
vector(unsigned(VKIND1)), intent(in) :: arg1; \
vector(unsigned(VKIND2)), intent(in) :: arg2; \
end function ;
#define ELEM_FUNC_VUVUVU(VKIND) ELEM_FUNC_VUVUVU_2(VKIND, VKIND)
! vector(r) function f(vector(r), vector(r))
#define ELEM_FUNC_VRVRVR(VKIND) \
elemental vector(real(VKIND)) function elem_func_vr##VKIND##vr##VKIND##vr##VKIND(arg1, arg2); \
vector(real(VKIND)), intent(in) :: arg1, arg2; \
end function ;
! vector(r) function f(vector(r), vector(u))
#define ELEM_FUNC_VRVRVU_2(VKIND1, VKIND2) \
elemental vector(real(VKIND1)) function elem_func_vr##VKIND1##vr##VKIND1##vu##VKIND2(arg1, arg2); \
vector(real(VKIND1)), intent(in) :: arg1; \
vector(unsigned(VKIND2)), intent(in) :: arg2; \
end function ;
! vector(u) function f(vector(r), vector(r))
#define ELEM_FUNC_VUVRVR(VKIND) \
elemental vector(unsigned(VKIND)) function elem_func_vu##VKIND##vr##VKIND##vr##VKIND(arg1, arg2); \
vector(real(VKIND)), intent(in) :: arg1, arg2; \
end function ;
! integer function f(vector(i), vector(i))
#define ELEM_FUNC_IVIVI(RKIND, VKIND) \
elemental integer(RKIND) function elem_func_i##RKIND##vi##VKIND##vi##VKIND(arg1, arg2); \
vector(integer(VKIND)), intent(in) :: arg1, arg2; \
end function ;
! integer function f(vector(u), vector(u))
#define ELEM_FUNC_IVUVU(RKIND, VKIND) \
elemental integer(RKIND) function elem_func_i##RKIND##vu##VKIND##vu##VKIND(arg1, arg2); \
vector(unsigned(VKIND)), intent(in) :: arg1, arg2; \
end function ;
! integer function f(vector(r), vector(r))
#define ELEM_FUNC_IVRVR(RKIND, VKIND) \
elemental integer(RKIND) function elem_func_i##RKIND##vr##VKIND##vr##VKIND(arg1, arg2); \
vector(real(VKIND)), intent(in) :: arg1, arg2; \
end function ;
! vector(r) function f(vector(i), i)
#define ELEM_FUNC_VRVII(VKIND) \
elemental vector(real(VKIND)) function elem_func_vr##VKIND##vi##VKIND##i(arg1, arg2); \
vector(integer(VKIND)), intent(in) :: arg1; \
integer(8), intent(in) :: arg2; \
!dir$ ignore_tkr(k) arg2; \
end function ;
! integer function f(vector(i), i)
#define ELEM_FUNC_IVII(VKIND) \
elemental integer(VKIND) function elem_func_i##VKIND##vi##VKIND##i(arg1, arg2); \
vector(integer(VKIND)), intent(in) :: arg1; \
integer(8), intent(in) :: arg2; \
!dir$ ignore_tkr(k) arg2; \
end function ;
! vector(r) function f(vector(u), i)
#define ELEM_FUNC_VRVUI(VKIND) \
elemental vector(real(VKIND)) function elem_func_vr##VKIND##vu##VKIND##i(arg1, arg2); \
vector(unsigned(VKIND)), intent(in) :: arg1; \
integer(8), intent(in) :: arg2; \
!dir$ ignore_tkr(k) arg2; \
end function ;
! real function f(vector(r), i)
#define ELEM_FUNC_RVRI(VKIND) \
elemental real(VKIND) function elem_func_r##VKIND##vr##VKIND##i(arg1, arg2); \
vector(real(VKIND)), intent(in) :: arg1; \
integer(8), intent(in) :: arg2; \
!dir$ ignore_tkr(k) arg2; \
end function ;
! vector(i) function f(vector(i), i)
#define ELEM_FUNC_VIVII0(VKIND) \
elemental vector(integer(VKIND)) function elem_func_vi##VKIND##vi##VKIND##i0(arg1, arg2); \
vector(integer(VKIND)), intent(in) :: arg1; \
integer(8), intent(in) :: arg2; \
!dir$ ignore_tkr(k) arg2; \
end function ;
! vector(u) function f(vector(u), i)
#define ELEM_FUNC_VUVUI0(VKIND) \
elemental vector(unsigned(VKIND)) function elem_func_vu##VKIND##vu##VKIND##i0(arg1, arg2); \
vector(unsigned(VKIND)), intent(in) :: arg1; \
integer(8), intent(in) :: arg2; \
!dir$ ignore_tkr(k) arg2; \
end function ;
! vector(r) function f(vector(r), i)
#define ELEM_FUNC_VRVRI0(VKIND) \
elemental vector(real(VKIND)) function elem_func_vr##VKIND##vr##VKIND##i0(arg1, arg2); \
vector(real(VKIND)), intent(in) :: arg1; \
integer(8), intent(in) :: arg2; \
!dir$ ignore_tkr(k) arg2; \
end function ;
! vector(i) function f(i, integer)
#define FUNC_VII0I(VKIND) \
pure vector(integer(VKIND)) function func_vi##VKIND##i0i##VKIND(arg1, arg2); \
integer(8), intent(in) :: arg1; \
!dir$ ignore_tkr(k) arg1; \
integer(VKIND), intent(in) :: arg2; \
!dir$ ignore_tkr(r) arg2; \
end function ;
! vector(r) function f(i, real)
#define FUNC_VRI0R(VKIND) \
pure vector(real(VKIND)) function func_vr##VKIND##i0r##VKIND(arg1, arg2); \
integer(8), intent(in) :: arg1; \
!dir$ ignore_tkr(k) arg1; \
real(VKIND), intent(in) :: arg2; \
!dir$ ignore_tkr(r) arg2; \
end function ;
! vector(i) function f(i, vector(i))
#define FUNC_VII0VI(VKIND) \
pure vector(integer(VKIND)) function func_vi##VKIND##i0vi##VKIND(arg1, arg2); \
integer(8), intent(in) :: arg1; \
!dir$ ignore_tkr(k) arg1; \
vector(integer(VKIND)), intent(in) :: arg2; \
!dir$ ignore_tkr(r) arg2; \
end function ;
! vector(u) function f(i, vector(u))
#define FUNC_VUI0VU(VKIND) \
pure vector(unsigned(VKIND)) function func_vu##VKIND##i0vu##VKIND(arg1, arg2); \
integer(8), intent(in) :: arg1; \
!dir$ ignore_tkr(k) arg1; \
vector(unsigned(VKIND)), intent(in) :: arg2; \
!dir$ ignore_tkr(r) arg2; \
end function ;
! vector(r) function f(i, vector(r))
#define FUNC_VRI0VR(VKIND) \
pure vector(real(VKIND)) function func_vr##VKIND##i0vr##VKIND(arg1, arg2); \
integer(8), intent(in) :: arg1; \
!dir$ ignore_tkr(k) arg1; \
vector(real(VKIND)), intent(in) :: arg2; \
!dir$ ignore_tkr(r) arg2; \
end function ;
! vector(u(1)) function f(i, i)
#define FUNC_VU1I0I(KIND) \
vector(unsigned(1)) function func_vu1i0i##KIND(arg1, arg2); \
integer(8), intent(in) :: arg1; \
!dir$ ignore_tkr(k) arg1; \
integer(KIND), intent(in) :: arg2; \
!dir$ ignore_tkr(r) arg2; \
end function ;
! vector(u(1)) function f(i, r)
#define FUNC_VU1I0R(KIND) \
vector(unsigned(1)) function func_vu1i0r##KIND(arg1, arg2); \
integer(8), intent(in) :: arg1; \
!dir$ ignore_tkr(k) arg1; \
real(KIND), intent(in) :: arg2; \
!dir$ ignore_tkr(r) arg2; \
end function ;
! __vector_pair function f(i, vector(i))
#define FUNC_VPI0VI(VKIND) \
pure __vector_pair function func_vpi0vi##VKIND(arg1, arg2); \
integer(8), intent(in) :: arg1; \
!dir$ ignore_tkr(k) arg1; \
vector(integer(VKIND)), intent(in) :: arg2; \
!dir$ ignore_tkr(r) arg2; \
end function;
! __vector_pair function f(i, vector(u))
#define FUNC_VPI0VU(VKIND) \
pure __vector_pair function func_vpi0vu##VKIND(arg1, arg2); \
integer(8), intent(in) :: arg1; \
!dir$ ignore_tkr(k) arg1; \
vector(unsigned(VKIND)), intent(in) :: arg2; \
!dir$ ignore_tkr(r) arg2; \
end function;
! __vector_pair function f(i, vector(r))
#define FUNC_VPI0VR(VKIND) \
pure __vector_pair function func_vpi0vr##VKIND(arg1, arg2); \
integer(8), intent(in) :: arg1; \
!dir$ ignore_tkr(k) arg1; \
vector(real(VKIND)), intent(in) :: arg2; \
!dir$ ignore_tkr(r) arg2; \
end function;
! __vector_pair function f(i, __vector_pair)
#define FUNC_VPI0VP \
pure __vector_pair function func_vpi0vp(arg1, arg2); \
integer(8), intent(in) :: arg1; \
!dir$ ignore_tkr(k) arg1; \
__vector_pair, intent(in) :: arg2; \
!dir$ ignore_tkr(r) arg2; \
end function;
! The following macros are specific for the vec_convert(v, mold) intrinsics as
! the argument keywords are different from the other vector intrinsics.
!
! vector(i) function f(vector(i), vector(i))
#define FUNC_VEC_CONVERT_VIVIVI(VKIND) \
pure vector(integer(VKIND)) function func_vec_convert_vi##VKIND##vi##vi##VKIND(v, mold); \
vector(integer(8)), intent(in) :: v; \
!dir$ ignore_tkr(tk) v; \
vector(integer(VKIND)), intent(in) :: mold; \
!dir$ ignore_tkr(r) mold; \
end function ;
! vector(u) function f(vector(i), vector(u))
#define FUNC_VEC_CONVERT_VUVIVU(VKIND) \
pure vector(unsigned(VKIND)) function func_vec_convert_vu##VKIND##vi##vu##VKIND(v, mold); \
vector(integer(8)), intent(in) :: v; \
!dir$ ignore_tkr(tk) v; \
vector(unsigned(VKIND)), intent(in) :: mold; \
!dir$ ignore_tkr(r) mold; \
end function ;
! vector(r) function f(vector(i), vector(r))
#define FUNC_VEC_CONVERT_VRVIVR(VKIND) \
pure vector(real(VKIND)) function func_vec_convert_vr##VKIND##vi##vr##VKIND(v, mold); \
vector(integer(8)), intent(in) :: v; \
!dir$ ignore_tkr(tk) v; \
vector(real(VKIND)), intent(in) :: mold; \
!dir$ ignore_tkr(r) mold; \
end function ;
FUNC_VEC_CONVERT_VIVIVI(1) FUNC_VEC_CONVERT_VIVIVI(2) FUNC_VEC_CONVERT_VIVIVI(4) FUNC_VEC_CONVERT_VIVIVI(8)
FUNC_VEC_CONVERT_VUVIVU(1) FUNC_VEC_CONVERT_VUVIVU(2) FUNC_VEC_CONVERT_VUVIVU(4) FUNC_VEC_CONVERT_VUVIVU(8)
FUNC_VEC_CONVERT_VRVIVR(4) FUNC_VEC_CONVERT_VRVIVR(8)
ELEM_FUNC_IVII(1) ELEM_FUNC_IVII(2) ELEM_FUNC_IVII(4) ELEM_FUNC_IVII(8)
ELEM_FUNC_RVRI(4) ELEM_FUNC_RVRI(8)
ELEM_FUNC_VIVIVI(1) ELEM_FUNC_VIVIVI(2) ELEM_FUNC_VIVIVI(4) ELEM_FUNC_VIVIVI(8)
ELEM_FUNC_VUVIVI(1) ELEM_FUNC_VUVIVI(2) ELEM_FUNC_VUVIVI(4) ELEM_FUNC_VUVIVI(8)
ELEM_FUNC_VUVUVU(1) ELEM_FUNC_VUVUVU(2) ELEM_FUNC_VUVUVU(4) ELEM_FUNC_VUVUVU(8)
ELEM_FUNC_VIVIVU(1) ELEM_FUNC_VIVIVU(2) ELEM_FUNC_VIVIVU(4) ELEM_FUNC_VIVIVU(8)
ELEM_FUNC_VIVIVU_2(1,2) ELEM_FUNC_VIVIVU_2(1,4)
ELEM_FUNC_VIVIVU_2(2,1) ELEM_FUNC_VIVIVU_2(2,4)
ELEM_FUNC_VIVIVU_2(4,1) ELEM_FUNC_VIVIVU_2(4,2)
ELEM_FUNC_VUVUVU_2(1,2) ELEM_FUNC_VUVUVU_2(1,4)
ELEM_FUNC_VUVUVU_2(2,1) ELEM_FUNC_VUVUVU_2(2,4)
ELEM_FUNC_VUVUVU_2(4,1) ELEM_FUNC_VUVUVU_2(4,2)
ELEM_FUNC_VRVRVU_2(4,1) ELEM_FUNC_VRVRVU_2(4,2)
ELEM_FUNC_VRVRVR(4) ELEM_FUNC_VRVRVR(8)
ELEM_FUNC_VUVRVR(4) ELEM_FUNC_VUVRVR(8)
ELEM_FUNC_IVIVI(4,1) ELEM_FUNC_IVIVI(4,2) ELEM_FUNC_IVIVI(4,4) ELEM_FUNC_IVIVI(4,8)
ELEM_FUNC_IVUVU(4,1) ELEM_FUNC_IVUVU(4,2) ELEM_FUNC_IVUVU(4,4) ELEM_FUNC_IVUVU(4,8)
ELEM_FUNC_IVRVR(4,4) ELEM_FUNC_IVRVR(4,8)
ELEM_FUNC_VRVII(4) ELEM_FUNC_VRVII(8)
ELEM_FUNC_VRVUI(4) ELEM_FUNC_VRVUI(8)
ELEM_FUNC_VIVII0(1) ELEM_FUNC_VIVII0(2) ELEM_FUNC_VIVII0(4) ELEM_FUNC_VIVII0(8)
ELEM_FUNC_VUVUI0(1) ELEM_FUNC_VUVUI0(2) ELEM_FUNC_VUVUI0(4) ELEM_FUNC_VUVUI0(8)
ELEM_FUNC_VRVRI0(4) ELEM_FUNC_VRVRI0(8)
FUNC_VII0VI(1) FUNC_VII0VI(2) FUNC_VII0VI(4) FUNC_VII0VI(8)
FUNC_VUI0VU(1) FUNC_VUI0VU(2) FUNC_VUI0VU(4) FUNC_VUI0VU(8)
FUNC_VRI0VR(4) FUNC_VRI0VR(8)
FUNC_VII0I(1) FUNC_VII0I(2) FUNC_VII0I(4) FUNC_VII0I(8)
FUNC_VRI0R(4) FUNC_VRI0R(8)
FUNC_VPI0VI(1) FUNC_VPI0VI(2) FUNC_VPI0VI(4) FUNC_VPI0VI(8)
FUNC_VPI0VU(1) FUNC_VPI0VU(2) FUNC_VPI0VU(4) FUNC_VPI0VU(8)
FUNC_VPI0VR(4) FUNC_VPI0VR(8)
FUNC_VPI0VP
FUNC_VU1I0I(1) FUNC_VU1I0I(2) FUNC_VU1I0I(4)
FUNC_VU1I0R(4)
#undef FUNC_VEC_CONVERT_VRVIVR
#undef FUNC_VEC_CONVERT_VUVIVU
#undef FUNC_VEC_CONVERT_VIVIVI
#undef FUNC_VPI0VP
#undef FUNC_VPI0VR
#undef FUNC_VPI0VU
#undef FUNC_VPI0VI
#undef FUNC_VU1I0R
#undef FUNC_VU1I0I
#undef FUNC_VRI0VR
#undef FUNC_VUI0VU
#undef FUNC_VII0VI
#undef FUNC_VRI0R
#undef FUNC_VII0I
#undef ELEM_FUNC_VRVRI0
#undef ELEM_FUNC_VUVUI0
#undef ELEM_FUNC_VIVII0
#undef ELEM_FUNC_RVRI
#undef ELEM_FUNC_VRVUI
#undef ELEM_FUNC_IVII
#undef ELEM_FUNC_VRVII
#undef ELEM_FUNC_IVRVR
#undef ELEM_FUNC_IVUVU
#undef ELEM_FUNC_IVIVI
#undef ELEM_FUNC_VUVRVR
#undef ELEM_FUNC_VRVRVU_2
#undef ELEM_FUNC_VRVRVR
#undef ELEM_FUNC_VUVUVU
#undef ELEM_FUNC_VUVUVU_2
#undef ELEM_FUNC_VIVIVU
#undef ELEM_FUNC_VIVIVU_2
#undef ELEM_FUNC_VUVIVI
#undef ELEM_FUNC_VIVIVI
!! ================ 3 arguments function interface ================
! vector(r) function f(vector(r), vector(r), vector(r))
#define ELEM_FUNC_VRVRVRVR(VKIND) \
elemental vector(real(VKIND)) function elem_func_vr##VKIND##vr##VKIND##vr##VKIND##vr##VKIND(arg1, arg2, arg3); \
vector(real(VKIND)), intent(in) :: arg1, arg2, arg3; \
end function ;
! vector(i) function f(vector(i), vector(i), vector(u))
#define ELEM_FUNC_VIVIVIVU_2(VKIND, UKIND) \
elemental vector(integer(VKIND)) function elem_func_vi##VKIND##vi##VKIND##vi##VKIND##vu##UKIND(arg1, arg2, arg3); \
vector(integer(VKIND)), intent(in) :: arg1, arg2; \
vector(unsigned(UKIND)), intent(in) :: arg3; \
end function ;
#define ELEM_FUNC_VIVIVIVU(VKIND) ELEM_FUNC_VIVIVIVU_2(VKIND, VKIND)
! vector(u) function f(vector(u), vector(u), vector(u))
#define ELEM_FUNC_VUVUVUVU_2(VKIND, UKIND) \
elemental vector(unsigned(VKIND)) function elem_func_vu##VKIND##vu##VKIND##vu##VKIND##vu##UKIND(arg1, arg2, arg3); \
vector(unsigned(VKIND)), intent(in) :: arg1, arg2; \
vector(unsigned(UKIND)), intent(in) :: arg3; \
end function ;
#define ELEM_FUNC_VUVUVUVU(VKIND) ELEM_FUNC_VUVUVUVU_2(VKIND, VKIND)
! vector(r) function f(vector(r), vector(r), vector(u))
#define ELEM_FUNC_VRVRVRVU_2(VKIND, UKIND) \
elemental vector(real(VKIND)) function elem_func_vr##VKIND##vr##VKIND##vr##VKIND##vu##UKIND(arg1, arg2, arg3); \
vector(real(VKIND)), intent(in) :: arg1, arg2; \
vector(unsigned(UKIND)), intent(in) :: arg3; \
end function ;
#define ELEM_FUNC_VRVRVRVU(VKIND) ELEM_FUNC_VRVRVRVU_2(VKIND, VKIND)
! vector(i) function f(vector(i), vector(i), i)
#define ELEM_FUNC_VIVIVII(VKIND) \
elemental vector(integer(VKIND)) function elem_func_vi##VKIND##vi##VKIND##vi##VKIND##i(arg1, arg2, arg3); \
vector(integer(VKIND)), intent(in) :: arg1, arg2; \
integer(8), intent(in) :: arg3; \
!dir$ ignore_tkr(k) arg3; \
end function ;
! vector(u) function f(vector(u), vector(u), i)
#define ELEM_FUNC_VUVUVUI(VKIND) \
elemental vector(unsigned(VKIND)) function elem_func_vu##VKIND##vu##VKIND##vu##VKIND##i(arg1, arg2, arg3); \
vector(unsigned(VKIND)), intent(in) :: arg1, arg2; \
integer(8), intent(in) :: arg3; \
!dir$ ignore_tkr(k) arg3; \
end function ;
! vector(r) function f(vector(r), vector(r), i)
#define ELEM_FUNC_VRVRVRI(VKIND) \
elemental vector(real(VKIND)) function elem_func_vr##VKIND##vr##VKIND##vr##VKIND##i(arg1, arg2, arg3); \
vector(real(VKIND)), intent(in) :: arg1, arg2; \
integer(8), intent(in) :: arg3; \
!dir$ ignore_tkr(k) arg3; \
end function ;
! vector(i) function f(i, vector(i), i)
#define ELEM_FUNC_VIIVII(VKIND) \
elemental vector(integer(VKIND)) function elem_func_vi##VKIND##i##VKIND##vi##VKIND##i(arg1, arg2, arg3); \
integer(VKIND), intent(in) :: arg1; \
vector(integer(VKIND)), intent(in) :: arg2; \
integer(8), intent(in) :: arg3; \
!dir$ ignore_tkr(k) arg3; \
end function ;
! vector(r) function f(r, vector(r), i)
#define ELEM_FUNC_VRRVRI(VKIND) \
elemental vector(real(VKIND)) function elem_func_vr##VKIND##r##VKIND##vr##VKIND##i(arg1, arg2, arg3); \
real(VKIND), intent(in) :: arg1; \
vector(real(VKIND)), intent(in) :: arg2; \
integer(8), intent(in) :: arg3; \
!dir$ ignore_tkr(k) arg3; \
end function ;
ELEM_FUNC_VIVIVIVU(1) ELEM_FUNC_VIVIVIVU(2) ELEM_FUNC_VIVIVIVU(4) ELEM_FUNC_VIVIVIVU(8)
ELEM_FUNC_VUVUVUVU(1) ELEM_FUNC_VUVUVUVU(2) ELEM_FUNC_VUVUVUVU(4) ELEM_FUNC_VUVUVUVU(8)
ELEM_FUNC_VRVRVRVU(4) ELEM_FUNC_VRVRVRVU(8)
ELEM_FUNC_VIVIVIVU_2(2,1) ELEM_FUNC_VIVIVIVU_2(4,1) ELEM_FUNC_VIVIVIVU_2(8,1)
ELEM_FUNC_VUVUVUVU_2(2,1) ELEM_FUNC_VUVUVUVU_2(4,1) ELEM_FUNC_VUVUVUVU_2(8,1)
ELEM_FUNC_VRVRVRVU_2(4,1) ELEM_FUNC_VRVRVRVU_2(8,1)
ELEM_FUNC_VIIVII(1) ELEM_FUNC_VIIVII(2) ELEM_FUNC_VIIVII(4) ELEM_FUNC_VIIVII(8)
ELEM_FUNC_VRRVRI(4) ELEM_FUNC_VRRVRI(8)
ELEM_FUNC_VRVRVRVR(4) ELEM_FUNC_VRVRVRVR(8)
ELEM_FUNC_VIVIVII(1) ELEM_FUNC_VIVIVII(2) ELEM_FUNC_VIVIVII(4) ELEM_FUNC_VIVIVII(8)
ELEM_FUNC_VUVUVUI(1) ELEM_FUNC_VUVUVUI(2) ELEM_FUNC_VUVUVUI(4) ELEM_FUNC_VUVUVUI(8)
ELEM_FUNC_VRVRVRI(4) ELEM_FUNC_VRVRVRI(8)
#undef ELEM_FUNC_VRRVRI
#undef ELEM_FUNC_VIIVII
#undef ELEM_FUNC_VRVRVRI
#undef ELEM_FUNC_VUVUVUI
#undef ELEM_FUNC_VIVIVII
#undef ELEM_FUNC_VRVRVRVU
#undef ELEM_FUNC_VRVRVRVU_2
#undef ELEM_FUNC_VUVUVUVU
#undef ELEM_FUNC_VUVUVUVU_2
#undef ELEM_FUNC_VIVIVIVU
#undef ELEM_FUNC_VIVIVIVU_2
#undef ELEM_FUNC_VRVRVRVR
!! ================ 3 argument subroutine interfaces =================================
! subroutine(vector(i), i, vector(i))
#define SUB_VIIVI(VKIND) \
pure subroutine sub_vi##VKIND##ivi##VKIND(arg1, arg2, arg3); \
vector(integer(VKIND)), intent(in) :: arg1; \
integer(8), intent(in) :: arg2; \
!dir$ ignore_tkr(k) arg2; \
vector(integer(VKIND)), intent(in) :: arg3; \
!dir$ ignore_tkr(r) arg3; \
end subroutine ;
! subroutine(vector(u), i, vector(u))
#define SUB_VUIVU(VKIND) \
pure subroutine sub_vu##VKIND##ivu##VKIND(arg1, arg2, arg3); \
vector(unsigned(VKIND)), intent(in) :: arg1; \
integer(8), intent(in) :: arg2; \
!dir$ ignore_tkr(k) arg2; \
vector(unsigned(VKIND)), intent(in) :: arg3; \
!dir$ ignore_tkr(r) arg3; \
end subroutine ;
! subroutine(vector(r), i, vector(r))
#define SUB_VRIVR(VKIND) \
pure subroutine sub_vr##VKIND##ivr##VKIND(arg1, arg2, arg3); \
vector(real(VKIND)), intent(in) :: arg1; \
integer(8), intent(in) :: arg2; \
!dir$ ignore_tkr(k) arg2; \
vector(real(VKIND)), intent(in) :: arg3; \
!dir$ ignore_tkr(r) arg3; \
end subroutine ;
! subroutine(vector(i), i, i)
#define SUB_VIII(VKIND) \
pure subroutine sub_vi##VKIND##ii##VKIND(arg1, arg2, arg3); \
vector(integer(VKIND)), intent(in) :: arg1; \
integer(8), intent(in) :: arg2; \
!dir$ ignore_tkr(k) arg2; \
integer(VKIND), intent(out) :: arg3; \
!dir$ ignore_tkr(r) arg3; \
end subroutine ;
! subroutine(vector(u), i, i)
#define SUB_VUII(VKIND) \
pure subroutine sub_vu##VKIND##ii##VKIND(arg1, arg2, arg3); \
vector(unsigned(VKIND)), intent(in) :: arg1; \
integer(8), intent(in) :: arg2; \
!dir$ ignore_tkr(k) arg2; \
integer(VKIND), intent(out) :: arg3; \
!dir$ ignore_tkr(r) arg3; \
end subroutine ;
! subroutine(vector(r), i, r)
#define SUB_VRIR(VKIND) \
pure subroutine sub_vr##VKIND##ir##VKIND(arg1, arg2, arg3); \
vector(real(VKIND)), intent(in) :: arg1; \
integer(8), intent(in) :: arg2; \
!dir$ ignore_tkr(k) arg2; \
real(VKIND), intent(out) :: arg3; \
!dir$ ignore_tkr(r) arg3; \
end subroutine ;
! subroutine(__vector_pair, i, __vector_pair)
pure subroutine sub_vpi0vp(arg1, arg2, arg3)
__vector_pair, intent(in) :: arg1
integer(8), intent(in) :: arg2
!dir$ ignore_tkr(k) arg2
__vector_pair, intent(out) :: arg3
!dir$ ignore_tkr(r) arg3
end subroutine
! subroutine(__vector_pair, i, vector(i))
#define SUB_VPI0VI(VKIND) \
pure subroutine sub_vpi0vi##VKIND(arg1, arg2, arg3); \
__vector_pair, intent(in) :: arg1; \
integer(8), intent(in) :: arg2; \
!dir$ ignore_tkr(k) arg2; \
vector(integer(VKIND)), intent(out) :: arg3; \
!dir$ ignore_tkr(r) arg3; \
end subroutine;
! subroutine(__vector_pair, i, vector(u))
#define SUB_VPI0VU(VKIND) \
pure subroutine sub_vpi0vu##VKIND(arg1, arg2, arg3); \
__vector_pair, intent(in) :: arg1; \
integer(8), intent(in) :: arg2; \
!dir$ ignore_tkr(k) arg2; \
vector(unsigned(VKIND)), intent(out) :: arg3; \
!dir$ ignore_tkr(r) arg3; \
end subroutine;
! subroutine(__vector_pair, i, vector(r))
#define SUB_VPI0VR(VKIND) \
pure subroutine sub_vpi0vr##VKIND(arg1, arg2, arg3); \
__vector_pair, intent(in) :: arg1; \
integer(8), intent(in) :: arg2; \
!dir$ ignore_tkr(k) arg2; \
vector(real(VKIND)), intent(out) :: arg3; \
!dir$ ignore_tkr(r) arg3; \
end subroutine;
! subroutine(__vector_pair, i, i)
pure subroutine sub_vpi0i0(arg1, arg2, arg3)
__vector_pair, intent(in) :: arg1
integer(8), intent(in) :: arg2
!dir$ ignore_tkr(k) arg2
integer(8), intent(out) :: arg3
!dir$ ignore_tkr(kr) arg3
end subroutine
! subroutine(__vector_pair, i, r)
pure subroutine sub_vpi0r0(arg1, arg2, arg3)
__vector_pair, intent(in) :: arg1
integer(8), intent(in) :: arg2
!dir$ ignore_tkr(k) arg2
real(8), intent(out) :: arg3
!dir$ ignore_tkr(kr) arg3
end subroutine
SUB_VIIVI(1) SUB_VIIVI(2) SUB_VIIVI(4) SUB_VIIVI(8)
SUB_VUIVU(1) SUB_VUIVU(2) SUB_VUIVU(4) SUB_VUIVU(8)
SUB_VRIVR(4) SUB_VRIVR(8)
SUB_VIII(1) SUB_VIII(2) SUB_VIII(4) SUB_VIII(8)
SUB_VUII(1) SUB_VUII(2) SUB_VUII(4) SUB_VUII(8)
SUB_VRIR(4) SUB_VRIR(8)
SUB_VPI0VI(1) SUB_VPI0VI(2) SUB_VPI0VI(4) SUB_VPI0VI(8)
SUB_VPI0VU(1) SUB_VPI0VU(2) SUB_VPI0VU(4) SUB_VPI0VU(8)
SUB_VPI0VR(4) SUB_VPI0VR(8)
#undef SUB_VPI0VR
#undef SUB_VPI0VU
#undef SUB_VPI0VI
#undef SUB_VRIR
#undef SUB_VUII
#undef SUB_VIII
#undef SUB_VRIVR
#undef SUB_VUIVU
#undef SUB_VIIVI
end interface
procedure(func_r4r4r4r4) :: __ppc_fmadd_r4
procedure(func_r8r8r8r8) :: __ppc_fmadd_r8
interface fmadd
procedure :: __ppc_fmadd_r4
procedure :: __ppc_fmadd_r8
end interface fmadd
public :: fmadd
procedure(func_r4r4r4r4) :: __ppc_fmsub_r4
procedure(func_r8r8r8r8) :: __ppc_fmsub_r8
interface fmsub
procedure :: __ppc_fmsub_r4
procedure :: __ppc_fmsub_r8
end interface fmsub
public :: fmsub
procedure(func_r4r4r4r4) :: __ppc_fnmadd_r4
procedure(func_r8r8r8r8) :: __ppc_fnmadd_r8
interface fnmadd
procedure :: __ppc_fnmadd_r4
procedure :: __ppc_fnmadd_r8
end interface fnmadd
public :: fnmadd
procedure(func_r4r4r4r4) :: __ppc_fnmsub_r4
procedure(func_r8r8r8r8) :: __ppc_fnmsub_r8
interface fnmsub
procedure :: __ppc_fnmsub_r4
procedure :: __ppc_fnmsub_r8
end interface fnmsub
public :: fnmsub
! fctid, fctidz, fctiw, fctiwz, fctudz, fctuwz
abstract interface
elemental real(4) function func_r4r4x(x)
real(4), intent(in) :: x
end function func_r4r4x
elemental real(8) function func_r8r8x(x)
real(8), intent(in) :: x
end function func_r8r8x
end interface
procedure(func_r8r8x) :: __ppc_fctid
interface fctid
procedure :: __ppc_fctid
end interface fctid
public :: fctid
procedure(func_r8r8x) :: __ppc_fctidz
interface fctidz
procedure :: __ppc_fctidz
end interface fctidz
public :: fctidz
procedure(func_r8r8x) :: __ppc_fctiw
interface fctiw
procedure :: __ppc_fctiw
end interface fctiw
public :: fctiw
procedure(func_r8r8x) :: __ppc_fctiwz
interface fctiwz
procedure :: __ppc_fctiwz
end interface fctiwz
public :: fctiwz
procedure(func_r8r8x) :: __ppc_fctudz
interface fctudz
procedure :: __ppc_fctudz
end interface fctudz
public :: fctudz
procedure(func_r8r8x) :: __ppc_fctuwz
interface fctuwz
procedure :: __ppc_fctuwz
end interface fctuwz
public :: fctuwz
! fcfi, fcfid, fcfud
abstract interface
elemental real(8) function func_r8r8i(i)
real(8), intent(in) :: i
end function func_r8r8i
end interface
procedure(func_r8r8i) :: __ppc_fcfi
interface fcfi
procedure :: __ppc_fcfi
end interface fcfi
public :: fcfi
procedure(func_r8r8i) :: __ppc_fcfid
interface fcfid
procedure :: __ppc_fcfid
end interface fcfid
public :: fcfid
procedure(func_r8r8i) :: __ppc_fcfud
interface fcfud
procedure :: __ppc_fcfud
end interface fcfud
public :: fcfud
! fnabs
procedure(func_r4r4x) :: __ppc_fnabs_r4
procedure(func_r8r8x) :: __ppc_fnabs_r8
interface fnabs
procedure :: __ppc_fnabs_r4
procedure :: __ppc_fnabs_r8
end interface fnabs
public :: fnabs
! fre, fres
procedure(func_r8r8x) :: __ppc_fre
interface fre
procedure :: __ppc_fre
end interface fre
public :: fre
procedure(func_r4r4x) :: __ppc_fres
interface fres
procedure :: __ppc_fres
end interface fres
public :: fres
! frsqrte, frsqrtes
procedure(func_r8r8x) :: __ppc_frsqrte
interface frsqrte
procedure :: __ppc_frsqrte
end interface frsqrte
public :: frsqrte
procedure(func_r4r4x) :: __ppc_frsqrtes
interface frsqrtes
procedure :: __ppc_frsqrtes
end interface frsqrtes
public :: frsqrtes
! mtfsf, mtfsfi
interface mtfsf
subroutine __ppc_mtfsf(mask, r)
integer(4), intent(in) :: mask
real(8), intent(in) :: r
end subroutine __ppc_mtfsf
end interface mtfsf
public :: mtfsf
interface mtfsfi
subroutine __ppc_mtfsfi(bf, i)
integer(4), intent(in) :: bf
integer(4), intent(in) :: i
end subroutine __ppc_mtfsfi
end interface mtfsfi
public :: mtfsfi
!-----------------------------
! vector function(vector/i/r)
!-----------------------------
#define VI_VI(NAME, VKIND) __ppc_##NAME##_vi##VKIND##vi##VKIND
#define VU_VU(NAME, VKIND) __ppc_##NAME##_vu##VKIND##vu##VKIND
#define VR_VR_2(NAME, VKIND1, VKIND2) __ppc_##NAME##_vr##VKIND1##vr##VKIND2
#define VR_VR(NAME, VKIND) VR_VR_2(NAME, VKIND, VKIND)
#define VI_I_2(NAME, RKIND, VKIND) __ppc_##NAME##_vi##RKIND##i##VKIND
#define VI_I(NAME, VKIND) VI_I_2(NAME, VKIND, VKIND)
#define VR_R(NAME, VKIND) __ppc_##NAME##_vr##VKIND##r##VKIND
#define VEC_VI_VI(NAME, VKIND) \
procedure(elem_func_vi##VKIND##vi##VKIND) :: VI_VI(NAME, VKIND);
#define VEC_VU_VU(NAME, VKIND) \
procedure(elem_func_vu##VKIND##vu##VKIND) :: VU_VU(NAME, VKIND);
#define VEC_VR_VR_2(NAME, VKIND1, VKIND2) \
procedure(elem_func_vr##VKIND1##vr##VKIND2) :: VR_VR_2(NAME, VKIND1, VKIND2);
#define VEC_VR_VR(NAME, VKIND) VEC_VR_VR_2(NAME, VKIND, VKIND)
#define VEC_VI_I_2(NAME, RKIND, VKIND) \
procedure(elem_func_vi##RKIND##i##VKIND) :: VI_I_2(NAME, RKIND, VKIND);
#define VEC_VI_I(NAME, VKIND) VEC_VI_I_2(NAME, VKIND, VKIND)
#define VEC_VR_R(NAME, VKIND) \
procedure(elem_func_vr##VKIND##r##VKIND) :: VR_R(NAME, VKIND);
! vec_abs
VEC_VI_VI(vec_abs,1) VEC_VI_VI(vec_abs,2) VEC_VI_VI(vec_abs,4) VEC_VI_VI(vec_abs,8)
VEC_VR_VR(vec_abs,4) VEC_VR_VR(vec_abs,8)
interface vec_abs
procedure :: VI_VI(vec_abs,1), VI_VI(vec_abs,2), VI_VI(vec_abs,4), VI_VI(vec_abs,8)
procedure :: VR_VR(vec_abs,4), VR_VR(vec_abs,8)
end interface vec_abs
public :: vec_abs
! vec_cvf
VEC_VR_VR_2(vec_cvf,4,8) VEC_VR_VR_2(vec_cvf,8,4)
interface vec_cvf
procedure :: VR_VR_2(vec_cvf,4,8), VR_VR_2(vec_cvf,8,4)
end interface vec_cvf
public :: vec_cvf
! vec_cvbf16spn
VEC_VU_VU(vec_cvbf16spn,1)
interface vec_cvbf16spn
procedure :: VU_VU(vec_cvbf16spn,1)
end interface
public vec_cvbf16spn
! vec_cvspbf16
VEC_VU_VU(vec_cvspbf16_,1)
interface vec_cvspbf16
procedure :: VU_VU(vec_cvspbf16_,1)
end interface
public vec_cvspbf16
! vec_splats
VEC_VI_I(vec_splats,1) VEC_VI_I(vec_splats,2) VEC_VI_I(vec_splats,4) VEC_VI_I(vec_splats,8)
VEC_VR_R(vec_splats,4) VEC_VR_R(vec_splats,8)
interface vec_splats
procedure :: VI_I(vec_splats,1), VI_I(vec_splats,2), VI_I(vec_splats,4), VI_I(vec_splats,8)
procedure :: VR_R(vec_splats,4), VR_R(vec_splats,8)
end interface vec_splats
public :: vec_splats
! vec_splat_32
VEC_VI_I_2(vec_splat_s32_,4,1) VEC_VI_I_2(vec_splat_s32_,4,2) VEC_VI_I_2(vec_splat_s32_,4,4) VEC_VI_I_2(vec_splat_s32_,4,8)
interface vec_splat_s32
procedure :: VI_I_2(vec_splat_s32_,4,1), VI_I_2(vec_splat_s32_,4,2), VI_I_2(vec_splat_s32_,4,4), VI_I_2(vec_splat_s32_,4,8)
end interface vec_splat_s32
public :: vec_splat_s32
#undef VEC_VR_R
#undef VEC_VI_I
#undef VEC_VI_I_2
#undef VEC_VR_VR
#undef VEC_VR_VR_2
#undef VEC_VU_VU
#undef VEC_VI_VI
#undef VR_R
#undef VI_I
#undef VI_I_2
#undef VR_VR
#undef VR_VR_2
#undef VU_VU
#undef VI_VI
!---------------------------------
! vector function(vector, vector)
!---------------------------------
#define VI_VI_VI(NAME, VKIND) __ppc_##NAME##_vi##VKIND##vi##VKIND##vi##VKIND
#define VU_VI_VI(NAME, VKIND) __ppc_##NAME##_vu##VKIND##vi##VKIND##vi##VKIND
#define VU_VU_VU_2(NAME, VKIND1, VKIND2) __ppc_##NAME##_vu##VKIND1##vu##VKIND1##vu##VKIND2
#define VU_VU_VU(NAME, VKIND) VU_VU_VU_2(NAME, VKIND, VKIND)
#define VI_VI_VU_2(NAME, VKIND1, VKIND2) __ppc_##NAME##_vi##VKIND1##vi##VKIND1##vu##VKIND2
#define VI_VI_VU(NAME, VKIND) VI_VI_VU_2(NAME, VKIND, VKIND)
#define VR_VR_VR(NAME, VKIND) __ppc_##NAME##_vr##VKIND##vr##VKIND##vr##VKIND
#define VR_VR_VU_2(NAME, VKIND1, VKIND2) __ppc_##NAME##_vr##VKIND1##vr##VKIND1##vu##VKIND2
#define VU_VR_VR(NAME, VKIND) __ppc_##NAME##_vu##VKIND##vr##VKIND##vr##VKIND
#define VEC_VI_VI_VI(NAME, VKIND) \
procedure(elem_func_vi##VKIND##vi##VKIND##vi##VKIND) :: VI_VI_VI(NAME, VKIND);
#define VEC_VU_VI_VI(NAME, VKIND) \
procedure(elem_func_vu##VKIND##vi##VKIND##vi##VKIND) :: VU_VI_VI(NAME, VKIND);
#define VEC_VU_VU_VU_2(NAME, VKIND1, VKIND2) \
procedure(elem_func_vu##VKIND1##vu##VKIND1##vu##VKIND2) :: VU_VU_VU_2(NAME, VKIND1, VKIND2);
#define VEC_VU_VU_VU(NAME, VKIND) VEC_VU_VU_VU_2(NAME, VKIND, VKIND)
#define VEC_VI_VI_VU_2(NAME, VKIND1, VKIND2) \
procedure(elem_func_vi##VKIND1##vi##VKIND1##vu##VKIND2) :: VI_VI_VU_2(NAME, VKIND1, VKIND2);
#define VEC_VI_VI_VU(NAME, VKIND) VEC_VI_VI_VU_2(NAME, VKIND, VKIND)
#define VEC_VR_VR_VR(NAME, VKIND) \
procedure(elem_func_vr##VKIND##vr##VKIND##vr##VKIND) :: VR_VR_VR(NAME, VKIND);
#define VEC_VU_VR_VR(NAME, VKIND) \
procedure(elem_func_vu##VKIND##vr##VKIND##vr##VKIND) :: VU_VR_VR(NAME, VKIND);
#define VEC_VR_VR_VU(NAME, VKIND1, VKIND2) \
procedure(elem_func_vr##VKIND1##vr##VKIND1##vu##VKIND2) :: VR_VR_VU_2(NAME, VKIND1, VKIND2);
! vec_add
VEC_VI_VI_VI(vec_add,1) VEC_VI_VI_VI(vec_add,2) VEC_VI_VI_VI(vec_add,4) VEC_VI_VI_VI(vec_add,8)
VEC_VU_VU_VU(vec_add,1) VEC_VU_VU_VU(vec_add,2) VEC_VU_VU_VU(vec_add,4) VEC_VU_VU_VU(vec_add,8)
VEC_VR_VR_VR(vec_add,4) VEC_VR_VR_VR(vec_add,8)
interface vec_add
procedure :: VI_VI_VI(vec_add,1), VI_VI_VI(vec_add,2), VI_VI_VI(vec_add,4), VI_VI_VI(vec_add,8)
procedure :: VU_VU_VU(vec_add,1), VU_VU_VU(vec_add,2), VU_VU_VU(vec_add,4), VU_VU_VU(vec_add,8)
procedure :: VR_VR_VR(vec_add,4), VR_VR_VR(vec_add,8)
end interface vec_add
public :: vec_add
! vec_and
VEC_VI_VI_VI(vec_and,1) VEC_VI_VI_VI(vec_and,2) VEC_VI_VI_VI(vec_and,4) VEC_VI_VI_VI(vec_and,8)
VEC_VU_VU_VU(vec_and,1) VEC_VU_VU_VU(vec_and,2) VEC_VU_VU_VU(vec_and,4) VEC_VU_VU_VU(vec_and,8)
VEC_VR_VR_VR(vec_and,4) VEC_VR_VR_VR(vec_and,8)
interface vec_and
procedure :: VI_VI_VI(vec_and,1), VI_VI_VI(vec_and,2), VI_VI_VI(vec_and,4), VI_VI_VI(vec_and,8)
procedure :: VU_VU_VU(vec_and,1), VU_VU_VU(vec_and,2), VU_VU_VU(vec_and,4), VU_VU_VU(vec_and,8)
procedure :: VR_VR_VR(vec_and,4), VR_VR_VR(vec_and,8)
end interface vec_and
public :: vec_and
! vec_cmpge
VEC_VU_VI_VI(vec_cmpge,1) VEC_VU_VI_VI(vec_cmpge,2) VEC_VU_VI_VI(vec_cmpge,4) VEC_VU_VI_VI(vec_cmpge,8)
VEC_VU_VU_VU(vec_cmpge,1) VEC_VU_VU_VU(vec_cmpge,2) VEC_VU_VU_VU(vec_cmpge,4) VEC_VU_VU_VU(vec_cmpge,8)
VEC_VU_VR_VR(vec_cmpge,4) VEC_VU_VR_VR(vec_cmpge,8)
interface vec_cmpge
procedure :: VU_VI_VI(vec_cmpge,1), VU_VI_VI(vec_cmpge,2), VU_VI_VI(vec_cmpge,4), VU_VI_VI(vec_cmpge,8)
procedure :: VU_VU_VU(vec_cmpge,1), VU_VU_VU(vec_cmpge,2), VU_VU_VU(vec_cmpge,4), VU_VU_VU(vec_cmpge,8)
procedure :: VU_VR_VR(vec_cmpge,4), VU_VR_VR(vec_cmpge,8)
end interface vec_cmpge
public :: vec_cmpge
! vec_cmpgt
VEC_VU_VI_VI(vec_cmpgt,1) VEC_VU_VI_VI(vec_cmpgt,2) VEC_VU_VI_VI(vec_cmpgt,4) VEC_VU_VI_VI(vec_cmpgt,8)
VEC_VU_VU_VU(vec_cmpgt,1) VEC_VU_VU_VU(vec_cmpgt,2) VEC_VU_VU_VU(vec_cmpgt,4) VEC_VU_VU_VU(vec_cmpgt,8)
VEC_VU_VR_VR(vec_cmpgt,4) VEC_VU_VR_VR(vec_cmpgt,8)
interface vec_cmpgt
procedure :: VU_VI_VI(vec_cmpgt,1), VU_VI_VI(vec_cmpgt,2), VU_VI_VI(vec_cmpgt,4), VU_VI_VI(vec_cmpgt,8)
procedure :: VU_VU_VU(vec_cmpgt,1), VU_VU_VU(vec_cmpgt,2), VU_VU_VU(vec_cmpgt,4), VU_VU_VU(vec_cmpgt,8)
procedure :: VU_VR_VR(vec_cmpgt,4), VU_VR_VR(vec_cmpgt,8)
end interface vec_cmpgt
public :: vec_cmpgt
! vec_cmple
VEC_VU_VI_VI(vec_cmple,1) VEC_VU_VI_VI(vec_cmple,2) VEC_VU_VI_VI(vec_cmple,4) VEC_VU_VI_VI(vec_cmple,8)
VEC_VU_VU_VU(vec_cmple,1) VEC_VU_VU_VU(vec_cmple,2) VEC_VU_VU_VU(vec_cmple,4) VEC_VU_VU_VU(vec_cmple,8)
VEC_VU_VR_VR(vec_cmple,4) VEC_VU_VR_VR(vec_cmple,8)
interface vec_cmple
procedure :: VU_VI_VI(vec_cmple,1), VU_VI_VI(vec_cmple,2), VU_VI_VI(vec_cmple,4), VU_VI_VI(vec_cmple,8)
procedure :: VU_VU_VU(vec_cmple,1), VU_VU_VU(vec_cmple,2), VU_VU_VU(vec_cmple,4), VU_VU_VU(vec_cmple,8)
procedure :: VU_VR_VR(vec_cmple,4), VU_VR_VR(vec_cmple,8)
end interface vec_cmple
public :: vec_cmple
! vec_cmplt
VEC_VU_VI_VI(vec_cmplt,1) VEC_VU_VI_VI(vec_cmplt,2) VEC_VU_VI_VI(vec_cmplt,4) VEC_VU_VI_VI(vec_cmplt,8)
VEC_VU_VU_VU(vec_cmplt,1) VEC_VU_VU_VU(vec_cmplt,2) VEC_VU_VU_VU(vec_cmplt,4) VEC_VU_VU_VU(vec_cmplt,8)
VEC_VU_VR_VR(vec_cmplt,4) VEC_VU_VR_VR(vec_cmplt,8)
interface vec_cmplt
procedure :: VU_VI_VI(vec_cmplt,1), VU_VI_VI(vec_cmplt,2), VU_VI_VI(vec_cmplt,4), VU_VI_VI(vec_cmplt,8)
procedure :: VU_VU_VU(vec_cmplt,1), VU_VU_VU(vec_cmplt,2), VU_VU_VU(vec_cmplt,4), VU_VU_VU(vec_cmplt,8)
procedure :: VU_VR_VR(vec_cmplt,4), VU_VR_VR(vec_cmplt,8)
end interface vec_cmplt
public :: vec_cmplt
! vec_convert
! Argument 'v' has the `ignore_tkr` directive
#define CONVERT_VI_VI_VI(VKIND) __ppc_vec_convert_vi##VKIND##vi##vi##VKIND
#define CONVERT_VU_VI_VU(VKIND) __ppc_vec_convert_vu##VKIND##vi##vu##VKIND
#define CONVERT_VR_VI_VR(VKIND) __ppc_vec_convert_vr##VKIND##vi##vr##VKIND
#define VEC_CONVERT_VI_VI_VI(VKIND) \
procedure(func_vec_convert_vi##VKIND##vi##vi##VKIND) :: CONVERT_VI_VI_VI(VKIND);
#define VEC_CONVERT_VU_VI_VU(VKIND) \
procedure(func_vec_convert_vu##VKIND##vi##vu##VKIND) :: CONVERT_VU_VI_VU(VKIND);
#define VEC_CONVERT_VR_VI_VR(VKIND) \
procedure(func_vec_convert_vr##VKIND##vi##vr##VKIND) :: CONVERT_VR_VI_VR(VKIND);
VEC_CONVERT_VI_VI_VI(1) VEC_CONVERT_VI_VI_VI(2) VEC_CONVERT_VI_VI_VI(4) VEC_CONVERT_VI_VI_VI(8)
VEC_CONVERT_VU_VI_VU(1) VEC_CONVERT_VU_VI_VU(2) VEC_CONVERT_VU_VI_VU(4) VEC_CONVERT_VU_VI_VU(8)
VEC_CONVERT_VR_VI_VR(4) VEC_CONVERT_VR_VI_VR(8)
interface vec_convert
procedure :: CONVERT_VI_VI_VI(1), CONVERT_VI_VI_VI(2), CONVERT_VI_VI_VI(4), CONVERT_VI_VI_VI(8)
procedure :: CONVERT_VU_VI_VU(1), CONVERT_VU_VI_VU(2), CONVERT_VU_VI_VU(4), CONVERT_VU_VI_VU(8)
procedure :: CONVERT_VR_VI_VR(4), CONVERT_VR_VI_VR(8)
end interface vec_convert
public :: vec_convert
#undef VEC_CONVERT_VR_VI_VR
#undef VEC_CONVERT_VU_VI_VU
#undef VEC_CONVERT_VI_VI_VI
#undef CONVERT_VR_VI_VR
#undef CONVERT_VU_VI_VU
#undef CONVERT_VI_VI_VI
! vec_max
VEC_VI_VI_VI(vec_max,1) VEC_VI_VI_VI(vec_max,2) VEC_VI_VI_VI(vec_max,4) VEC_VI_VI_VI(vec_max,8)
VEC_VU_VU_VU(vec_max,1) VEC_VU_VU_VU(vec_max,2) VEC_VU_VU_VU(vec_max,4) VEC_VU_VU_VU(vec_max,8)
VEC_VR_VR_VR(vec_max,4) VEC_VR_VR_VR(vec_max,8)
interface vec_max
procedure :: VI_VI_VI(vec_max,1), VI_VI_VI(vec_max,2), VI_VI_VI(vec_max,4), VI_VI_VI(vec_max,8)
procedure :: VU_VU_VU(vec_max,1), VU_VU_VU(vec_max,2), VU_VU_VU(vec_max,4), VU_VU_VU(vec_max,8)
procedure :: VR_VR_VR(vec_max,4), VR_VR_VR(vec_max,8)
end interface vec_max
public :: vec_max
! vec_mergeh
VEC_VI_VI_VI(vec_mergeh,1) VEC_VI_VI_VI(vec_mergeh,2) VEC_VI_VI_VI(vec_mergeh,4) VEC_VI_VI_VI(vec_mergeh,8)
VEC_VU_VU_VU(vec_mergeh,1) VEC_VU_VU_VU(vec_mergeh,2) VEC_VU_VU_VU(vec_mergeh,4) VEC_VU_VU_VU(vec_mergeh,8)
VEC_VR_VR_VR(vec_mergeh,4) VEC_VR_VR_VR(vec_mergeh,8)
interface vec_mergeh
procedure :: VI_VI_VI(vec_mergeh,1), VI_VI_VI(vec_mergeh,2), VI_VI_VI(vec_mergeh,4), VI_VI_VI(vec_mergeh,8)
procedure :: VU_VU_VU(vec_mergeh,1), VU_VU_VU(vec_mergeh,2), VU_VU_VU(vec_mergeh,4), VU_VU_VU(vec_mergeh,8)
procedure :: VR_VR_VR(vec_mergeh,4), VR_VR_VR(vec_mergeh,8)
end interface vec_mergeh
public :: vec_mergeh
! vec_mergel
VEC_VI_VI_VI(vec_mergel,1) VEC_VI_VI_VI(vec_mergel,2) VEC_VI_VI_VI(vec_mergel,4) VEC_VI_VI_VI(vec_mergel,8)
VEC_VU_VU_VU(vec_mergel,1) VEC_VU_VU_VU(vec_mergel,2) VEC_VU_VU_VU(vec_mergel,4) VEC_VU_VU_VU(vec_mergel,8)
VEC_VR_VR_VR(vec_mergel,4) VEC_VR_VR_VR(vec_mergel,8)
interface vec_mergel
procedure :: VI_VI_VI(vec_mergel,1), VI_VI_VI(vec_mergel,2), VI_VI_VI(vec_mergel,4), VI_VI_VI(vec_mergel,8)
procedure :: VU_VU_VU(vec_mergel,1), VU_VU_VU(vec_mergel,2), VU_VU_VU(vec_mergel,4), VU_VU_VU(vec_mergel,8)
procedure :: VR_VR_VR(vec_mergel,4), VR_VR_VR(vec_mergel,8)
end interface vec_mergel
public :: vec_mergel
! vec_min
VEC_VI_VI_VI(vec_min,1) VEC_VI_VI_VI(vec_min,2) VEC_VI_VI_VI(vec_min,4) VEC_VI_VI_VI(vec_min,8)
VEC_VU_VU_VU(vec_min,1) VEC_VU_VU_VU(vec_min,2) VEC_VU_VU_VU(vec_min,4) VEC_VU_VU_VU(vec_min,8)
VEC_VR_VR_VR(vec_min,4) VEC_VR_VR_VR(vec_min,8)
interface vec_min
procedure :: VI_VI_VI(vec_min,1), VI_VI_VI(vec_min,2), VI_VI_VI(vec_min,4), VI_VI_VI(vec_min,8)
procedure :: VU_VU_VU(vec_min,1), VU_VU_VU(vec_min,2), VU_VU_VU(vec_min,4), VU_VU_VU(vec_min,8)
procedure :: VR_VR_VR(vec_min,4), VR_VR_VR(vec_min,8)
end interface vec_min
public :: vec_min
! vec_mul
VEC_VI_VI_VI(vec_mul,1) VEC_VI_VI_VI(vec_mul,2) VEC_VI_VI_VI(vec_mul,4) VEC_VI_VI_VI(vec_mul,8)
VEC_VU_VU_VU(vec_mul,1) VEC_VU_VU_VU(vec_mul,2) VEC_VU_VU_VU(vec_mul,4) VEC_VU_VU_VU(vec_mul,8)
VEC_VR_VR_VR(vec_mul,4) VEC_VR_VR_VR(vec_mul,8)
interface vec_mul
procedure :: VI_VI_VI(vec_mul,1), VI_VI_VI(vec_mul,2), VI_VI_VI(vec_mul,4), VI_VI_VI(vec_mul,8)
procedure :: VU_VU_VU(vec_mul,1), VU_VU_VU(vec_mul,2), VU_VU_VU(vec_mul,4), VU_VU_VU(vec_mul,8)
procedure :: VR_VR_VR(vec_mul,4), VR_VR_VR(vec_mul,8)
end interface vec_mul
public :: vec_mul
! vec_sub
VEC_VI_VI_VI(vec_sub,1) VEC_VI_VI_VI(vec_sub,2) VEC_VI_VI_VI(vec_sub,4) VEC_VI_VI_VI(vec_sub,8)
VEC_VU_VU_VU(vec_sub,1) VEC_VU_VU_VU(vec_sub,2) VEC_VU_VU_VU(vec_sub,4) VEC_VU_VU_VU(vec_sub,8)
VEC_VR_VR_VR(vec_sub,4) VEC_VR_VR_VR(vec_sub,8)
interface vec_sub
procedure :: VI_VI_VI(vec_sub,1), VI_VI_VI(vec_sub,2), VI_VI_VI(vec_sub,4), VI_VI_VI(vec_sub,8)
procedure :: VU_VU_VU(vec_sub,1), VU_VU_VU(vec_sub,2), VU_VU_VU(vec_sub,4), VU_VU_VU(vec_sub,8)
procedure :: VR_VR_VR(vec_sub,4), VR_VR_VR(vec_sub,8)
end interface vec_sub
public :: vec_sub
! vec_sl
VEC_VI_VI_VU(vec_sl,1) VEC_VI_VI_VU(vec_sl,2) VEC_VI_VI_VU(vec_sl,4) VEC_VI_VI_VU(vec_sl,8)
VEC_VU_VU_VU(vec_sl,1) VEC_VU_VU_VU(vec_sl,2) VEC_VU_VU_VU(vec_sl,4) VEC_VU_VU_VU(vec_sl,8)
interface vec_sl
procedure :: VI_VI_VU(vec_sl,1), VI_VI_VU(vec_sl,2), VI_VI_VU(vec_sl,4), VI_VI_VU(vec_sl,8)
procedure :: VU_VU_VU(vec_sl,1), VU_VU_VU(vec_sl,2), VU_VU_VU(vec_sl,4), VU_VU_VU(vec_sl,8)
end interface vec_sl
public :: vec_sl
! vec_sll
VEC_VI_VI_VU_2(vec_sll,1,1) VEC_VI_VI_VU_2(vec_sll,2,1) VEC_VI_VI_VU_2(vec_sll,4,1)
VEC_VI_VI_VU_2(vec_sll,1,2) VEC_VI_VI_VU_2(vec_sll,2,2) VEC_VI_VI_VU_2(vec_sll,4,2)
VEC_VI_VI_VU_2(vec_sll,1,4) VEC_VI_VI_VU_2(vec_sll,2,4) VEC_VI_VI_VU_2(vec_sll,4,4)
VEC_VU_VU_VU_2(vec_sll,1,1) VEC_VU_VU_VU_2(vec_sll,2,1) VEC_VU_VU_VU_2(vec_sll,4,1)
VEC_VU_VU_VU_2(vec_sll,1,2) VEC_VU_VU_VU_2(vec_sll,2,2) VEC_VU_VU_VU_2(vec_sll,4,2)
VEC_VU_VU_VU_2(vec_sll,1,4) VEC_VU_VU_VU_2(vec_sll,2,4) VEC_VU_VU_VU_2(vec_sll,4,4)
interface vec_sll
procedure :: VI_VI_VU_2(vec_sll,1,1), VI_VI_VU_2(vec_sll,2,1), VI_VI_VU_2(vec_sll,4,1)
procedure :: VI_VI_VU_2(vec_sll,1,2), VI_VI_VU_2(vec_sll,2,2), VI_VI_VU_2(vec_sll,4,2)
procedure :: VI_VI_VU_2(vec_sll,1,4), VI_VI_VU_2(vec_sll,2,4), VI_VI_VU_2(vec_sll,4,4)
procedure :: VU_VU_VU_2(vec_sll,1,1), VU_VU_VU_2(vec_sll,2,1), VU_VU_VU_2(vec_sll,4,1)
procedure :: VU_VU_VU_2(vec_sll,1,2), VU_VU_VU_2(vec_sll,2,2), VU_VU_VU_2(vec_sll,4,2)
procedure :: VU_VU_VU_2(vec_sll,1,4), VU_VU_VU_2(vec_sll,2,4), VU_VU_VU_2(vec_sll,4,4)
end interface vec_sll
public :: vec_sll
! vec_slo
VEC_VI_VI_VU_2(vec_slo,1,1) VEC_VI_VI_VU_2(vec_slo,2,1) VEC_VI_VI_VU_2(vec_slo,4,1)
VEC_VI_VI_VU_2(vec_slo,1,2) VEC_VI_VI_VU_2(vec_slo,2,2) VEC_VI_VI_VU_2(vec_slo,4,2)
VEC_VU_VU_VU_2(vec_slo,1,1) VEC_VU_VU_VU_2(vec_slo,2,1) VEC_VU_VU_VU_2(vec_slo,4,1)
VEC_VU_VU_VU_2(vec_slo,1,2) VEC_VU_VU_VU_2(vec_slo,2,2) VEC_VU_VU_VU_2(vec_slo,4,2)
VEC_VR_VR_VU(vec_slo,4,1) VEC_VR_VR_VU(vec_slo,4,2)
interface vec_slo
procedure :: VI_VI_VU_2(vec_slo,1,1), VI_VI_VU_2(vec_slo,2,1), VI_VI_VU_2(vec_slo,4,1)
procedure :: VI_VI_VU_2(vec_slo,1,2), VI_VI_VU_2(vec_slo,2,2), VI_VI_VU_2(vec_slo,4,2)
procedure :: VU_VU_VU_2(vec_slo,1,1), VU_VU_VU_2(vec_slo,2,1), VU_VU_VU_2(vec_slo,4,1)
procedure :: VU_VU_VU_2(vec_slo,1,2), VU_VU_VU_2(vec_slo,2,2), VU_VU_VU_2(vec_slo,4,2)
procedure :: VR_VR_VU_2(vec_slo,4,1), VR_VR_VU_2(vec_slo,4,2)
end interface vec_slo
public :: vec_slo
! vec_sr
VEC_VI_VI_VU(vec_sr,1) VEC_VI_VI_VU(vec_sr,2) VEC_VI_VI_VU(vec_sr,4) VEC_VI_VI_VU(vec_sr,8)
VEC_VU_VU_VU(vec_sr,1) VEC_VU_VU_VU(vec_sr,2) VEC_VU_VU_VU(vec_sr,4) VEC_VU_VU_VU(vec_sr,8)
interface vec_sr
procedure :: VI_VI_VU(vec_sr,1), VI_VI_VU(vec_sr,2), VI_VI_VU(vec_sr,4), VI_VI_VU(vec_sr,8)
procedure :: VU_VU_VU(vec_sr,1), VU_VU_VU(vec_sr,2), VU_VU_VU(vec_sr,4), VU_VU_VU(vec_sr,8)
end interface vec_sr
public :: vec_sr
! vec_srl
VEC_VI_VI_VU_2(vec_srl,1,1) VEC_VI_VI_VU_2(vec_srl,2,1) VEC_VI_VI_VU_2(vec_srl,4,1)
VEC_VI_VI_VU_2(vec_srl,1,2) VEC_VI_VI_VU_2(vec_srl,2,2) VEC_VI_VI_VU_2(vec_srl,4,2)
VEC_VI_VI_VU_2(vec_srl,1,4) VEC_VI_VI_VU_2(vec_srl,2,4) VEC_VI_VI_VU_2(vec_srl,4,4)
VEC_VU_VU_VU_2(vec_srl,1,1) VEC_VU_VU_VU_2(vec_srl,2,1) VEC_VU_VU_VU_2(vec_srl,4,1)
VEC_VU_VU_VU_2(vec_srl,1,2) VEC_VU_VU_VU_2(vec_srl,2,2) VEC_VU_VU_VU_2(vec_srl,4,2)
VEC_VU_VU_VU_2(vec_srl,1,4) VEC_VU_VU_VU_2(vec_srl,2,4) VEC_VU_VU_VU_2(vec_srl,4,4)
interface vec_srl
procedure :: VI_VI_VU_2(vec_srl,1,1), VI_VI_VU_2(vec_srl,2,1), VI_VI_VU_2(vec_srl,4,1)
procedure :: VI_VI_VU_2(vec_srl,1,2), VI_VI_VU_2(vec_srl,2,2), VI_VI_VU_2(vec_srl,4,2)
procedure :: VI_VI_VU_2(vec_srl,1,4), VI_VI_VU_2(vec_srl,2,4), VI_VI_VU_2(vec_srl,4,4)
procedure :: VU_VU_VU_2(vec_srl,1,1), VU_VU_VU_2(vec_srl,2,1), VU_VU_VU_2(vec_srl,4,1)
procedure :: VU_VU_VU_2(vec_srl,1,2), VU_VU_VU_2(vec_srl,2,2), VU_VU_VU_2(vec_srl,4,2)
procedure :: VU_VU_VU_2(vec_srl,1,4), VU_VU_VU_2(vec_srl,2,4), VU_VU_VU_2(vec_srl,4,4)
end interface vec_srl
public :: vec_srl
! vec_sro
VEC_VI_VI_VU_2(vec_sro,1,1) VEC_VI_VI_VU_2(vec_sro,2,1) VEC_VI_VI_VU_2(vec_sro,4,1)
VEC_VI_VI_VU_2(vec_sro,1,2) VEC_VI_VI_VU_2(vec_sro,2,2) VEC_VI_VI_VU_2(vec_sro,4,2)
VEC_VU_VU_VU_2(vec_sro,1,1) VEC_VU_VU_VU_2(vec_sro,2,1) VEC_VU_VU_VU_2(vec_sro,4,1)
VEC_VU_VU_VU_2(vec_sro,1,2) VEC_VU_VU_VU_2(vec_sro,2,2) VEC_VU_VU_VU_2(vec_sro,4,2)
VEC_VR_VR_VU(vec_sro,4,1) VEC_VR_VR_VU(vec_sro,4,2)
interface vec_sro
procedure :: VI_VI_VU_2(vec_sro,1,1), VI_VI_VU_2(vec_sro,2,1), VI_VI_VU_2(vec_sro,4,1)
procedure :: VI_VI_VU_2(vec_sro,1,2), VI_VI_VU_2(vec_sro,2,2), VI_VI_VU_2(vec_sro,4,2)
procedure :: VU_VU_VU_2(vec_sro,1,1), VU_VU_VU_2(vec_sro,2,1), VU_VU_VU_2(vec_sro,4,1)
procedure :: VU_VU_VU_2(vec_sro,1,2), VU_VU_VU_2(vec_sro,2,2), VU_VU_VU_2(vec_sro,4,2)
procedure :: VR_VR_VU_2(vec_sro,4,1), VR_VR_VU_2(vec_sro,4,2)
end interface vec_sro
public :: vec_sro
! vec_xor
VEC_VI_VI_VI(vec_xor,1) VEC_VI_VI_VI(vec_xor,2) VEC_VI_VI_VI(vec_xor,4) VEC_VI_VI_VI(vec_xor,8)
VEC_VU_VU_VU(vec_xor,1) VEC_VU_VU_VU(vec_xor,2) VEC_VU_VU_VU(vec_xor,4) VEC_VU_VU_VU(vec_xor,8)
VEC_VR_VR_VR(vec_xor,4) VEC_VR_VR_VR(vec_xor,8)
interface vec_xor
procedure :: VI_VI_VI(vec_xor,1), VI_VI_VI(vec_xor,2), VI_VI_VI(vec_xor,4), VI_VI_VI(vec_xor,8)
procedure :: VU_VU_VU(vec_xor,1), VU_VU_VU(vec_xor,2), VU_VU_VU(vec_xor,4), VU_VU_VU(vec_xor,8)
procedure :: VR_VR_VR(vec_xor,4), VR_VR_VR(vec_xor,8)
end interface vec_xor
public :: vec_xor
#undef VEC_VU_VR_VR
#undef VEC_VR_VR_VR
#undef VEC_VU_VU_VU
#undef VEC_VU_VU_VU_2
#undef VEC_VI_VI_VI
#undef VEC_VU_VI_VI
#undef VEC_VI_VI_VU
#undef VEC_VI_VI_VU_2
#undef VU_VR_VR
#undef VR_VR_VU_2
#undef VR_VR_VR
#undef VU_VU_VU
#undef VU_VU_VU_2
#undef VI_VI_VU
#undef VI_VI_VU_2
#undef VU_VI_VI
#undef VI_VI_VI
!-------------------------------------------------------
! vector(unsigned(1)) function(integer, i/r)
!-------------------------------------------------------
#define VU1_I0_I(NAME, KIND) __ppc_##NAME##_vu1i0i##KIND
#define VU1_I0_R(NAME, KIND) __ppc_##NAME##_vu1i0r##KIND
#define VEC_VU1_I0_I(NAME, KIND) \
procedure(func_vu1i0i##KIND) :: VU1_I0_I(NAME, KIND);
#define VEC_VU1_I0_R(NAME, KIND) \
procedure(func_vu1i0r##KIND) :: VU1_I0_R(NAME, KIND);
! vec_lvsl
VEC_VU1_I0_I(vec_lvsl,1) VEC_VU1_I0_I(vec_lvsl,2) VEC_VU1_I0_I(vec_lvsl,4)
VEC_VU1_I0_R(vec_lvsl,4)
interface vec_lvsl
procedure :: VU1_I0_I(vec_lvsl,1), VU1_I0_I(vec_lvsl,2), VU1_I0_I(vec_lvsl,4)
procedure :: VU1_I0_R(vec_lvsl,4)
end interface
public :: vec_lvsl
! vec_lvsr
VEC_VU1_I0_I(vec_lvsr,1) VEC_VU1_I0_I(vec_lvsr,2) VEC_VU1_I0_I(vec_lvsr,4)
VEC_VU1_I0_R(vec_lvsr,4)
interface vec_lvsr
procedure :: VU1_I0_I(vec_lvsr,1), VU1_I0_I(vec_lvsr,2), VU1_I0_I(vec_lvsr,4)
procedure :: VU1_I0_R(vec_lvsr,4)
end interface
public :: vec_lvsr
#undef VEC_VU1_I0_R
#undef VEC_VU1_I0_I
#undef VU1_I0_R
#undef VU1_I0_I
!-------------------------------------------------------
! vector function(integer, i/u/r/vector)
!-------------------------------------------------------
! i0 means the integer argument has ignore_tkr(k)
#define VI_I0_VI(NAME, VKIND) __ppc_##NAME##_vi##VKIND##i0##vi##VKIND
#define VU_I0_VU(NAME, VKIND) __ppc_##NAME##_vu##VKIND##i0##vu##VKIND
#define VR_I0_VR(NAME, VKIND) __ppc_##NAME##_vr##VKIND##i0##vr##VKIND
#define VI_I0_I(NAME, VKIND) __ppc_##NAME##_vi##VKIND##i0##i##VKIND
#define VR_I0_R(NAME, VKIND) __ppc_##NAME##_vr##VKIND##i0##r##VKIND
#define VEC_VI_I0_VI(NAME, VKIND) \
procedure(func_vi##VKIND##i0##vi##VKIND) :: VI_I0_VI(NAME, VKIND);
#define VEC_VU_I0_VU(NAME, VKIND) \
procedure(func_vu##VKIND##i0##vu##VKIND) :: VU_I0_VU(NAME, VKIND);
#define VEC_VR_I0_VR(NAME, VKIND) \
procedure(func_vr##VKIND##i0##vr##VKIND) :: VR_I0_VR(NAME, VKIND);
#define VEC_VI_I0_I(NAME, VKIND) \
procedure(func_vi##VKIND##i0##i##VKIND) :: VI_I0_I(NAME, VKIND);
#define VEC_VR_I0_R(NAME, VKIND) \
procedure(func_vr##VKIND##i0##r##VKIND) :: VR_I0_R(NAME, VKIND);
! vec_ld
VEC_VI_I0_VI(vec_ld,1) VEC_VI_I0_VI(vec_ld,2) VEC_VI_I0_VI(vec_ld,4)
VEC_VU_I0_VU(vec_ld,1) VEC_VU_I0_VU(vec_ld,2) VEC_VU_I0_VU(vec_ld,4)
VEC_VR_I0_VR(vec_ld,4)
VEC_VI_I0_I(vec_ld,1) VEC_VI_I0_I(vec_ld,2) VEC_VI_I0_I(vec_ld,4)
VEC_VR_I0_R(vec_ld,4)
interface vec_ld
procedure :: VI_I0_VI(vec_ld,1), VI_I0_VI(vec_ld,2), VI_I0_VI(vec_ld,4)
procedure :: VU_I0_VU(vec_ld,1), VU_I0_VU(vec_ld,2), VU_I0_VU(vec_ld,4)
procedure :: VR_I0_VR(vec_ld,4)
procedure :: VI_I0_I(vec_ld,1), VI_I0_I(vec_ld,2), VI_I0_I(vec_ld,4)
procedure :: VR_I0_R(vec_ld,4)
end interface
public :: vec_ld
! vec_lde
VEC_VI_I0_I(vec_lde,1) VEC_VI_I0_I(vec_lde,2) VEC_VI_I0_I(vec_lde,4)
VEC_VR_I0_R(vec_lde,4)
interface vec_lde
procedure :: VI_I0_I(vec_lde,1), VI_I0_I(vec_lde,2), VI_I0_I(vec_lde,4)
procedure :: VR_I0_R(vec_lde,4)
end interface
public :: vec_lde
! vec_ldl
VEC_VI_I0_VI(vec_ldl,1) VEC_VI_I0_VI(vec_ldl,2) VEC_VI_I0_VI(vec_ldl,4)
VEC_VU_I0_VU(vec_ldl,1) VEC_VU_I0_VU(vec_ldl,2) VEC_VU_I0_VU(vec_ldl,4)
VEC_VR_I0_VR(vec_ldl,4)
VEC_VI_I0_I(vec_ldl,1) VEC_VI_I0_I(vec_ldl,2) VEC_VI_I0_I(vec_ldl,4)
VEC_VR_I0_R(vec_ldl,4)
interface vec_ldl
procedure :: VI_I0_VI(vec_ldl,1), VI_I0_VI(vec_ldl,2), VI_I0_VI(vec_ldl,4)
procedure :: VU_I0_VU(vec_ldl,1), VU_I0_VU(vec_ldl,2), VU_I0_VU(vec_ldl,4)
procedure :: VR_I0_VR(vec_ldl,4)
procedure :: VI_I0_I(vec_ldl,1), VI_I0_I(vec_ldl,2), VI_I0_I(vec_ldl,4)
procedure :: VR_I0_R(vec_ldl,4)
end interface
public :: vec_ldl
! vec_lxv
VEC_VI_I0_VI(vec_lxv,1) VEC_VI_I0_VI(vec_lxv,2) VEC_VI_I0_VI(vec_lxv,4) VEC_VI_I0_VI(vec_lxv,8)
VEC_VU_I0_VU(vec_lxv,1) VEC_VU_I0_VU(vec_lxv,2) VEC_VU_I0_VU(vec_lxv,4) VEC_VU_I0_VU(vec_lxv,8)
VEC_VR_I0_VR(vec_lxv,4) VEC_VR_I0_VR(vec_lxv,8)
VEC_VI_I0_I(vec_lxv,1) VEC_VI_I0_I(vec_lxv,2) VEC_VI_I0_I(vec_lxv,4) VEC_VI_I0_I(vec_lxv,8)
VEC_VR_I0_R(vec_lxv,4) VEC_VR_I0_R(vec_lxv,8)
interface vec_lxv
procedure :: VI_I0_VI(vec_lxv,1), VI_I0_VI(vec_lxv,2), VI_I0_VI(vec_lxv,4), VI_I0_VI(vec_lxv,8)
procedure :: VU_I0_VU(vec_lxv,1), VU_I0_VU(vec_lxv,2), VU_I0_VU(vec_lxv,4), VU_I0_VU(vec_lxv,8)
procedure :: VR_I0_VR(vec_lxv,4), VR_I0_VR(vec_lxv,8)
procedure :: VI_I0_I(vec_lxv,1), VI_I0_I(vec_lxv,2), VI_I0_I(vec_lxv,4), VI_I0_I(vec_lxv,8)
procedure :: VR_I0_R(vec_lxv,4), VR_I0_R(vec_lxv,8)
end interface
public :: vec_lxv
! vec_xl
VEC_VI_I0_VI(vec_xl,1) VEC_VI_I0_VI(vec_xl,2) VEC_VI_I0_VI(vec_xl,4) VEC_VI_I0_VI(vec_xl,8)
VEC_VU_I0_VU(vec_xl,1) VEC_VU_I0_VU(vec_xl,2) VEC_VU_I0_VU(vec_xl,4) VEC_VU_I0_VU(vec_xl,8)
VEC_VR_I0_VR(vec_xl,4) VEC_VR_I0_VR(vec_xl,8)
VEC_VI_I0_I(vec_xl,1) VEC_VI_I0_I(vec_xl,2) VEC_VI_I0_I(vec_xl,4) VEC_VI_I0_I(vec_xl,8)
VEC_VR_I0_R(vec_xl,4) VEC_VR_I0_R(vec_xl,8)
interface vec_xl
procedure :: VI_I0_VI(vec_xl,1), VI_I0_VI(vec_xl,2), VI_I0_VI(vec_xl,4), VI_I0_VI(vec_xl,8)
procedure :: VU_I0_VU(vec_xl,1), VU_I0_VU(vec_xl,2), VU_I0_VU(vec_xl,4), VU_I0_VU(vec_xl,8)
procedure :: VR_I0_VR(vec_xl,4), VR_I0_VR(vec_xl,8)
procedure :: VI_I0_I(vec_xl,1), VI_I0_I(vec_xl,2), VI_I0_I(vec_xl,4), VI_I0_I(vec_xl,8)
procedure :: VR_I0_R(vec_xl,4), VR_I0_R(vec_xl,8)
end interface
public :: vec_xl
! vec_xl_be
VEC_VI_I0_VI(vec_xl_be,1) VEC_VI_I0_VI(vec_xl_be,2) VEC_VI_I0_VI(vec_xl_be,4) VEC_VI_I0_VI(vec_xl_be,8)
VEC_VU_I0_VU(vec_xl_be,1) VEC_VU_I0_VU(vec_xl_be,2) VEC_VU_I0_VU(vec_xl_be,4) VEC_VU_I0_VU(vec_xl_be,8)
VEC_VR_I0_VR(vec_xl_be,4) VEC_VR_I0_VR(vec_xl_be,8)
VEC_VI_I0_I(vec_xl_be,1) VEC_VI_I0_I(vec_xl_be,2) VEC_VI_I0_I(vec_xl_be,4) VEC_VI_I0_I(vec_xl_be,8)
VEC_VR_I0_R(vec_xl_be,4) VEC_VR_I0_R(vec_xl_be,8)
interface vec_xl_be
procedure :: VI_I0_VI(vec_xl_be,1), VI_I0_VI(vec_xl_be,2), VI_I0_VI(vec_xl_be,4), VI_I0_VI(vec_xl_be,8)
procedure :: VU_I0_VU(vec_xl_be,1), VU_I0_VU(vec_xl_be,2), VU_I0_VU(vec_xl_be,4), VU_I0_VU(vec_xl_be,8)
procedure :: VR_I0_VR(vec_xl_be,4), VR_I0_VR(vec_xl_be,8)
procedure :: VI_I0_I(vec_xl_be,1), VI_I0_I(vec_xl_be,2), VI_I0_I(vec_xl_be,4) , VI_I0_I(vec_xl_be,8)
procedure :: VR_I0_R(vec_xl_be,4), VR_I0_R(vec_xl_be,8)
end interface
public :: vec_xl_be
! vec_xld2
VEC_VI_I0_VI(vec_xld2_,1) VEC_VI_I0_VI(vec_xld2_,2) VEC_VI_I0_VI(vec_xld2_,4) VEC_VI_I0_VI(vec_xld2_,8)
VEC_VU_I0_VU(vec_xld2_,1) VEC_VU_I0_VU(vec_xld2_,2) VEC_VU_I0_VU(vec_xld2_,4) VEC_VU_I0_VU(vec_xld2_,8)
VEC_VR_I0_VR(vec_xld2_,4) VEC_VR_I0_VR(vec_xld2_,8)
VEC_VI_I0_I(vec_xld2_,1) VEC_VI_I0_I(vec_xld2_,2) VEC_VI_I0_I(vec_xld2_,4) VEC_VI_I0_I(vec_xld2_,8)
VEC_VR_I0_R(vec_xld2_,4) VEC_VR_I0_R(vec_xld2_,8)
interface vec_xld2
procedure :: VI_I0_VI(vec_xld2_,1), VI_I0_VI(vec_xld2_,2), VI_I0_VI(vec_xld2_,4), VI_I0_VI(vec_xld2_,8)
procedure :: VU_I0_VU(vec_xld2_,1), VU_I0_VU(vec_xld2_,2), VU_I0_VU(vec_xld2_,4), VU_I0_VU(vec_xld2_,8)
procedure :: VR_I0_VR(vec_xld2_,4), VR_I0_VR(vec_xld2_,8)
procedure :: VI_I0_I(vec_xld2_,1), VI_I0_I(vec_xld2_,2), VI_I0_I(vec_xld2_,4), VI_I0_I(vec_xld2_,8)
procedure :: VR_I0_R(vec_xld2_,4), VR_I0_R(vec_xld2_,8)
end interface
public :: vec_xld2
! vec_xlds
VEC_VI_I0_VI(vec_xlds,8)
VEC_VU_I0_VU(vec_xlds,8)
VEC_VR_I0_VR(vec_xlds,8)
VEC_VI_I0_I(vec_xlds,8)
VEC_VR_I0_R(vec_xlds,8)
interface vec_xlds
procedure :: VI_I0_VI(vec_xlds,8)
procedure :: VU_I0_VU(vec_xlds,8)
procedure :: VR_I0_VR(vec_xlds,8)
procedure :: VI_I0_I(vec_xlds,8)
procedure :: VR_I0_R(vec_xlds,8)
end interface
public :: vec_xlds
! vec_xlw4
VEC_VI_I0_VI(vec_xlw4_,1) VEC_VI_I0_VI(vec_xlw4_,2)
VEC_VU_I0_VU(vec_xlw4_,1) VEC_VU_I0_VU(vec_xlw4_,2) VEC_VU_I0_VU(vec_xlw4_,4)
VEC_VR_I0_VR(vec_xlw4_,4)
VEC_VI_I0_I(vec_xlw4_,1) VEC_VI_I0_I(vec_xlw4_,2) VEC_VI_I0_I(vec_xlw4_,4)
VEC_VR_I0_R(vec_xlw4_,4)
interface vec_xlw4
procedure :: VI_I0_VI(vec_xlw4_,1), VI_I0_VI(vec_xlw4_,2)
procedure :: VU_I0_VU(vec_xlw4_,1), VU_I0_VU(vec_xlw4_,2), VU_I0_VU(vec_xlw4_,4)
procedure :: VR_I0_VR(vec_xlw4_,4)
procedure :: VI_I0_I(vec_xlw4_,1), VI_I0_I(vec_xlw4_,2), VI_I0_I(vec_xlw4_,4)
procedure :: VR_I0_R(vec_xlw4_,4)
end interface
public :: vec_xlw4
#undef VEC_VR_I0_R
#undef VEC_VI_I0_I
#undef VEC_VR_I0_VR
#undef VEC_VU_I0_VU
#undef VEC_VI_I0_VI
#undef VR_I0_R
#undef VI_I0_I
#undef VR_I0_VR
#undef VU_I0_VU
#undef VI_I0_VI
!-------------------------------------------------------
! __vector_pair function(integer, vector/__vector_pair)
!-------------------------------------------------------
#define VP_I0_VI(NAME, VKIND) __ppc_##NAME##_vpi0##vi##VKIND
#define VP_I0_VU(NAME, VKIND) __ppc_##NAME##_vpi0##vu##VKIND
#define VP_I0_VR(NAME, VKIND) __ppc_##NAME##_vpi0##vr##VKIND
#define VP_I0_VP(NAME) __ppc_##NAME##_vpi0vp0
#define VEC_VP_I0_VI(NAME, VKIND) \
procedure(func_vpi0vi##VKIND) :: VP_I0_VI(NAME, VKIND);
#define VEC_VP_I0_VU(NAME, VKIND) \
procedure(func_vpi0vu##VKIND) :: VP_I0_VU(NAME, VKIND);
#define VEC_VP_I0_VR(NAME, VKIND) \
procedure(func_vpi0vr##VKIND) :: VP_I0_VR(NAME, VKIND);
#define VEC_VP_I0_VP(NAME) procedure(func_vpi0vp) :: VP_I0_VP(NAME);
! vec_lxvp
VEC_VP_I0_VI(vec_lxvp,1) VEC_VP_I0_VI(vec_lxvp,2) VEC_VP_I0_VI(vec_lxvp,4) VEC_VP_I0_VI(vec_lxvp,8)
VEC_VP_I0_VU(vec_lxvp,1) VEC_VP_I0_VU(vec_lxvp,2) VEC_VP_I0_VU(vec_lxvp,4) VEC_VP_I0_VU(vec_lxvp,8)
VEC_VP_I0_VR(vec_lxvp,4) VEC_VP_I0_VR(vec_lxvp,8)
VEC_VP_I0_VP(vec_lxvp)
interface vec_lxvp
procedure :: VP_I0_VI(vec_lxvp,1), VP_I0_VI(vec_lxvp,2), VP_I0_VI(vec_lxvp,4), VP_I0_VI(vec_lxvp,8)
procedure :: VP_I0_VU(vec_lxvp,1), VP_I0_VU(vec_lxvp,2), VP_I0_VU(vec_lxvp,4), VP_I0_VU(vec_lxvp,8)
procedure :: VP_I0_VR(vec_lxvp,4), VP_I0_VR(vec_lxvp,8)
procedure :: VP_I0_VP(vec_lxvp)
end interface vec_lxvp
public :: vec_lxvp
! vsx_lxvp (alias to vec_lxvp)
interface vsx_lxvp
procedure :: VP_I0_VI(vec_lxvp,1), VP_I0_VI(vec_lxvp,2), VP_I0_VI(vec_lxvp,4), VP_I0_VI(vec_lxvp,8)
procedure :: VP_I0_VU(vec_lxvp,1), VP_I0_VU(vec_lxvp,2), VP_I0_VU(vec_lxvp,4), VP_I0_VU(vec_lxvp,8)
procedure :: VP_I0_VR(vec_lxvp,4), VP_I0_VR(vec_lxvp,8)
procedure :: VP_I0_VP(vec_lxvp)
end interface vsx_lxvp
public :: vsx_lxvp
#undef VEC_VP_I0_VP
#undef VEC_VP_I0_VR
#undef VEC_VP_I0_VU
#undef VEC_VP_I0_VI
#undef VP_I0_VP
#undef VP_I0_VR
#undef VP_I0_VU
#undef VP_I0_VI
!-----------------------------------------
! vector function(vector, vector, vector)
!-----------------------------------------
#define VR_VR_VR_VR(NAME, VKIND) __ppc_##NAME##_vr##VKIND##vr##VKIND##vr##VKIND##vr##VKIND
#define VI_VI_VI_VU_2(NAME, VKIND, UKIND) __ppc_##NAME##_vi##VKIND##vi##VKIND##vi##VKIND##vu##UKIND
#define VI_VI_VI_VU(NAME, VKIND) VI_VI_VI_VU_2(NAME, VKIND, VKIND)
#define VU_VU_VU_VU_2(NAME, VKIND, UKIND) __ppc_##NAME##_vu##VKIND##vu##VKIND##vu##VKIND##vu##UKIND
#define VU_VU_VU_VU(NAME, VKIND) VU_VU_VU_VU_2(NAME, VKIND, VKIND)
#define VR_VR_VR_VU_2(NAME, VKIND, UKIND) __ppc_##NAME##_vr##VKIND##vr##VKIND##vr##VKIND##vu##UKIND
#define VR_VR_VR_VU(NAME, VKIND) VR_VR_VR_VU_2(NAME, VKIND, VKIND)
! i0 indicates "!dir$ ignore_tkr(k) arg3"
#define VI_VI_VI_I(NAME, VKIND) __ppc_##NAME##_vi##VKIND##vi##VKIND##vi##VKIND##i0
#define VU_VU_VU_I(NAME, VKIND) __ppc_##NAME##_vu##VKIND##vu##VKIND##vu##VKIND##i0
#define VR_VR_VR_I(NAME, VKIND) __ppc_##NAME##_vr##VKIND##vr##VKIND##vr##VKIND##i0
#define VEC_VR_VR_VR_VR(NAME, VKIND) \
procedure(elem_func_vr##VKIND##vr##VKIND##vr##VKIND##vr##VKIND) :: VR_VR_VR_VR(NAME, VKIND);
#define VEC_VI_VI_VI_VU_2(NAME, VKIND, UKIND) \
procedure(elem_func_vi##VKIND##vi##VKIND##vi##VKIND##vu##UKIND) :: VI_VI_VI_VU_2(NAME, VKIND, UKIND);
#define VEC_VI_VI_VI_VU(NAME, VKIND) VEC_VI_VI_VI_VU_2(NAME, VKIND, VKIND)
#define VEC_VU_VU_VU_VU_2(NAME, VKIND, UKIND) \
procedure(elem_func_vu##VKIND##vu##VKIND##vu##VKIND##vu##UKIND) :: VU_VU_VU_VU_2(NAME, VKIND, UKIND);
#define VEC_VU_VU_VU_VU(NAME, VKIND) VEC_VU_VU_VU_VU_2(NAME, VKIND, VKIND)
#define VEC_VR_VR_VR_VU_2(NAME, VKIND, UKIND) \
procedure(elem_func_vr##VKIND##vr##VKIND##vr##VKIND##vu##UKIND) :: VR_VR_VR_VU_2(NAME, VKIND, UKIND);
#define VEC_VR_VR_VR_VU(NAME, VKIND) VEC_VR_VR_VR_VU_2(NAME, VKIND, VKIND)
#define VEC_VI_VI_VI_I(NAME, VKIND) \
procedure(elem_func_vi##VKIND##vi##VKIND##vi##VKIND##i) :: VI_VI_VI_I(NAME, VKIND);
#define VEC_VU_VU_VU_I(NAME, VKIND) \
procedure(elem_func_vu##VKIND##vu##VKIND##vu##VKIND##i) :: VU_VU_VU_I(NAME, VKIND);
#define VEC_VR_VR_VR_I(NAME, VKIND) \
procedure(elem_func_vr##VKIND##vr##VKIND##vr##VKIND##i) :: VR_VR_VR_I(NAME, VKIND);
! vec_madd
VEC_VR_VR_VR_VR(vec_madd,4) VEC_VR_VR_VR_VR(vec_madd,8)
interface vec_madd
procedure :: VR_VR_VR_VR(vec_madd,4), VR_VR_VR_VR(vec_madd,8)
end interface vec_madd
public :: vec_madd
! vec_msub
VEC_VR_VR_VR_VR(vec_msub,4) VEC_VR_VR_VR_VR(vec_msub,8)
interface vec_msub
procedure :: VR_VR_VR_VR(vec_msub,4), VR_VR_VR_VR(vec_msub,8)
end interface vec_msub
public :: vec_msub
! vec_nmadd
VEC_VR_VR_VR_VR(vec_nmadd,4) VEC_VR_VR_VR_VR(vec_nmadd,8)
interface vec_nmadd
procedure :: VR_VR_VR_VR(vec_nmadd,4), VR_VR_VR_VR(vec_nmadd,8)
end interface vec_nmadd
public :: vec_nmadd
! vec_nmsub
VEC_VR_VR_VR_VR(vec_nmsub,4) VEC_VR_VR_VR_VR(vec_nmsub,8)
interface vec_nmsub
procedure :: VR_VR_VR_VR(vec_nmsub,4), VR_VR_VR_VR(vec_nmsub,8)
end interface vec_nmsub
public :: vec_nmsub
! vec_perm
VEC_VI_VI_VI_VU_2(vec_perm,1,1) VEC_VI_VI_VI_VU_2(vec_perm,2,1) VEC_VI_VI_VI_VU_2(vec_perm,4,1) VEC_VI_VI_VI_VU_2(vec_perm,8,1)
VEC_VU_VU_VU_VU_2(vec_perm,1,1) VEC_VU_VU_VU_VU_2(vec_perm,2,1) VEC_VU_VU_VU_VU_2(vec_perm,4,1) VEC_VU_VU_VU_VU_2(vec_perm,8,1)
VEC_VR_VR_VR_VU_2(vec_perm,4,1) VEC_VR_VR_VR_VU_2(vec_perm,8,1)
interface vec_perm
procedure :: VI_VI_VI_VU_2(vec_perm,1,1), VI_VI_VI_VU_2(vec_perm,2,1), VI_VI_VI_VU_2(vec_perm,4,1), VI_VI_VI_VU_2(vec_perm,8,1)
procedure :: VU_VU_VU_VU_2(vec_perm,1,1), VU_VU_VU_VU_2(vec_perm,2,1), VU_VU_VU_VU_2(vec_perm,4,1), VU_VU_VU_VU_2(vec_perm,8,1)
procedure :: VR_VR_VR_VU_2(vec_perm,4,1), VR_VR_VR_VU_2(vec_perm,8,1)
end interface vec_perm
public :: vec_perm
! vec_permi
VEC_VI_VI_VI_I(vec_permi,8)
VEC_VU_VU_VU_I(vec_permi,8)
VEC_VR_VR_VR_I(vec_permi,4) VEC_VR_VR_VR_I(vec_permi,8)
interface vec_permi
procedure :: VI_VI_VI_I(vec_permi,8)
procedure :: VU_VU_VU_I(vec_permi,8)
procedure :: VR_VR_VR_I(vec_permi,4), VR_VR_VR_I(vec_permi,8)
end interface vec_permi
public :: vec_permi
! vec_sel
VEC_VI_VI_VI_VU(vec_sel,1) VEC_VI_VI_VI_VU(vec_sel,2) VEC_VI_VI_VI_VU(vec_sel,4) VEC_VI_VI_VI_VU(vec_sel,8)
VEC_VU_VU_VU_VU(vec_sel,1) VEC_VU_VU_VU_VU(vec_sel,2) VEC_VU_VU_VU_VU(vec_sel,4) VEC_VU_VU_VU_VU(vec_sel,8)
VEC_VR_VR_VR_VU(vec_sel,4) VEC_VR_VR_VR_VU(vec_sel,8)
interface vec_sel
procedure :: VI_VI_VI_VU(vec_sel,1), VI_VI_VI_VU(vec_sel,2), VI_VI_VI_VU(vec_sel,4), VI_VI_VI_VU(vec_sel,8)
procedure :: VU_VU_VU_VU(vec_sel,1), VU_VU_VU_VU(vec_sel,2), VU_VU_VU_VU(vec_sel,4), VU_VU_VU_VU(vec_sel,8)
procedure :: VR_VR_VR_VU(vec_sel,4), VR_VR_VR_VU(vec_sel,8)
end interface vec_sel
public :: vec_sel
#undef VEC_VR_VR_VR_I
#undef VEC_VU_VU_VU_I
#undef VEC_VI_VI_VI_I
#undef VEC_VI_VI_VI_VU_2
#undef VEC_VI_VI_VI_VU
#undef VEC_VU_VU_VU_VU_2
#undef VEC_VU_VU_VU_VU
#undef VEC_VR_VR_VR_VU_2
#undef VEC_VR_VR_VR_VU
#undef VEC_VR_VR_VR_VR
#undef VR_VR_VR_I
#undef VU_VU_VU_I
#undef VI_VI_VI_I
#undef VI_VI_VI_VU
#undef VI_VI_VI_VU_2
#undef VU_VU_VU_VU
#undef VU_VU_VU_VU_2
#undef VR_VR_VR_VU
#undef VR_VR_VR_VU_2
#undef VR_VR_VR_VR
!------------------------------------------
! vector function(integer, vector, integer)
! vector function(real, vector, integer)
!------------------------------------------
#define VI_I_VI_I(NAME, VKIND) __ppc_##NAME##_vi##VKIND##i##VKIND##vi##VKIND##i0
#define VR_R_VR_I(NAME, VKIND) __ppc_##NAME##_vr##VKIND##r##VKIND##vr##VKIND##i0
#define VEC_VI_I_VI_I(NAME, VKIND) \
procedure(elem_func_vi##VKIND##i##VKIND##vi##VKIND##i) :: VI_I_VI_I(NAME, VKIND);
#define VEC_VR_R_VR_I(NAME, VKIND) \
procedure(elem_func_vr##VKIND##r##VKIND##vr##VKIND##i) :: VR_R_VR_I(NAME, VKIND);
! vec_insert
VEC_VI_I_VI_I(vec_insert,1) VEC_VI_I_VI_I(vec_insert,2) VEC_VI_I_VI_I(vec_insert,4) VEC_VI_I_VI_I(vec_insert,8)
VEC_VR_R_VR_I(vec_insert,4) VEC_VR_R_VR_I(vec_insert,8)
interface vec_insert
procedure :: VI_I_VI_I(vec_insert,1), VI_I_VI_I(vec_insert,2), VI_I_VI_I(vec_insert,4), VI_I_VI_I(vec_insert,8)
procedure :: VR_R_VR_I(vec_insert,4), VR_R_VR_I(vec_insert,8)
end interface vec_insert
public :: vec_insert
#undef VEC_VR_R_VR_I
#undef VEC_VI_I_VI_I
#undef VR_R_VR_I
#undef VI_I_VI_I
!----------------------------------
! integer function(vector, vector)
!----------------------------------
#define I_VI_VI(NAME, RKIND, VKIND) __ppc_##NAME##_i##RKIND##vi##VKIND##vi##VKIND
#define I_VU_VU(NAME, RKIND, VKIND) __ppc_##NAME##_i##RKIND##vu##VKIND##vu##VKIND
#define I_VR_VR(NAME, RKIND, VKIND) __ppc_##NAME##_i##RKIND##vr##VKIND##vr##VKIND
#define VEC_I_VI_VI(NAME, RKIND, VKIND) \
procedure(elem_func_i##RKIND##vi##VKIND##vi##VKIND) :: I_VI_VI(NAME, RKIND, VKIND);
#define VEC_I_VU_VU(NAME, RKIND, VKIND) \
procedure(elem_func_i##RKIND##vu##VKIND##vu##VKIND) :: I_VU_VU(NAME, RKIND, VKIND);
#define VEC_I_VR_VR(NAME, RKIND, VKIND) \
procedure(elem_func_i##RKIND##vr##VKIND##vr##VKIND) :: I_VR_VR(NAME, RKIND, VKIND);
! vec_any_ge
VEC_I_VI_VI(vec_any_ge,4,1) VEC_I_VI_VI(vec_any_ge,4,2) VEC_I_VI_VI(vec_any_ge,4,4) VEC_I_VI_VI(vec_any_ge,4,8)
VEC_I_VU_VU(vec_any_ge,4,1) VEC_I_VU_VU(vec_any_ge,4,2) VEC_I_VU_VU(vec_any_ge,4,4) VEC_I_VU_VU(vec_any_ge,4,8)
VEC_I_VR_VR(vec_any_ge,4,4) VEC_I_VR_VR(vec_any_ge,4,8)
interface vec_any_ge
procedure :: I_VI_VI(vec_any_ge,4,1), I_VI_VI(vec_any_ge,4,2), I_VI_VI(vec_any_ge,4,4), I_VI_VI(vec_any_ge,4,8)
procedure :: I_VU_VU(vec_any_ge,4,1), I_VU_VU(vec_any_ge,4,2), I_VU_VU(vec_any_ge,4,4), I_VU_VU(vec_any_ge,4,8)
procedure :: I_VR_VR(vec_any_ge,4,4), I_VR_VR(vec_any_ge,4,8)
end interface vec_any_ge
public :: vec_any_ge
#undef VEC_I_VR_VR
#undef VEC_I_VU_VU
#undef VEC_I_VI_VI
#undef I_VR_VR
#undef I_VU_VU
#undef I_VI_VI
!----------------------------------------
! integer/real function(vector, integer)
!----------------------------------------
#define I_VI_I(NAME, VKIND) __ppc_##NAME##_i##VKIND##vi##VKIND##i0
#define R_VR_I(NAME, VKIND) __ppc_##NAME##_r##VKIND##vr##VKIND##i0
#define VEC_I_VI_I(NAME, VKIND) \
procedure(elem_func_i##VKIND##vi##VKIND##i) :: I_VI_I(NAME, VKIND);
#define VEC_R_VR_I(NAME, VKIND) \
procedure(elem_func_r##VKIND##vr##VKIND##i) :: R_VR_I(NAME, VKIND);
! vec_extract
VEC_I_VI_I(vec_extract,1) VEC_I_VI_I(vec_extract,2) VEC_I_VI_I(vec_extract,4) VEC_I_VI_I(vec_extract,8)
VEC_R_VR_I(vec_extract,4) VEC_R_VR_I(vec_extract,8)
interface vec_extract
procedure :: I_VI_I(vec_extract,1), I_VI_I(vec_extract,2), I_VI_I(vec_extract,4), I_VI_I(vec_extract,8)
procedure :: R_VR_I(vec_extract,4), R_VR_I(vec_extract,8)
end interface
public :: vec_extract
!------------------------------------------
! vector function(vector, vector, integer)
!------------------------------------------
! i0 means the integer argument has ignore_tkr(k)
#define VI_VI_VI_I(NAME, VKIND) __ppc_##NAME##_vi##VKIND##vi##VKIND##vi##VKIND##i0
#define VU_VU_VU_I(NAME, VKIND) __ppc_##NAME##_vu##VKIND##vu##VKIND##vu##VKIND##i0
#define VR_VR_VR_I(NAME, VKIND) __ppc_##NAME##_vr##VKIND##vr##VKIND##vr##VKIND##i0
#define VEC_VI_VI_VI_I(NAME, VKIND) \
procedure(elem_func_vi##VKIND##vi##VKIND##vi##VKIND##i) :: VI_VI_VI_I(NAME, VKIND);
#define VEC_VU_VU_VU_I(NAME, VKIND) \
procedure(elem_func_vu##VKIND##vu##VKIND##vu##VKIND##i) :: VU_VU_VU_I(NAME, VKIND);
#define VEC_VR_VR_VR_I(NAME, VKIND) \
procedure(elem_func_vr##VKIND##vr##VKIND##vr##VKIND##i) :: VR_VR_VR_I(NAME, VKIND);
! vec_sld
VEC_VI_VI_VI_I(vec_sld,1) VEC_VI_VI_VI_I(vec_sld,2) VEC_VI_VI_VI_I(vec_sld,4) VEC_VI_VI_VI_I(vec_sld,8)
VEC_VU_VU_VU_I(vec_sld,1) VEC_VU_VU_VU_I(vec_sld,2) VEC_VU_VU_VU_I(vec_sld,4) VEC_VU_VU_VU_I(vec_sld,8)
VEC_VR_VR_VR_I(vec_sld,4) VEC_VR_VR_VR_I(vec_sld,8)
interface vec_sld
procedure :: VI_VI_VI_I(vec_sld,1), VI_VI_VI_I(vec_sld,2), VI_VI_VI_I(vec_sld,4), VI_VI_VI_I(vec_sld,8)
procedure :: VU_VU_VU_I(vec_sld,1), VU_VU_VU_I(vec_sld,2), VU_VU_VU_I(vec_sld,4), VU_VU_VU_I(vec_sld,8)
procedure :: VR_VR_VR_I(vec_sld,4), VR_VR_VR_I(vec_sld,8)
end interface vec_sld
public :: vec_sld
! vec_sldw
VEC_VI_VI_VI_I(vec_sldw,1) VEC_VI_VI_VI_I(vec_sldw,2) VEC_VI_VI_VI_I(vec_sldw,4) VEC_VI_VI_VI_I(vec_sldw,8)
VEC_VU_VU_VU_I(vec_sldw,1) VEC_VU_VU_VU_I(vec_sldw,2) VEC_VU_VU_VU_I(vec_sldw,4) VEC_VU_VU_VU_I(vec_sldw,8)
VEC_VR_VR_VR_I(vec_sldw,4) VEC_VR_VR_VR_I(vec_sldw,8)
interface vec_sldw
procedure :: VI_VI_VI_I(vec_sldw,1), VI_VI_VI_I(vec_sldw,2), VI_VI_VI_I(vec_sldw,4), VI_VI_VI_I(vec_sldw,8)
procedure :: VU_VU_VU_I(vec_sldw,1), VU_VU_VU_I(vec_sldw,2), VU_VU_VU_I(vec_sldw,4), VU_VU_VU_I(vec_sldw,8)
procedure :: VR_VR_VR_I(vec_sldw,4), VR_VR_VR_I(vec_sldw,8)
end interface vec_sldw
public :: vec_sldw
#undef VEC_VR_VR_VR_I
#undef VEC_VU_VU_VU_I
#undef VEC_VI_VI_VI_I
#undef VR_VR_VR_I
#undef VU_VU_VU_I
#undef VI_VI_VI_I
!----------------------------------
! vector function(vector, integer)
!----------------------------------
! 'i0' stands for the integer argument being ignored via
! the `ignore_tkr' directive.
#define VR_VI_I(NAME, VKIND) __ppc_##NAME##_vr##VKIND##vi##VKIND##i0
#define VR_VU_I(NAME, VKIND) __ppc_##NAME##_vr##VKIND##vu##VKIND##i0
#define VI_VI_I0(NAME, VKIND) __ppc_##NAME##_vi##VKIND##vi##VKIND##i0
#define VU_VU_I0(NAME, VKIND) __ppc_##NAME##_vu##VKIND##vu##VKIND##i0
#define VR_VR_I0(NAME, VKIND) __ppc_##NAME##_vr##VKIND##vr##VKIND##i0
#define VEC_VR_VI_I(NAME, VKIND) \
procedure(elem_func_vr##VKIND##vi##VKIND##i) :: VR_VI_I(NAME, VKIND);
#define VEC_VR_VU_I(NAME, VKIND) \
procedure(elem_func_vr##VKIND##vu##VKIND##i) :: VR_VU_I(NAME, VKIND);
#define VEC_VI_VI_I0(NAME, VKIND) \
procedure(elem_func_vi##VKIND##vi##VKIND##i0) :: VI_VI_I0(NAME, VKIND);
#define VEC_VU_VU_I0(NAME, VKIND) \
procedure(elem_func_vu##VKIND##vu##VKIND##i0) :: VU_VU_I0(NAME, VKIND);
#define VEC_VR_VR_I0(NAME, VKIND) \
procedure(elem_func_vr##VKIND##vr##VKIND##i0) :: VR_VR_I0(NAME, VKIND);
! vec_ctf
VEC_VR_VI_I(vec_ctf,4) VEC_VR_VI_I(vec_ctf,8)
VEC_VR_VU_I(vec_ctf,4) VEC_VR_VU_I(vec_ctf,8)
interface vec_ctf
procedure :: VR_VI_I(vec_ctf,4), VR_VI_I(vec_ctf,8)
procedure :: VR_VU_I(vec_ctf,4), VR_VU_I(vec_ctf,8)
end interface vec_ctf
public :: vec_ctf
! vec_splat
VEC_VI_VI_I0(vec_splat,1) VEC_VI_VI_I0(vec_splat,2) VEC_VI_VI_I0(vec_splat,4) VEC_VI_VI_I0(vec_splat,8)
VEC_VU_VU_I0(vec_splat,1) VEC_VU_VU_I0(vec_splat,2) VEC_VU_VU_I0(vec_splat,4) VEC_VU_VU_I0(vec_splat,8)
VEC_VR_VR_I0(vec_splat,4) VEC_VR_VR_I0(vec_splat,8)
interface vec_splat
procedure :: VI_VI_I0(vec_splat,1), VI_VI_I0(vec_splat,2), VI_VI_I0(vec_splat,4), VI_VI_I0(vec_splat,8)
procedure :: VU_VU_I0(vec_splat,1), VU_VU_I0(vec_splat,2), VU_VU_I0(vec_splat,4), VU_VU_I0(vec_splat,8)
procedure :: VR_VR_I0(vec_splat,4), VR_VR_I0(vec_splat,8)
end interface vec_splat
public :: vec_splat
#undef VEC_VR_VR_I0
#undef VEC_VU_VU_I0
#undef VEC_VI_VI_I0
#undef VEC_VR_VU_I
#undef VEC_VR_VI_I
#undef VR_VR_I0
#undef VU_VU_I0
#undef VI_VI_I0
#undef VR_VU_I
#undef VR_VI_I
!--------------------------------------------------
! subroutine(vector, integer, vector/integer/real)
!--------------------------------------------------
! 'i0' stands for the integer argument being ignored via
! the `ignore_tkr' directive.
#define SUB_VI_I_VI(NAME, VKIND) __ppc_##NAME##_vi##VKIND##i0vi##VKIND
#define SUB_VU_I_VU(NAME, VKIND) __ppc_##NAME##_vu##VKIND##i0vu##VKIND
#define SUB_VR_I_VR(NAME, VKIND) __ppc_##NAME##_vr##VKIND##i0vr##VKIND
#define SUB_VI_I_I(NAME, VKIND) __ppc_##NAME##_vi##VKIND##i0i##VKIND
#define SUB_VU_I_I(NAME, VKIND) __ppc_##NAME##_vu##VKIND##i0u##VKIND
#define SUB_VR_I_R(NAME, VKIND) __ppc_##NAME##_vr##VKIND##i0r##VKIND
#define VEC_SUB_VI_I_VI(NAME, VKIND) \
procedure(sub_vi##VKIND##ivi##VKIND) :: SUB_VI_I_VI(NAME, VKIND);
#define VEC_SUB_VU_I_VU(NAME, VKIND) \
procedure(sub_vu##VKIND##ivu##VKIND) :: SUB_VU_I_VU(NAME, VKIND);
#define VEC_SUB_VR_I_VR(NAME, VKIND) \
procedure(sub_vr##VKIND##ivr##VKIND) :: SUB_VR_I_VR(NAME, VKIND);
#define VEC_SUB_VI_I_I(NAME, VKIND) \
procedure(sub_vi##VKIND##ii##VKIND) :: SUB_VI_I_I(NAME, VKIND);
#define VEC_SUB_VU_I_I(NAME, VKIND) \
procedure(sub_vu##VKIND##ii##VKIND) :: SUB_VU_I_I(NAME, VKIND);
#define VEC_SUB_VR_I_R(NAME, VKIND) \
procedure(sub_vr##VKIND##ir##VKIND) :: SUB_VR_I_R(NAME, VKIND);
! vec_st
VEC_SUB_VI_I_VI(vec_st,1) VEC_SUB_VI_I_VI(vec_st,2) VEC_SUB_VI_I_VI(vec_st,4)
VEC_SUB_VU_I_VU(vec_st,1) VEC_SUB_VU_I_VU(vec_st,2) VEC_SUB_VU_I_VU(vec_st,4)
VEC_SUB_VR_I_VR(vec_st,4)
VEC_SUB_VI_I_I(vec_st,1) VEC_SUB_VI_I_I(vec_st,2) VEC_SUB_VI_I_I(vec_st,4)
VEC_SUB_VU_I_I(vec_st,1) VEC_SUB_VU_I_I(vec_st,2) VEC_SUB_VU_I_I(vec_st,4)
VEC_SUB_VR_I_R(vec_st,4)
interface vec_st
procedure :: SUB_VI_I_VI(vec_st,1), SUB_VI_I_VI(vec_st,2), SUB_VI_I_VI(vec_st,4)
procedure :: SUB_VU_I_VU(vec_st,1), SUB_VU_I_VU(vec_st,2), SUB_VU_I_VU(vec_st,4)
procedure :: SUB_VR_I_VR(vec_st,4)
procedure :: SUB_VI_I_I(vec_st,1), SUB_VI_I_I(vec_st,2), SUB_VI_I_I(vec_st,4)
procedure :: SUB_VU_I_I(vec_st,1), SUB_VU_I_I(vec_st,2), SUB_VU_I_I(vec_st,4)
procedure :: SUB_VR_I_R(vec_st,4)
end interface vec_st
public :: vec_st
! vec_ste
VEC_SUB_VI_I_I(vec_ste,1) VEC_SUB_VI_I_I(vec_ste,2) VEC_SUB_VI_I_I(vec_ste,4)
VEC_SUB_VU_I_I(vec_ste,1) VEC_SUB_VU_I_I(vec_ste,2) VEC_SUB_VU_I_I(vec_ste,4)
VEC_SUB_VR_I_R(vec_ste,4)
interface vec_ste
procedure :: SUB_VI_I_I(vec_ste,1), SUB_VI_I_I(vec_ste,2), SUB_VI_I_I(vec_ste,4)
procedure :: SUB_VU_I_I(vec_ste,1), SUB_VU_I_I(vec_ste,2), SUB_VU_I_I(vec_ste,4)
procedure :: SUB_VR_I_R(vec_ste,4)
end interface vec_ste
public :: vec_ste
! vec_stxv
VEC_SUB_VI_I_VI(vec_stxv,1) VEC_SUB_VI_I_VI(vec_stxv,2) VEC_SUB_VI_I_VI(vec_stxv,4) VEC_SUB_VI_I_VI(vec_stxv,8)
VEC_SUB_VU_I_VU(vec_stxv,1) VEC_SUB_VU_I_VU(vec_stxv,2) VEC_SUB_VU_I_VU(vec_stxv,4) VEC_SUB_VU_I_VU(vec_stxv,8)
VEC_SUB_VR_I_VR(vec_stxv,4) VEC_SUB_VR_I_VR(vec_stxv,8)
VEC_SUB_VI_I_I(vec_stxv,1) VEC_SUB_VI_I_I(vec_stxv,2) VEC_SUB_VI_I_I(vec_stxv,4) VEC_SUB_VI_I_I(vec_stxv,8)
VEC_SUB_VU_I_I(vec_stxv,1) VEC_SUB_VU_I_I(vec_stxv,2) VEC_SUB_VU_I_I(vec_stxv,4) VEC_SUB_VU_I_I(vec_stxv,8)
VEC_SUB_VR_I_R(vec_stxv,4) VEC_SUB_VR_I_R(vec_stxv,8)
interface vec_stxv
procedure :: SUB_VI_I_VI(vec_stxv,1), SUB_VI_I_VI(vec_stxv,2), SUB_VI_I_VI(vec_stxv,4), SUB_VI_I_VI(vec_stxv,8)
procedure :: SUB_VU_I_VU(vec_stxv,1), SUB_VU_I_VU(vec_stxv,2), SUB_VU_I_VU(vec_stxv,4), SUB_VU_I_VU(vec_stxv,8)
procedure :: SUB_VR_I_VR(vec_stxv,4), SUB_VR_I_VR(vec_stxv,8)
procedure :: SUB_VI_I_I(vec_stxv,1), SUB_VI_I_I(vec_stxv,2), SUB_VI_I_I(vec_stxv,4), SUB_VI_I_I(vec_stxv,8)
procedure :: SUB_VU_I_I(vec_stxv,1), SUB_VU_I_I(vec_stxv,2), SUB_VU_I_I(vec_stxv,4), SUB_VU_I_I(vec_stxv,8)
procedure :: SUB_VR_I_R(vec_stxv,4), SUB_VR_I_R(vec_stxv,8)
end interface vec_stxv
public :: vec_stxv
! vec_xst
VEC_SUB_VI_I_VI(vec_xst,1) VEC_SUB_VI_I_VI(vec_xst,2) VEC_SUB_VI_I_VI(vec_xst,4) VEC_SUB_VI_I_VI(vec_xst,8)
VEC_SUB_VU_I_VU(vec_xst,1) VEC_SUB_VU_I_VU(vec_xst,2) VEC_SUB_VU_I_VU(vec_xst,4) VEC_SUB_VU_I_VU(vec_xst,8)
VEC_SUB_VR_I_VR(vec_xst,4) VEC_SUB_VR_I_VR(vec_xst,8)
VEC_SUB_VI_I_I(vec_xst,1) VEC_SUB_VI_I_I(vec_xst,2) VEC_SUB_VI_I_I(vec_xst,4) VEC_SUB_VI_I_I(vec_xst,8)
VEC_SUB_VU_I_I(vec_xst,1) VEC_SUB_VU_I_I(vec_xst,2) VEC_SUB_VU_I_I(vec_xst,4) VEC_SUB_VU_I_I(vec_xst,8)
VEC_SUB_VR_I_R(vec_xst,4) VEC_SUB_VR_I_R(vec_xst,8)
interface vec_xst
procedure :: SUB_VI_I_VI(vec_xst,1), SUB_VI_I_VI(vec_xst,2), SUB_VI_I_VI(vec_xst,4), SUB_VI_I_VI(vec_xst,8)
procedure :: SUB_VU_I_VU(vec_xst,1), SUB_VU_I_VU(vec_xst,2), SUB_VU_I_VU(vec_xst,4), SUB_VU_I_VU(vec_xst,8)
procedure :: SUB_VR_I_VR(vec_xst,4), SUB_VR_I_VR(vec_xst,8)
procedure :: SUB_VI_I_I(vec_xst,1), SUB_VI_I_I(vec_xst,2), SUB_VI_I_I(vec_xst,4), SUB_VI_I_I(vec_xst,8)
procedure :: SUB_VU_I_I(vec_xst,1), SUB_VU_I_I(vec_xst,2), SUB_VU_I_I(vec_xst,4), SUB_VU_I_I(vec_xst,8)
procedure :: SUB_VR_I_R(vec_xst,4), SUB_VR_I_R(vec_xst,8)
end interface vec_xst
public :: vec_xst
! vec_xst_be
VEC_SUB_VI_I_VI(vec_xst_be,1) VEC_SUB_VI_I_VI(vec_xst_be,2) VEC_SUB_VI_I_VI(vec_xst_be,4) VEC_SUB_VI_I_VI(vec_xst_be,8)
VEC_SUB_VU_I_VU(vec_xst_be,1) VEC_SUB_VU_I_VU(vec_xst_be,2) VEC_SUB_VU_I_VU(vec_xst_be,4) VEC_SUB_VU_I_VU(vec_xst_be,8)
VEC_SUB_VR_I_VR(vec_xst_be,4) VEC_SUB_VR_I_VR(vec_xst_be,8)
VEC_SUB_VI_I_I(vec_xst_be,1) VEC_SUB_VI_I_I(vec_xst_be,2) VEC_SUB_VI_I_I(vec_xst_be,4) VEC_SUB_VI_I_I(vec_xst_be,8)
VEC_SUB_VU_I_I(vec_xst_be,1) VEC_SUB_VU_I_I(vec_xst_be,2) VEC_SUB_VU_I_I(vec_xst_be,4) VEC_SUB_VU_I_I(vec_xst_be,8)
VEC_SUB_VR_I_R(vec_xst_be,4) VEC_SUB_VR_I_R(vec_xst_be,8)
interface vec_xst_be
procedure :: SUB_VI_I_VI(vec_xst_be,1), SUB_VI_I_VI(vec_xst_be,2), SUB_VI_I_VI(vec_xst_be,4), SUB_VI_I_VI(vec_xst_be,8)
procedure :: SUB_VU_I_VU(vec_xst_be,1), SUB_VU_I_VU(vec_xst_be,2), SUB_VU_I_VU(vec_xst_be,4), SUB_VU_I_VU(vec_xst_be,8)
procedure :: SUB_VR_I_VR(vec_xst_be,4), SUB_VR_I_VR(vec_xst_be,8)
procedure :: SUB_VI_I_I(vec_xst_be,1), SUB_VI_I_I(vec_xst_be,2), SUB_VI_I_I(vec_xst_be,4), SUB_VI_I_I(vec_xst_be,8)
procedure :: SUB_VU_I_I(vec_xst_be,1), SUB_VU_I_I(vec_xst_be,2), SUB_VU_I_I(vec_xst_be,4), SUB_VU_I_I(vec_xst_be,8)
procedure :: SUB_VR_I_R(vec_xst_be,4), SUB_VR_I_R(vec_xst_be,8)
end interface vec_xst_be
public :: vec_xst_be
! vec_xstd2
VEC_SUB_VI_I_VI(vec_xstd2_,1) VEC_SUB_VI_I_VI(vec_xstd2_,2) VEC_SUB_VI_I_VI(vec_xstd2_,4) VEC_SUB_VI_I_VI(vec_xstd2_,8)
VEC_SUB_VU_I_VU(vec_xstd2_,1) VEC_SUB_VU_I_VU(vec_xstd2_,2) VEC_SUB_VU_I_VU(vec_xstd2_,4) VEC_SUB_VU_I_VU(vec_xstd2_,8)
VEC_SUB_VR_I_VR(vec_xstd2_,4) VEC_SUB_VR_I_VR(vec_xstd2_,8)
VEC_SUB_VI_I_I(vec_xstd2_,1) VEC_SUB_VI_I_I(vec_xstd2_,2) VEC_SUB_VI_I_I(vec_xstd2_,4) VEC_SUB_VI_I_I(vec_xstd2_,8)
VEC_SUB_VU_I_I(vec_xstd2_,1) VEC_SUB_VU_I_I(vec_xstd2_,2) VEC_SUB_VU_I_I(vec_xstd2_,4) VEC_SUB_VU_I_I(vec_xstd2_,8)
VEC_SUB_VR_I_R(vec_xstd2_,4) VEC_SUB_VR_I_R(vec_xstd2_,8)
interface vec_xstd2
procedure :: SUB_VI_I_VI(vec_xstd2_,1), SUB_VI_I_VI(vec_xstd2_,2), SUB_VI_I_VI(vec_xstd2_,4), SUB_VI_I_VI(vec_xstd2_,8)
procedure :: SUB_VU_I_VU(vec_xstd2_,1), SUB_VU_I_VU(vec_xstd2_,2), SUB_VU_I_VU(vec_xstd2_,4), SUB_VU_I_VU(vec_xstd2_,8)
procedure :: SUB_VR_I_VR(vec_xstd2_,4), SUB_VR_I_VR(vec_xstd2_,8)
procedure :: SUB_VI_I_I(vec_xstd2_,1), SUB_VI_I_I(vec_xstd2_,2), SUB_VI_I_I(vec_xstd2_,4), SUB_VI_I_I(vec_xstd2_,8)
procedure :: SUB_VU_I_I(vec_xstd2_,1), SUB_VU_I_I(vec_xstd2_,2), SUB_VU_I_I(vec_xstd2_,4), SUB_VU_I_I(vec_xstd2_,8)
procedure :: SUB_VR_I_R(vec_xstd2_,4), SUB_VR_I_R(vec_xstd2_,8)
end interface vec_xstd2
public :: vec_xstd2
! vec_xstw4
VEC_SUB_VI_I_VI(vec_xstw4_,1) VEC_SUB_VI_I_VI(vec_xstw4_,2) VEC_SUB_VI_I_VI(vec_xstw4_,4)
VEC_SUB_VU_I_VU(vec_xstw4_,1) VEC_SUB_VU_I_VU(vec_xstw4_,2) VEC_SUB_VU_I_VU(vec_xstw4_,4)
VEC_SUB_VR_I_VR(vec_xstw4_,4)
VEC_SUB_VI_I_I(vec_xstw4_,1) VEC_SUB_VI_I_I(vec_xstw4_,2) VEC_SUB_VI_I_I(vec_xstw4_,4)
VEC_SUB_VU_I_I(vec_xstw4_,1) VEC_SUB_VU_I_I(vec_xstw4_,2) VEC_SUB_VU_I_I(vec_xstw4_,4)
VEC_SUB_VR_I_R(vec_xstw4_,4)
interface vec_xstw4
procedure :: SUB_VI_I_VI(vec_xstw4_,1), SUB_VI_I_VI(vec_xstw4_,2), SUB_VI_I_VI(vec_xstw4_,4)
procedure :: SUB_VU_I_VU(vec_xstw4_,1), SUB_VU_I_VU(vec_xstw4_,2), SUB_VU_I_VU(vec_xstw4_,4)
procedure :: SUB_VR_I_VR(vec_xstw4_,4)
procedure :: SUB_VI_I_I(vec_xstw4_,1), SUB_VI_I_I(vec_xstw4_,2), SUB_VI_I_I(vec_xstw4_,4)
procedure :: SUB_VU_I_I(vec_xstw4_,1), SUB_VU_I_I(vec_xstw4_,2), SUB_VU_I_I(vec_xstw4_,4)
procedure :: SUB_VR_I_R(vec_xstw4_,4)
end interface vec_xstw4
public :: vec_xstw4
#undef VEC_SUB_VI_I_VI
#undef VEC_SUB_VU_I_VU
#undef VEC_SUB_VR_I_VR
#undef VEC_SUB_VI_I_I
#undef VEC_SUB_VU_I_I
#undef VEC_SUB_VR_I_R
#undef SUB_VI_I_VI
#undef SUB_VU_I_VU
#undef SUB_VR_I_VR
#undef SUB_VI_I_I
#undef SUB_VU_I_I
#undef SUB_VR_Ik_R
!-----------------------------------------------------------------------
! subroutine(__vector_pair, integer, __vector_pair/vector/integer/real)
!-----------------------------------------------------------------------
#define VP_I0_VI(NAME, VKIND) __ppc_##NAME##_vpi0vi##VKIND
#define VP_I0_VU(NAME, VKIND) __ppc_##NAME##_vpi0vu##VKIND
#define VP_I0_VR(NAME, VKIND) __ppc_##NAME##_vpi0vr##VKIND
#define VEC_VP_I0_VI(NAME, VKIND) \
procedure(sub_vpi0vi##VKIND) :: VP_I0_VI(NAME, VKIND);
#define VEC_VP_I0_VU(NAME, VKIND) \
procedure(sub_vpi0vu##VKIND) :: VP_I0_VU(NAME, VKIND);
#define VEC_VP_I0_VR(NAME, VKIND) \
procedure(sub_vpi0vr##VKIND) :: VP_I0_VR(NAME, VKIND);
! vec_stxvp
procedure(sub_vpi0vp) :: __ppc_vec_stxvp_vpi0vp0
procedure(sub_vpi0i0) :: __ppc_vec_stxvp_vpi0i0
procedure(sub_vpi0r0) :: __ppc_vec_stxvp_vpi0r0
VEC_VP_I0_VI(vec_stxvp, 1) VEC_VP_I0_VI(vec_stxvp, 2) VEC_VP_I0_VI(vec_stxvp, 4) VEC_VP_I0_VI(vec_stxvp, 8)
VEC_VP_I0_VU(vec_stxvp, 1) VEC_VP_I0_VU(vec_stxvp, 2) VEC_VP_I0_VU(vec_stxvp, 4) VEC_VP_I0_VU(vec_stxvp, 8)
VEC_VP_I0_VR(vec_stxvp, 4) VEC_VP_I0_VR(vec_stxvp, 8)
interface vec_stxvp
procedure :: __ppc_vec_stxvp_vpi0vp0
procedure :: __ppc_vec_stxvp_vpi0i0
procedure :: __ppc_vec_stxvp_vpi0r0
procedure :: VP_I0_VI(vec_stxvp, 1), VP_I0_VI(vec_stxvp, 2), VP_I0_VI(vec_stxvp, 4), VP_I0_VI(vec_stxvp, 8)
procedure :: VP_I0_VU(vec_stxvp, 1), VP_I0_VU(vec_stxvp, 2), VP_I0_VU(vec_stxvp, 4), VP_I0_VU(vec_stxvp, 8)
procedure :: VP_I0_VR(vec_stxvp, 4), VP_I0_VR(vec_stxvp, 8)
end interface vec_stxvp
public :: vec_stxvp
! vsx_stxvp (alias to vec_stxvp)
interface vsx_stxvp
procedure :: __ppc_vec_stxvp_vpi0vp0
procedure :: __ppc_vec_stxvp_vpi0i0
procedure :: __ppc_vec_stxvp_vpi0r0
procedure :: VP_I0_VI(vec_stxvp, 1), VP_I0_VI(vec_stxvp, 2), VP_I0_VI(vec_stxvp, 4), VP_I0_VI(vec_stxvp, 8)
procedure :: VP_I0_VU(vec_stxvp, 1), VP_I0_VU(vec_stxvp, 2), VP_I0_VU(vec_stxvp, 4), VP_I0_VU(vec_stxvp, 8)
procedure :: VP_I0_VR(vec_stxvp, 4), VP_I0_VR(vec_stxvp, 8)
end interface vsx_stxvp
public :: vsx_stxvp
#undef VEC_VP_I0_VR
#undef VEC_VP_I0_VU
#undef VEC_VP_I0_VI
#undef VP_I0_VR
#undef VP_I0_VU
#undef VP_I0_VI
end module __ppc_intrinsics
Reference in New Issue View Git Blame Copy Permalink