1!===-- module/__ppc_intrinsics.f90 -----------------------------------------===! 2! 3! Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4! See https://llvm.org/LICENSE.txt for license information. 5! SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6! 7!===------------------------------------------------------------------------===! 8 9module __ppc_intrinsics 10 11 private 12 13! fmadd, fmsub, fnmadd, fnmsub 14 abstract interface 15 elemental real(4) function func_r4r4r4r4(a, x, y) 16 real(4), intent(in) :: a, x, y 17 end function func_r4r4r4r4 18 elemental real(8) function func_r8r8r8r8(a, x, y) 19 real(8), intent(in) :: a, x, y 20 end function func_r8r8r8r8 21 22!-------------------- 23! Vector intrinsic 24!-------------------- 25!! ================ 1 argument function interface ================ 26! vector(i) function f(vector(i)) 27#define ELEM_FUNC_VIVI(VKIND) \ 28 elemental vector(integer(VKIND)) function elem_func_vi##VKIND##vi##VKIND(arg1); \ 29 vector(integer(VKIND)), intent(in) :: arg1; \ 30 end function ; 31 32! vector(u) function f(vector(u)) 33#define ELEM_FUNC_VUVU(VKIND) \ 34 elemental vector(unsigned(VKIND)) function elem_func_vu##VKIND##vu##VKIND(arg1); \ 35 vector(unsigned(VKIND)), intent(in) :: arg1; \ 36 end function ; 37 38! vector(r) function f(vector(r)) 39#define ELEM_FUNC_VRVR_2(VKIND1, VKIND2) \ 40 elemental vector(real(VKIND1)) function elem_func_vr##VKIND1##vr##VKIND2(arg1); \ 41 vector(real(VKIND2)), intent(in) :: arg1; \ 42 end function ; 43#define ELEM_FUNC_VRVR(VKIND) ELEM_FUNC_VRVR_2(VKIND, VKIND) 44 45! vector(i) function f(i) 46#define ELEM_FUNC_VII_2(RKIND, VKIND) \ 47 elemental vector(integer(RKIND)) function elem_func_vi##RKIND##i##VKIND(arg1); \ 48 integer(VKIND), intent(in) :: arg1; \ 49 end function ; 50#define ELEM_FUNC_VII(VKIND) ELEM_FUNC_VII_2(VKIND, VKIND) 51 52! vector(r) function f(r) 53#define ELEM_FUNC_VRR(VKIND) \ 54 elemental vector(real(VKIND)) function elem_func_vr##VKIND##r##VKIND(arg1); \ 55 real(VKIND), intent(in) :: arg1; \ 56 end function ; 57 58 ELEM_FUNC_VIVI(1) ELEM_FUNC_VIVI(2) ELEM_FUNC_VIVI(4) ELEM_FUNC_VIVI(8) 59 ELEM_FUNC_VUVU(1) 60 ELEM_FUNC_VRVR_2(4,8) ELEM_FUNC_VRVR_2(8,4) 61 ELEM_FUNC_VRVR(4) ELEM_FUNC_VRVR(8) 62 ELEM_FUNC_VII_2(4,1) ELEM_FUNC_VII_2(4,2) ELEM_FUNC_VII_2(4,8) 63 ELEM_FUNC_VII(1) ELEM_FUNC_VII(2) ELEM_FUNC_VII(4) ELEM_FUNC_VII(8) 64 ELEM_FUNC_VRR(4) ELEM_FUNC_VRR(8) 65 66#undef ELEM_FUNC_VRR 67#undef ELEM_FUNC_VII 68#undef ELEM_FUNC_VII_2 69#undef ELEM_FUNC_VRVR 70#undef ELEM_FUNC_VRVR_2 71#undef ELEM_FUNC_VUVU 72#undef ELEM_FUNC_VIVI 73 74!! ================ 2 arguments function interface ================ 75! vector(i) function f(vector(i), vector(i)) 76#define ELEM_FUNC_VIVIVI(VKIND) \ 77 elemental vector(integer(VKIND)) function elem_func_vi##VKIND##vi##VKIND##vi##VKIND(arg1, arg2); \ 78 vector(integer(VKIND)), intent(in) :: arg1, arg2; \ 79 end function ; 80 81! vector(u) function f(vector(i), vector(i)) 82#define ELEM_FUNC_VUVIVI(VKIND) \ 83 elemental vector(unsigned(VKIND)) function elem_func_vu##VKIND##vi##VKIND##vi##VKIND(arg1, arg2); \ 84 vector(integer(VKIND)), intent(in) :: arg1, arg2; \ 85 end function ; 86 87! vector(i) function f(vector(i), vector(u)) 88#define ELEM_FUNC_VIVIVU_2(VKIND1, VKIND2) \ 89 elemental vector(integer(VKIND1)) function elem_func_vi##VKIND1##vi##VKIND1##vu##VKIND2(arg1, arg2); \ 90 vector(integer(VKIND1)), intent(in) :: arg1; \ 91 vector(unsigned(VKIND2)), intent(in) :: arg2; \ 92 end function ; 93#define ELEM_FUNC_VIVIVU(VKIND) ELEM_FUNC_VIVIVU_2(VKIND, VKIND) 94 95! vector(u) function f(vector(u), vector(u)) 96#define ELEM_FUNC_VUVUVU_2(VKIND1, VKIND2) \ 97 elemental vector(unsigned(VKIND1)) function elem_func_vu##VKIND1##vu##VKIND1##vu##VKIND2(arg1, arg2); \ 98 vector(unsigned(VKIND1)), intent(in) :: arg1; \ 99 vector(unsigned(VKIND2)), intent(in) :: arg2; \ 100 end function ; 101#define ELEM_FUNC_VUVUVU(VKIND) ELEM_FUNC_VUVUVU_2(VKIND, VKIND) 102 103! vector(r) function f(vector(r), vector(r)) 104#define ELEM_FUNC_VRVRVR(VKIND) \ 105 elemental vector(real(VKIND)) function elem_func_vr##VKIND##vr##VKIND##vr##VKIND(arg1, arg2); \ 106 vector(real(VKIND)), intent(in) :: arg1, arg2; \ 107 end function ; 108 109! vector(r) function f(vector(r), vector(u)) 110#define ELEM_FUNC_VRVRVU_2(VKIND1, VKIND2) \ 111 elemental vector(real(VKIND1)) function elem_func_vr##VKIND1##vr##VKIND1##vu##VKIND2(arg1, arg2); \ 112 vector(real(VKIND1)), intent(in) :: arg1; \ 113 vector(unsigned(VKIND2)), intent(in) :: arg2; \ 114 end function ; 115 116! vector(u) function f(vector(r), vector(r)) 117#define ELEM_FUNC_VUVRVR(VKIND) \ 118 elemental vector(unsigned(VKIND)) function elem_func_vu##VKIND##vr##VKIND##vr##VKIND(arg1, arg2); \ 119 vector(real(VKIND)), intent(in) :: arg1, arg2; \ 120 end function ; 121 122! integer function f(vector(i), vector(i)) 123#define ELEM_FUNC_IVIVI(RKIND, VKIND) \ 124 elemental integer(RKIND) function elem_func_i##RKIND##vi##VKIND##vi##VKIND(arg1, arg2); \ 125 vector(integer(VKIND)), intent(in) :: arg1, arg2; \ 126 end function ; 127 128! integer function f(vector(u), vector(u)) 129#define ELEM_FUNC_IVUVU(RKIND, VKIND) \ 130 elemental integer(RKIND) function elem_func_i##RKIND##vu##VKIND##vu##VKIND(arg1, arg2); \ 131 vector(unsigned(VKIND)), intent(in) :: arg1, arg2; \ 132 end function ; 133 134! integer function f(vector(r), vector(r)) 135#define ELEM_FUNC_IVRVR(RKIND, VKIND) \ 136 elemental integer(RKIND) function elem_func_i##RKIND##vr##VKIND##vr##VKIND(arg1, arg2); \ 137 vector(real(VKIND)), intent(in) :: arg1, arg2; \ 138 end function ; 139 140! vector(r) function f(vector(i), i) 141#define ELEM_FUNC_VRVII(VKIND) \ 142 elemental vector(real(VKIND)) function elem_func_vr##VKIND##vi##VKIND##i(arg1, arg2); \ 143 vector(integer(VKIND)), intent(in) :: arg1; \ 144 integer(8), intent(in) :: arg2; \ 145 !dir$ ignore_tkr(k) arg2; \ 146 end function ; 147 148! integer function f(vector(i), i) 149#define ELEM_FUNC_IVII(VKIND) \ 150 elemental integer(VKIND) function elem_func_i##VKIND##vi##VKIND##i(arg1, arg2); \ 151 vector(integer(VKIND)), intent(in) :: arg1; \ 152 integer(8), intent(in) :: arg2; \ 153 !dir$ ignore_tkr(k) arg2; \ 154 end function ; 155 156! vector(r) function f(vector(u), i) 157#define ELEM_FUNC_VRVUI(VKIND) \ 158 elemental vector(real(VKIND)) function elem_func_vr##VKIND##vu##VKIND##i(arg1, arg2); \ 159 vector(unsigned(VKIND)), intent(in) :: arg1; \ 160 integer(8), intent(in) :: arg2; \ 161 !dir$ ignore_tkr(k) arg2; \ 162 end function ; 163 164! real function f(vector(r), i) 165#define ELEM_FUNC_RVRI(VKIND) \ 166 elemental real(VKIND) function elem_func_r##VKIND##vr##VKIND##i(arg1, arg2); \ 167 vector(real(VKIND)), intent(in) :: arg1; \ 168 integer(8), intent(in) :: arg2; \ 169 !dir$ ignore_tkr(k) arg2; \ 170 end function ; 171 172! vector(i) function f(vector(i), i) 173#define ELEM_FUNC_VIVII0(VKIND) \ 174 elemental vector(integer(VKIND)) function elem_func_vi##VKIND##vi##VKIND##i0(arg1, arg2); \ 175 vector(integer(VKIND)), intent(in) :: arg1; \ 176 integer(8), intent(in) :: arg2; \ 177 !dir$ ignore_tkr(k) arg2; \ 178 end function ; 179 180! vector(u) function f(vector(u), i) 181#define ELEM_FUNC_VUVUI0(VKIND) \ 182 elemental vector(unsigned(VKIND)) function elem_func_vu##VKIND##vu##VKIND##i0(arg1, arg2); \ 183 vector(unsigned(VKIND)), intent(in) :: arg1; \ 184 integer(8), intent(in) :: arg2; \ 185 !dir$ ignore_tkr(k) arg2; \ 186 end function ; 187 188! vector(r) function f(vector(r), i) 189#define ELEM_FUNC_VRVRI0(VKIND) \ 190 elemental vector(real(VKIND)) function elem_func_vr##VKIND##vr##VKIND##i0(arg1, arg2); \ 191 vector(real(VKIND)), intent(in) :: arg1; \ 192 integer(8), intent(in) :: arg2; \ 193 !dir$ ignore_tkr(k) arg2; \ 194 end function ; 195 196! vector(i) function f(i, integer) 197#define FUNC_VII0I(VKIND) \ 198 pure vector(integer(VKIND)) function func_vi##VKIND##i0i##VKIND(arg1, arg2); \ 199 integer(8), intent(in) :: arg1; \ 200 !dir$ ignore_tkr(k) arg1; \ 201 integer(VKIND), intent(in) :: arg2; \ 202 !dir$ ignore_tkr(r) arg2; \ 203 end function ; 204 205! vector(r) function f(i, real) 206#define FUNC_VRI0R(VKIND) \ 207 pure vector(real(VKIND)) function func_vr##VKIND##i0r##VKIND(arg1, arg2); \ 208 integer(8), intent(in) :: arg1; \ 209 !dir$ ignore_tkr(k) arg1; \ 210 real(VKIND), intent(in) :: arg2; \ 211 !dir$ ignore_tkr(r) arg2; \ 212 end function ; 213 214! vector(i) function f(i, vector(i)) 215#define FUNC_VII0VI(VKIND) \ 216 pure vector(integer(VKIND)) function func_vi##VKIND##i0vi##VKIND(arg1, arg2); \ 217 integer(8), intent(in) :: arg1; \ 218 !dir$ ignore_tkr(k) arg1; \ 219 vector(integer(VKIND)), intent(in) :: arg2; \ 220 !dir$ ignore_tkr(r) arg2; \ 221 end function ; 222 223! vector(u) function f(i, vector(u)) 224#define FUNC_VUI0VU(VKIND) \ 225 pure vector(unsigned(VKIND)) function func_vu##VKIND##i0vu##VKIND(arg1, arg2); \ 226 integer(8), intent(in) :: arg1; \ 227 !dir$ ignore_tkr(k) arg1; \ 228 vector(unsigned(VKIND)), intent(in) :: arg2; \ 229 !dir$ ignore_tkr(r) arg2; \ 230 end function ; 231 232! vector(r) function f(i, vector(r)) 233#define FUNC_VRI0VR(VKIND) \ 234 pure vector(real(VKIND)) function func_vr##VKIND##i0vr##VKIND(arg1, arg2); \ 235 integer(8), intent(in) :: arg1; \ 236 !dir$ ignore_tkr(k) arg1; \ 237 vector(real(VKIND)), intent(in) :: arg2; \ 238 !dir$ ignore_tkr(r) arg2; \ 239 end function ; 240 241! vector(u(1)) function f(i, i) 242#define FUNC_VU1I0I(KIND) \ 243 vector(unsigned(1)) function func_vu1i0i##KIND(arg1, arg2); \ 244 integer(8), intent(in) :: arg1; \ 245 !dir$ ignore_tkr(k) arg1; \ 246 integer(KIND), intent(in) :: arg2; \ 247 !dir$ ignore_tkr(r) arg2; \ 248 end function ; 249 250! vector(u(1)) function f(i, r) 251#define FUNC_VU1I0R(KIND) \ 252 vector(unsigned(1)) function func_vu1i0r##KIND(arg1, arg2); \ 253 integer(8), intent(in) :: arg1; \ 254 !dir$ ignore_tkr(k) arg1; \ 255 real(KIND), intent(in) :: arg2; \ 256 !dir$ ignore_tkr(r) arg2; \ 257 end function ; 258 259! __vector_pair function f(i, vector(i)) 260#define FUNC_VPI0VI(VKIND) \ 261 pure __vector_pair function func_vpi0vi##VKIND(arg1, arg2); \ 262 integer(8), intent(in) :: arg1; \ 263 !dir$ ignore_tkr(k) arg1; \ 264 vector(integer(VKIND)), intent(in) :: arg2; \ 265 !dir$ ignore_tkr(r) arg2; \ 266 end function; 267 268! __vector_pair function f(i, vector(u)) 269#define FUNC_VPI0VU(VKIND) \ 270 pure __vector_pair function func_vpi0vu##VKIND(arg1, arg2); \ 271 integer(8), intent(in) :: arg1; \ 272 !dir$ ignore_tkr(k) arg1; \ 273 vector(unsigned(VKIND)), intent(in) :: arg2; \ 274 !dir$ ignore_tkr(r) arg2; \ 275 end function; 276 277! __vector_pair function f(i, vector(r)) 278#define FUNC_VPI0VR(VKIND) \ 279 pure __vector_pair function func_vpi0vr##VKIND(arg1, arg2); \ 280 integer(8), intent(in) :: arg1; \ 281 !dir$ ignore_tkr(k) arg1; \ 282 vector(real(VKIND)), intent(in) :: arg2; \ 283 !dir$ ignore_tkr(r) arg2; \ 284 end function; 285 286! __vector_pair function f(i, __vector_pair) 287#define FUNC_VPI0VP \ 288 pure __vector_pair function func_vpi0vp(arg1, arg2); \ 289 integer(8), intent(in) :: arg1; \ 290 !dir$ ignore_tkr(k) arg1; \ 291 __vector_pair, intent(in) :: arg2; \ 292 !dir$ ignore_tkr(r) arg2; \ 293 end function; 294 295! The following macros are specific for the vec_convert(v, mold) intrinsics as 296! the argument keywords are different from the other vector intrinsics. 297! 298! vector(i) function f(vector(i), vector(i)) 299#define FUNC_VEC_CONVERT_VIVIVI(VKIND) \ 300 pure vector(integer(VKIND)) function func_vec_convert_vi##VKIND##vi##vi##VKIND(v, mold); \ 301 vector(integer(8)), intent(in) :: v; \ 302 !dir$ ignore_tkr(tk) v; \ 303 vector(integer(VKIND)), intent(in) :: mold; \ 304 !dir$ ignore_tkr(r) mold; \ 305 end function ; 306 307! vector(u) function f(vector(i), vector(u)) 308#define FUNC_VEC_CONVERT_VUVIVU(VKIND) \ 309 pure vector(unsigned(VKIND)) function func_vec_convert_vu##VKIND##vi##vu##VKIND(v, mold); \ 310 vector(integer(8)), intent(in) :: v; \ 311 !dir$ ignore_tkr(tk) v; \ 312 vector(unsigned(VKIND)), intent(in) :: mold; \ 313 !dir$ ignore_tkr(r) mold; \ 314 end function ; 315 316! vector(r) function f(vector(i), vector(r)) 317#define FUNC_VEC_CONVERT_VRVIVR(VKIND) \ 318 pure vector(real(VKIND)) function func_vec_convert_vr##VKIND##vi##vr##VKIND(v, mold); \ 319 vector(integer(8)), intent(in) :: v; \ 320 !dir$ ignore_tkr(tk) v; \ 321 vector(real(VKIND)), intent(in) :: mold; \ 322 !dir$ ignore_tkr(r) mold; \ 323 end function ; 324 325 FUNC_VEC_CONVERT_VIVIVI(1) FUNC_VEC_CONVERT_VIVIVI(2) FUNC_VEC_CONVERT_VIVIVI(4) FUNC_VEC_CONVERT_VIVIVI(8) 326 FUNC_VEC_CONVERT_VUVIVU(1) FUNC_VEC_CONVERT_VUVIVU(2) FUNC_VEC_CONVERT_VUVIVU(4) FUNC_VEC_CONVERT_VUVIVU(8) 327 FUNC_VEC_CONVERT_VRVIVR(4) FUNC_VEC_CONVERT_VRVIVR(8) 328 ELEM_FUNC_IVII(1) ELEM_FUNC_IVII(2) ELEM_FUNC_IVII(4) ELEM_FUNC_IVII(8) 329 ELEM_FUNC_RVRI(4) ELEM_FUNC_RVRI(8) 330 ELEM_FUNC_VIVIVI(1) ELEM_FUNC_VIVIVI(2) ELEM_FUNC_VIVIVI(4) ELEM_FUNC_VIVIVI(8) 331 ELEM_FUNC_VUVIVI(1) ELEM_FUNC_VUVIVI(2) ELEM_FUNC_VUVIVI(4) ELEM_FUNC_VUVIVI(8) 332 ELEM_FUNC_VUVUVU(1) ELEM_FUNC_VUVUVU(2) ELEM_FUNC_VUVUVU(4) ELEM_FUNC_VUVUVU(8) 333 ELEM_FUNC_VIVIVU(1) ELEM_FUNC_VIVIVU(2) ELEM_FUNC_VIVIVU(4) ELEM_FUNC_VIVIVU(8) 334 ELEM_FUNC_VIVIVU_2(1,2) ELEM_FUNC_VIVIVU_2(1,4) 335 ELEM_FUNC_VIVIVU_2(2,1) ELEM_FUNC_VIVIVU_2(2,4) 336 ELEM_FUNC_VIVIVU_2(4,1) ELEM_FUNC_VIVIVU_2(4,2) 337 ELEM_FUNC_VUVUVU_2(1,2) ELEM_FUNC_VUVUVU_2(1,4) 338 ELEM_FUNC_VUVUVU_2(2,1) ELEM_FUNC_VUVUVU_2(2,4) 339 ELEM_FUNC_VUVUVU_2(4,1) ELEM_FUNC_VUVUVU_2(4,2) 340 ELEM_FUNC_VRVRVU_2(4,1) ELEM_FUNC_VRVRVU_2(4,2) 341 ELEM_FUNC_VRVRVR(4) ELEM_FUNC_VRVRVR(8) 342 ELEM_FUNC_VUVRVR(4) ELEM_FUNC_VUVRVR(8) 343 ELEM_FUNC_IVIVI(4,1) ELEM_FUNC_IVIVI(4,2) ELEM_FUNC_IVIVI(4,4) ELEM_FUNC_IVIVI(4,8) 344 ELEM_FUNC_IVUVU(4,1) ELEM_FUNC_IVUVU(4,2) ELEM_FUNC_IVUVU(4,4) ELEM_FUNC_IVUVU(4,8) 345 ELEM_FUNC_IVRVR(4,4) ELEM_FUNC_IVRVR(4,8) 346 ELEM_FUNC_VRVII(4) ELEM_FUNC_VRVII(8) 347 ELEM_FUNC_VRVUI(4) ELEM_FUNC_VRVUI(8) 348 ELEM_FUNC_VIVII0(1) ELEM_FUNC_VIVII0(2) ELEM_FUNC_VIVII0(4) ELEM_FUNC_VIVII0(8) 349 ELEM_FUNC_VUVUI0(1) ELEM_FUNC_VUVUI0(2) ELEM_FUNC_VUVUI0(4) ELEM_FUNC_VUVUI0(8) 350 ELEM_FUNC_VRVRI0(4) ELEM_FUNC_VRVRI0(8) 351 FUNC_VII0VI(1) FUNC_VII0VI(2) FUNC_VII0VI(4) FUNC_VII0VI(8) 352 FUNC_VUI0VU(1) FUNC_VUI0VU(2) FUNC_VUI0VU(4) FUNC_VUI0VU(8) 353 FUNC_VRI0VR(4) FUNC_VRI0VR(8) 354 FUNC_VII0I(1) FUNC_VII0I(2) FUNC_VII0I(4) FUNC_VII0I(8) 355 FUNC_VRI0R(4) FUNC_VRI0R(8) 356 FUNC_VPI0VI(1) FUNC_VPI0VI(2) FUNC_VPI0VI(4) FUNC_VPI0VI(8) 357 FUNC_VPI0VU(1) FUNC_VPI0VU(2) FUNC_VPI0VU(4) FUNC_VPI0VU(8) 358 FUNC_VPI0VR(4) FUNC_VPI0VR(8) 359 FUNC_VPI0VP 360 FUNC_VU1I0I(1) FUNC_VU1I0I(2) FUNC_VU1I0I(4) 361 FUNC_VU1I0R(4) 362 363#undef FUNC_VEC_CONVERT_VRVIVR 364#undef FUNC_VEC_CONVERT_VUVIVU 365#undef FUNC_VEC_CONVERT_VIVIVI 366#undef FUNC_VPI0VP 367#undef FUNC_VPI0VR 368#undef FUNC_VPI0VU 369#undef FUNC_VPI0VI 370#undef FUNC_VU1I0R 371#undef FUNC_VU1I0I 372#undef FUNC_VRI0VR 373#undef FUNC_VUI0VU 374#undef FUNC_VII0VI 375#undef FUNC_VRI0R 376#undef FUNC_VII0I 377#undef ELEM_FUNC_VRVRI0 378#undef ELEM_FUNC_VUVUI0 379#undef ELEM_FUNC_VIVII0 380#undef ELEM_FUNC_RVRI 381#undef ELEM_FUNC_VRVUI 382#undef ELEM_FUNC_IVII 383#undef ELEM_FUNC_VRVII 384#undef ELEM_FUNC_IVRVR 385#undef ELEM_FUNC_IVUVU 386#undef ELEM_FUNC_IVIVI 387#undef ELEM_FUNC_VUVRVR 388#undef ELEM_FUNC_VRVRVU_2 389#undef ELEM_FUNC_VRVRVR 390#undef ELEM_FUNC_VUVUVU 391#undef ELEM_FUNC_VUVUVU_2 392#undef ELEM_FUNC_VIVIVU 393#undef ELEM_FUNC_VIVIVU_2 394#undef ELEM_FUNC_VUVIVI 395#undef ELEM_FUNC_VIVIVI 396 397!! ================ 3 arguments function interface ================ 398! vector(r) function f(vector(r), vector(r), vector(r)) 399#define ELEM_FUNC_VRVRVRVR(VKIND) \ 400 elemental vector(real(VKIND)) function elem_func_vr##VKIND##vr##VKIND##vr##VKIND##vr##VKIND(arg1, arg2, arg3); \ 401 vector(real(VKIND)), intent(in) :: arg1, arg2, arg3; \ 402 end function ; 403 404! vector(i) function f(vector(i), vector(i), vector(u)) 405#define ELEM_FUNC_VIVIVIVU_2(VKIND, UKIND) \ 406 elemental vector(integer(VKIND)) function elem_func_vi##VKIND##vi##VKIND##vi##VKIND##vu##UKIND(arg1, arg2, arg3); \ 407 vector(integer(VKIND)), intent(in) :: arg1, arg2; \ 408 vector(unsigned(UKIND)), intent(in) :: arg3; \ 409 end function ; 410#define ELEM_FUNC_VIVIVIVU(VKIND) ELEM_FUNC_VIVIVIVU_2(VKIND, VKIND) 411 412! vector(u) function f(vector(u), vector(u), vector(u)) 413#define ELEM_FUNC_VUVUVUVU_2(VKIND, UKIND) \ 414 elemental vector(unsigned(VKIND)) function elem_func_vu##VKIND##vu##VKIND##vu##VKIND##vu##UKIND(arg1, arg2, arg3); \ 415 vector(unsigned(VKIND)), intent(in) :: arg1, arg2; \ 416 vector(unsigned(UKIND)), intent(in) :: arg3; \ 417 end function ; 418#define ELEM_FUNC_VUVUVUVU(VKIND) ELEM_FUNC_VUVUVUVU_2(VKIND, VKIND) 419 420! vector(r) function f(vector(r), vector(r), vector(u)) 421#define ELEM_FUNC_VRVRVRVU_2(VKIND, UKIND) \ 422 elemental vector(real(VKIND)) function elem_func_vr##VKIND##vr##VKIND##vr##VKIND##vu##UKIND(arg1, arg2, arg3); \ 423 vector(real(VKIND)), intent(in) :: arg1, arg2; \ 424 vector(unsigned(UKIND)), intent(in) :: arg3; \ 425 end function ; 426#define ELEM_FUNC_VRVRVRVU(VKIND) ELEM_FUNC_VRVRVRVU_2(VKIND, VKIND) 427 428! vector(i) function f(vector(i), vector(i), i) 429#define ELEM_FUNC_VIVIVII(VKIND) \ 430 elemental vector(integer(VKIND)) function elem_func_vi##VKIND##vi##VKIND##vi##VKIND##i(arg1, arg2, arg3); \ 431 vector(integer(VKIND)), intent(in) :: arg1, arg2; \ 432 integer(8), intent(in) :: arg3; \ 433 !dir$ ignore_tkr(k) arg3; \ 434 end function ; 435 436! vector(u) function f(vector(u), vector(u), i) 437#define ELEM_FUNC_VUVUVUI(VKIND) \ 438 elemental vector(unsigned(VKIND)) function elem_func_vu##VKIND##vu##VKIND##vu##VKIND##i(arg1, arg2, arg3); \ 439 vector(unsigned(VKIND)), intent(in) :: arg1, arg2; \ 440 integer(8), intent(in) :: arg3; \ 441 !dir$ ignore_tkr(k) arg3; \ 442 end function ; 443 444! vector(r) function f(vector(r), vector(r), i) 445#define ELEM_FUNC_VRVRVRI(VKIND) \ 446 elemental vector(real(VKIND)) function elem_func_vr##VKIND##vr##VKIND##vr##VKIND##i(arg1, arg2, arg3); \ 447 vector(real(VKIND)), intent(in) :: arg1, arg2; \ 448 integer(8), intent(in) :: arg3; \ 449 !dir$ ignore_tkr(k) arg3; \ 450 end function ; 451 452! vector(i) function f(i, vector(i), i) 453#define ELEM_FUNC_VIIVII(VKIND) \ 454 elemental vector(integer(VKIND)) function elem_func_vi##VKIND##i##VKIND##vi##VKIND##i(arg1, arg2, arg3); \ 455 integer(VKIND), intent(in) :: arg1; \ 456 vector(integer(VKIND)), intent(in) :: arg2; \ 457 integer(8), intent(in) :: arg3; \ 458 !dir$ ignore_tkr(k) arg3; \ 459 end function ; 460 461! vector(r) function f(r, vector(r), i) 462#define ELEM_FUNC_VRRVRI(VKIND) \ 463 elemental vector(real(VKIND)) function elem_func_vr##VKIND##r##VKIND##vr##VKIND##i(arg1, arg2, arg3); \ 464 real(VKIND), intent(in) :: arg1; \ 465 vector(real(VKIND)), intent(in) :: arg2; \ 466 integer(8), intent(in) :: arg3; \ 467 !dir$ ignore_tkr(k) arg3; \ 468 end function ; 469 470 ELEM_FUNC_VIVIVIVU(1) ELEM_FUNC_VIVIVIVU(2) ELEM_FUNC_VIVIVIVU(4) ELEM_FUNC_VIVIVIVU(8) 471 ELEM_FUNC_VUVUVUVU(1) ELEM_FUNC_VUVUVUVU(2) ELEM_FUNC_VUVUVUVU(4) ELEM_FUNC_VUVUVUVU(8) 472 ELEM_FUNC_VRVRVRVU(4) ELEM_FUNC_VRVRVRVU(8) 473 ELEM_FUNC_VIVIVIVU_2(2,1) ELEM_FUNC_VIVIVIVU_2(4,1) ELEM_FUNC_VIVIVIVU_2(8,1) 474 ELEM_FUNC_VUVUVUVU_2(2,1) ELEM_FUNC_VUVUVUVU_2(4,1) ELEM_FUNC_VUVUVUVU_2(8,1) 475 ELEM_FUNC_VRVRVRVU_2(4,1) ELEM_FUNC_VRVRVRVU_2(8,1) 476 ELEM_FUNC_VIIVII(1) ELEM_FUNC_VIIVII(2) ELEM_FUNC_VIIVII(4) ELEM_FUNC_VIIVII(8) 477 ELEM_FUNC_VRRVRI(4) ELEM_FUNC_VRRVRI(8) 478 ELEM_FUNC_VRVRVRVR(4) ELEM_FUNC_VRVRVRVR(8) 479 ELEM_FUNC_VIVIVII(1) ELEM_FUNC_VIVIVII(2) ELEM_FUNC_VIVIVII(4) ELEM_FUNC_VIVIVII(8) 480 ELEM_FUNC_VUVUVUI(1) ELEM_FUNC_VUVUVUI(2) ELEM_FUNC_VUVUVUI(4) ELEM_FUNC_VUVUVUI(8) 481 ELEM_FUNC_VRVRVRI(4) ELEM_FUNC_VRVRVRI(8) 482 483#undef ELEM_FUNC_VRRVRI 484#undef ELEM_FUNC_VIIVII 485#undef ELEM_FUNC_VRVRVRI 486#undef ELEM_FUNC_VUVUVUI 487#undef ELEM_FUNC_VIVIVII 488#undef ELEM_FUNC_VRVRVRVU 489#undef ELEM_FUNC_VRVRVRVU_2 490#undef ELEM_FUNC_VUVUVUVU 491#undef ELEM_FUNC_VUVUVUVU_2 492#undef ELEM_FUNC_VIVIVIVU 493#undef ELEM_FUNC_VIVIVIVU_2 494#undef ELEM_FUNC_VRVRVRVR 495 496!! ================ 3 argument subroutine interfaces ================================= 497! subroutine(vector(i), i, vector(i)) 498#define SUB_VIIVI(VKIND) \ 499 pure subroutine sub_vi##VKIND##ivi##VKIND(arg1, arg2, arg3); \ 500 vector(integer(VKIND)), intent(in) :: arg1; \ 501 integer(8), intent(in) :: arg2; \ 502 !dir$ ignore_tkr(k) arg2; \ 503 vector(integer(VKIND)), intent(in) :: arg3; \ 504 !dir$ ignore_tkr(r) arg3; \ 505 end subroutine ; 506 507! subroutine(vector(u), i, vector(u)) 508#define SUB_VUIVU(VKIND) \ 509 pure subroutine sub_vu##VKIND##ivu##VKIND(arg1, arg2, arg3); \ 510 vector(unsigned(VKIND)), intent(in) :: arg1; \ 511 integer(8), intent(in) :: arg2; \ 512 !dir$ ignore_tkr(k) arg2; \ 513 vector(unsigned(VKIND)), intent(in) :: arg3; \ 514 !dir$ ignore_tkr(r) arg3; \ 515 end subroutine ; 516 517! subroutine(vector(r), i, vector(r)) 518#define SUB_VRIVR(VKIND) \ 519 pure subroutine sub_vr##VKIND##ivr##VKIND(arg1, arg2, arg3); \ 520 vector(real(VKIND)), intent(in) :: arg1; \ 521 integer(8), intent(in) :: arg2; \ 522 !dir$ ignore_tkr(k) arg2; \ 523 vector(real(VKIND)), intent(in) :: arg3; \ 524 !dir$ ignore_tkr(r) arg3; \ 525 end subroutine ; 526 527! subroutine(vector(i), i, i) 528#define SUB_VIII(VKIND) \ 529 pure subroutine sub_vi##VKIND##ii##VKIND(arg1, arg2, arg3); \ 530 vector(integer(VKIND)), intent(in) :: arg1; \ 531 integer(8), intent(in) :: arg2; \ 532 !dir$ ignore_tkr(k) arg2; \ 533 integer(VKIND), intent(out) :: arg3; \ 534 !dir$ ignore_tkr(r) arg3; \ 535 end subroutine ; 536 537! subroutine(vector(u), i, i) 538#define SUB_VUII(VKIND) \ 539 pure subroutine sub_vu##VKIND##ii##VKIND(arg1, arg2, arg3); \ 540 vector(unsigned(VKIND)), intent(in) :: arg1; \ 541 integer(8), intent(in) :: arg2; \ 542 !dir$ ignore_tkr(k) arg2; \ 543 integer(VKIND), intent(out) :: arg3; \ 544 !dir$ ignore_tkr(r) arg3; \ 545 end subroutine ; 546 547! subroutine(vector(r), i, r) 548#define SUB_VRIR(VKIND) \ 549 pure subroutine sub_vr##VKIND##ir##VKIND(arg1, arg2, arg3); \ 550 vector(real(VKIND)), intent(in) :: arg1; \ 551 integer(8), intent(in) :: arg2; \ 552 !dir$ ignore_tkr(k) arg2; \ 553 real(VKIND), intent(out) :: arg3; \ 554 !dir$ ignore_tkr(r) arg3; \ 555 end subroutine ; 556 557! subroutine(__vector_pair, i, __vector_pair) 558 pure subroutine sub_vpi0vp(arg1, arg2, arg3) 559 __vector_pair, intent(in) :: arg1 560 integer(8), intent(in) :: arg2 561 !dir$ ignore_tkr(k) arg2 562 __vector_pair, intent(out) :: arg3 563 !dir$ ignore_tkr(r) arg3 564 end subroutine 565 566! subroutine(__vector_pair, i, vector(i)) 567#define SUB_VPI0VI(VKIND) \ 568 pure subroutine sub_vpi0vi##VKIND(arg1, arg2, arg3); \ 569 __vector_pair, intent(in) :: arg1; \ 570 integer(8), intent(in) :: arg2; \ 571 !dir$ ignore_tkr(k) arg2; \ 572 vector(integer(VKIND)), intent(out) :: arg3; \ 573 !dir$ ignore_tkr(r) arg3; \ 574 end subroutine; 575 576! subroutine(__vector_pair, i, vector(u)) 577#define SUB_VPI0VU(VKIND) \ 578 pure subroutine sub_vpi0vu##VKIND(arg1, arg2, arg3); \ 579 __vector_pair, intent(in) :: arg1; \ 580 integer(8), intent(in) :: arg2; \ 581 !dir$ ignore_tkr(k) arg2; \ 582 vector(unsigned(VKIND)), intent(out) :: arg3; \ 583 !dir$ ignore_tkr(r) arg3; \ 584 end subroutine; 585 586! subroutine(__vector_pair, i, vector(r)) 587#define SUB_VPI0VR(VKIND) \ 588 pure subroutine sub_vpi0vr##VKIND(arg1, arg2, arg3); \ 589 __vector_pair, intent(in) :: arg1; \ 590 integer(8), intent(in) :: arg2; \ 591 !dir$ ignore_tkr(k) arg2; \ 592 vector(real(VKIND)), intent(out) :: arg3; \ 593 !dir$ ignore_tkr(r) arg3; \ 594 end subroutine; 595 596! subroutine(__vector_pair, i, i) 597 pure subroutine sub_vpi0i0(arg1, arg2, arg3) 598 __vector_pair, intent(in) :: arg1 599 integer(8), intent(in) :: arg2 600 !dir$ ignore_tkr(k) arg2 601 integer(8), intent(out) :: arg3 602 !dir$ ignore_tkr(kr) arg3 603 end subroutine 604 605! subroutine(__vector_pair, i, r) 606 pure subroutine sub_vpi0r0(arg1, arg2, arg3) 607 __vector_pair, intent(in) :: arg1 608 integer(8), intent(in) :: arg2 609 !dir$ ignore_tkr(k) arg2 610 real(8), intent(out) :: arg3 611 !dir$ ignore_tkr(kr) arg3 612 end subroutine 613 614 SUB_VIIVI(1) SUB_VIIVI(2) SUB_VIIVI(4) SUB_VIIVI(8) 615 SUB_VUIVU(1) SUB_VUIVU(2) SUB_VUIVU(4) SUB_VUIVU(8) 616 SUB_VRIVR(4) SUB_VRIVR(8) 617 SUB_VIII(1) SUB_VIII(2) SUB_VIII(4) SUB_VIII(8) 618 SUB_VUII(1) SUB_VUII(2) SUB_VUII(4) SUB_VUII(8) 619 SUB_VRIR(4) SUB_VRIR(8) 620 SUB_VPI0VI(1) SUB_VPI0VI(2) SUB_VPI0VI(4) SUB_VPI0VI(8) 621 SUB_VPI0VU(1) SUB_VPI0VU(2) SUB_VPI0VU(4) SUB_VPI0VU(8) 622 SUB_VPI0VR(4) SUB_VPI0VR(8) 623 624#undef SUB_VPI0VR 625#undef SUB_VPI0VU 626#undef SUB_VPI0VI 627#undef SUB_VRIR 628#undef SUB_VUII 629#undef SUB_VIII 630#undef SUB_VRIVR 631#undef SUB_VUIVU 632#undef SUB_VIIVI 633 634 end interface 635 636 procedure(func_r4r4r4r4) :: __ppc_fmadd_r4 637 procedure(func_r8r8r8r8) :: __ppc_fmadd_r8 638 interface fmadd 639 procedure :: __ppc_fmadd_r4 640 procedure :: __ppc_fmadd_r8 641 end interface fmadd 642 public :: fmadd 643 644 procedure(func_r4r4r4r4) :: __ppc_fmsub_r4 645 procedure(func_r8r8r8r8) :: __ppc_fmsub_r8 646 interface fmsub 647 procedure :: __ppc_fmsub_r4 648 procedure :: __ppc_fmsub_r8 649 end interface fmsub 650 public :: fmsub 651 652 procedure(func_r4r4r4r4) :: __ppc_fnmadd_r4 653 procedure(func_r8r8r8r8) :: __ppc_fnmadd_r8 654 interface fnmadd 655 procedure :: __ppc_fnmadd_r4 656 procedure :: __ppc_fnmadd_r8 657 end interface fnmadd 658 public :: fnmadd 659 660 procedure(func_r4r4r4r4) :: __ppc_fnmsub_r4 661 procedure(func_r8r8r8r8) :: __ppc_fnmsub_r8 662 interface fnmsub 663 procedure :: __ppc_fnmsub_r4 664 procedure :: __ppc_fnmsub_r8 665 end interface fnmsub 666 public :: fnmsub 667 668! fctid, fctidz, fctiw, fctiwz, fctudz, fctuwz 669 abstract interface 670 elemental real(4) function func_r4r4x(x) 671 real(4), intent(in) :: x 672 end function func_r4r4x 673 elemental real(8) function func_r8r8x(x) 674 real(8), intent(in) :: x 675 end function func_r8r8x 676 end interface 677 678 procedure(func_r8r8x) :: __ppc_fctid 679 interface fctid 680 procedure :: __ppc_fctid 681 end interface fctid 682 public :: fctid 683 684 procedure(func_r8r8x) :: __ppc_fctidz 685 interface fctidz 686 procedure :: __ppc_fctidz 687 end interface fctidz 688 public :: fctidz 689 690 procedure(func_r8r8x) :: __ppc_fctiw 691 interface fctiw 692 procedure :: __ppc_fctiw 693 end interface fctiw 694 public :: fctiw 695 696 procedure(func_r8r8x) :: __ppc_fctiwz 697 interface fctiwz 698 procedure :: __ppc_fctiwz 699 end interface fctiwz 700 public :: fctiwz 701 702 procedure(func_r8r8x) :: __ppc_fctudz 703 interface fctudz 704 procedure :: __ppc_fctudz 705 end interface fctudz 706 public :: fctudz 707 708 procedure(func_r8r8x) :: __ppc_fctuwz 709 interface fctuwz 710 procedure :: __ppc_fctuwz 711 end interface fctuwz 712 public :: fctuwz 713 714! fcfi, fcfid, fcfud 715 abstract interface 716 elemental real(8) function func_r8r8i(i) 717 real(8), intent(in) :: i 718 end function func_r8r8i 719 end interface 720 721 procedure(func_r8r8i) :: __ppc_fcfi 722 interface fcfi 723 procedure :: __ppc_fcfi 724 end interface fcfi 725 public :: fcfi 726 727 procedure(func_r8r8i) :: __ppc_fcfid 728 interface fcfid 729 procedure :: __ppc_fcfid 730 end interface fcfid 731 public :: fcfid 732 733 procedure(func_r8r8i) :: __ppc_fcfud 734 interface fcfud 735 procedure :: __ppc_fcfud 736 end interface fcfud 737 public :: fcfud 738 739! fnabs 740 procedure(func_r4r4x) :: __ppc_fnabs_r4 741 procedure(func_r8r8x) :: __ppc_fnabs_r8 742 interface fnabs 743 procedure :: __ppc_fnabs_r4 744 procedure :: __ppc_fnabs_r8 745 end interface fnabs 746 public :: fnabs 747 748! fre, fres 749 procedure(func_r8r8x) :: __ppc_fre 750 interface fre 751 procedure :: __ppc_fre 752 end interface fre 753 public :: fre 754 755 procedure(func_r4r4x) :: __ppc_fres 756 interface fres 757 procedure :: __ppc_fres 758 end interface fres 759 public :: fres 760 761! frsqrte, frsqrtes 762 procedure(func_r8r8x) :: __ppc_frsqrte 763 interface frsqrte 764 procedure :: __ppc_frsqrte 765 end interface frsqrte 766 public :: frsqrte 767 768 procedure(func_r4r4x) :: __ppc_frsqrtes 769 interface frsqrtes 770 procedure :: __ppc_frsqrtes 771 end interface frsqrtes 772 public :: frsqrtes 773 774! mtfsf, mtfsfi 775 interface mtfsf 776 subroutine __ppc_mtfsf(mask, r) 777 integer(4), intent(in) :: mask 778 real(8), intent(in) :: r 779 end subroutine __ppc_mtfsf 780 end interface mtfsf 781 public :: mtfsf 782 783 interface mtfsfi 784 subroutine __ppc_mtfsfi(bf, i) 785 integer(4), intent(in) :: bf 786 integer(4), intent(in) :: i 787 end subroutine __ppc_mtfsfi 788 end interface mtfsfi 789 public :: mtfsfi 790 791!----------------------------- 792! vector function(vector/i/r) 793!----------------------------- 794#define VI_VI(NAME, VKIND) __ppc_##NAME##_vi##VKIND##vi##VKIND 795#define VU_VU(NAME, VKIND) __ppc_##NAME##_vu##VKIND##vu##VKIND 796#define VR_VR_2(NAME, VKIND1, VKIND2) __ppc_##NAME##_vr##VKIND1##vr##VKIND2 797#define VR_VR(NAME, VKIND) VR_VR_2(NAME, VKIND, VKIND) 798#define VI_I_2(NAME, RKIND, VKIND) __ppc_##NAME##_vi##RKIND##i##VKIND 799#define VI_I(NAME, VKIND) VI_I_2(NAME, VKIND, VKIND) 800#define VR_R(NAME, VKIND) __ppc_##NAME##_vr##VKIND##r##VKIND 801 802#define VEC_VI_VI(NAME, VKIND) \ 803 procedure(elem_func_vi##VKIND##vi##VKIND) :: VI_VI(NAME, VKIND); 804#define VEC_VU_VU(NAME, VKIND) \ 805 procedure(elem_func_vu##VKIND##vu##VKIND) :: VU_VU(NAME, VKIND); 806#define VEC_VR_VR_2(NAME, VKIND1, VKIND2) \ 807 procedure(elem_func_vr##VKIND1##vr##VKIND2) :: VR_VR_2(NAME, VKIND1, VKIND2); 808#define VEC_VR_VR(NAME, VKIND) VEC_VR_VR_2(NAME, VKIND, VKIND) 809#define VEC_VI_I_2(NAME, RKIND, VKIND) \ 810 procedure(elem_func_vi##RKIND##i##VKIND) :: VI_I_2(NAME, RKIND, VKIND); 811#define VEC_VI_I(NAME, VKIND) VEC_VI_I_2(NAME, VKIND, VKIND) 812#define VEC_VR_R(NAME, VKIND) \ 813 procedure(elem_func_vr##VKIND##r##VKIND) :: VR_R(NAME, VKIND); 814 815! vec_abs 816 VEC_VI_VI(vec_abs,1) VEC_VI_VI(vec_abs,2) VEC_VI_VI(vec_abs,4) VEC_VI_VI(vec_abs,8) 817 VEC_VR_VR(vec_abs,4) VEC_VR_VR(vec_abs,8) 818 interface vec_abs 819 procedure :: VI_VI(vec_abs,1), VI_VI(vec_abs,2), VI_VI(vec_abs,4), VI_VI(vec_abs,8) 820 procedure :: VR_VR(vec_abs,4), VR_VR(vec_abs,8) 821 end interface vec_abs 822 public :: vec_abs 823 824! vec_cvf 825 VEC_VR_VR_2(vec_cvf,4,8) VEC_VR_VR_2(vec_cvf,8,4) 826 interface vec_cvf 827 procedure :: VR_VR_2(vec_cvf,4,8), VR_VR_2(vec_cvf,8,4) 828 end interface vec_cvf 829 public :: vec_cvf 830 831! vec_cvbf16spn 832 VEC_VU_VU(vec_cvbf16spn,1) 833 interface vec_cvbf16spn 834 procedure :: VU_VU(vec_cvbf16spn,1) 835 end interface 836 public vec_cvbf16spn 837 838! vec_cvspbf16 839 VEC_VU_VU(vec_cvspbf16_,1) 840 interface vec_cvspbf16 841 procedure :: VU_VU(vec_cvspbf16_,1) 842 end interface 843 public vec_cvspbf16 844 845! vec_splats 846 VEC_VI_I(vec_splats,1) VEC_VI_I(vec_splats,2) VEC_VI_I(vec_splats,4) VEC_VI_I(vec_splats,8) 847 VEC_VR_R(vec_splats,4) VEC_VR_R(vec_splats,8) 848 interface vec_splats 849 procedure :: VI_I(vec_splats,1), VI_I(vec_splats,2), VI_I(vec_splats,4), VI_I(vec_splats,8) 850 procedure :: VR_R(vec_splats,4), VR_R(vec_splats,8) 851 end interface vec_splats 852 public :: vec_splats 853 854! vec_splat_32 855 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) 856 interface vec_splat_s32 857 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) 858 end interface vec_splat_s32 859 public :: vec_splat_s32 860 861#undef VEC_VR_R 862#undef VEC_VI_I 863#undef VEC_VI_I_2 864#undef VEC_VR_VR 865#undef VEC_VR_VR_2 866#undef VEC_VU_VU 867#undef VEC_VI_VI 868#undef VR_R 869#undef VI_I 870#undef VI_I_2 871#undef VR_VR 872#undef VR_VR_2 873#undef VU_VU 874#undef VI_VI 875 876!--------------------------------- 877! vector function(vector, vector) 878!--------------------------------- 879#define VI_VI_VI(NAME, VKIND) __ppc_##NAME##_vi##VKIND##vi##VKIND##vi##VKIND 880#define VU_VI_VI(NAME, VKIND) __ppc_##NAME##_vu##VKIND##vi##VKIND##vi##VKIND 881#define VU_VU_VU_2(NAME, VKIND1, VKIND2) __ppc_##NAME##_vu##VKIND1##vu##VKIND1##vu##VKIND2 882#define VU_VU_VU(NAME, VKIND) VU_VU_VU_2(NAME, VKIND, VKIND) 883#define VI_VI_VU_2(NAME, VKIND1, VKIND2) __ppc_##NAME##_vi##VKIND1##vi##VKIND1##vu##VKIND2 884#define VI_VI_VU(NAME, VKIND) VI_VI_VU_2(NAME, VKIND, VKIND) 885#define VR_VR_VR(NAME, VKIND) __ppc_##NAME##_vr##VKIND##vr##VKIND##vr##VKIND 886#define VR_VR_VU_2(NAME, VKIND1, VKIND2) __ppc_##NAME##_vr##VKIND1##vr##VKIND1##vu##VKIND2 887#define VU_VR_VR(NAME, VKIND) __ppc_##NAME##_vu##VKIND##vr##VKIND##vr##VKIND 888 889#define VEC_VI_VI_VI(NAME, VKIND) \ 890 procedure(elem_func_vi##VKIND##vi##VKIND##vi##VKIND) :: VI_VI_VI(NAME, VKIND); 891#define VEC_VU_VI_VI(NAME, VKIND) \ 892 procedure(elem_func_vu##VKIND##vi##VKIND##vi##VKIND) :: VU_VI_VI(NAME, VKIND); 893#define VEC_VU_VU_VU_2(NAME, VKIND1, VKIND2) \ 894 procedure(elem_func_vu##VKIND1##vu##VKIND1##vu##VKIND2) :: VU_VU_VU_2(NAME, VKIND1, VKIND2); 895#define VEC_VU_VU_VU(NAME, VKIND) VEC_VU_VU_VU_2(NAME, VKIND, VKIND) 896#define VEC_VI_VI_VU_2(NAME, VKIND1, VKIND2) \ 897 procedure(elem_func_vi##VKIND1##vi##VKIND1##vu##VKIND2) :: VI_VI_VU_2(NAME, VKIND1, VKIND2); 898#define VEC_VI_VI_VU(NAME, VKIND) VEC_VI_VI_VU_2(NAME, VKIND, VKIND) 899#define VEC_VR_VR_VR(NAME, VKIND) \ 900 procedure(elem_func_vr##VKIND##vr##VKIND##vr##VKIND) :: VR_VR_VR(NAME, VKIND); 901#define VEC_VU_VR_VR(NAME, VKIND) \ 902 procedure(elem_func_vu##VKIND##vr##VKIND##vr##VKIND) :: VU_VR_VR(NAME, VKIND); 903#define VEC_VR_VR_VU(NAME, VKIND1, VKIND2) \ 904 procedure(elem_func_vr##VKIND1##vr##VKIND1##vu##VKIND2) :: VR_VR_VU_2(NAME, VKIND1, VKIND2); 905 906! vec_add 907 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) 908 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) 909 VEC_VR_VR_VR(vec_add,4) VEC_VR_VR_VR(vec_add,8) 910 interface vec_add 911 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) 912 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) 913 procedure :: VR_VR_VR(vec_add,4), VR_VR_VR(vec_add,8) 914 end interface vec_add 915 public :: vec_add 916 917! vec_and 918 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) 919 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) 920 VEC_VR_VR_VR(vec_and,4) VEC_VR_VR_VR(vec_and,8) 921 interface vec_and 922 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) 923 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) 924 procedure :: VR_VR_VR(vec_and,4), VR_VR_VR(vec_and,8) 925 end interface vec_and 926 public :: vec_and 927 928! vec_cmpge 929 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) 930 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) 931 VEC_VU_VR_VR(vec_cmpge,4) VEC_VU_VR_VR(vec_cmpge,8) 932 interface vec_cmpge 933 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) 934 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) 935 procedure :: VU_VR_VR(vec_cmpge,4), VU_VR_VR(vec_cmpge,8) 936 end interface vec_cmpge 937 public :: vec_cmpge 938 939! vec_cmpgt 940 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) 941 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) 942 VEC_VU_VR_VR(vec_cmpgt,4) VEC_VU_VR_VR(vec_cmpgt,8) 943 interface vec_cmpgt 944 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) 945 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) 946 procedure :: VU_VR_VR(vec_cmpgt,4), VU_VR_VR(vec_cmpgt,8) 947 end interface vec_cmpgt 948 public :: vec_cmpgt 949 950! vec_cmple 951 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) 952 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) 953 VEC_VU_VR_VR(vec_cmple,4) VEC_VU_VR_VR(vec_cmple,8) 954 interface vec_cmple 955 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) 956 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) 957 procedure :: VU_VR_VR(vec_cmple,4), VU_VR_VR(vec_cmple,8) 958 end interface vec_cmple 959 public :: vec_cmple 960 961! vec_cmplt 962 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) 963 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) 964 VEC_VU_VR_VR(vec_cmplt,4) VEC_VU_VR_VR(vec_cmplt,8) 965 interface vec_cmplt 966 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) 967 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) 968 procedure :: VU_VR_VR(vec_cmplt,4), VU_VR_VR(vec_cmplt,8) 969 end interface vec_cmplt 970 public :: vec_cmplt 971 972! vec_convert 973! Argument 'v' has the `ignore_tkr` directive 974#define CONVERT_VI_VI_VI(VKIND) __ppc_vec_convert_vi##VKIND##vi##vi##VKIND 975#define CONVERT_VU_VI_VU(VKIND) __ppc_vec_convert_vu##VKIND##vi##vu##VKIND 976#define CONVERT_VR_VI_VR(VKIND) __ppc_vec_convert_vr##VKIND##vi##vr##VKIND 977 978#define VEC_CONVERT_VI_VI_VI(VKIND) \ 979 procedure(func_vec_convert_vi##VKIND##vi##vi##VKIND) :: CONVERT_VI_VI_VI(VKIND); 980#define VEC_CONVERT_VU_VI_VU(VKIND) \ 981 procedure(func_vec_convert_vu##VKIND##vi##vu##VKIND) :: CONVERT_VU_VI_VU(VKIND); 982#define VEC_CONVERT_VR_VI_VR(VKIND) \ 983 procedure(func_vec_convert_vr##VKIND##vi##vr##VKIND) :: CONVERT_VR_VI_VR(VKIND); 984 985 VEC_CONVERT_VI_VI_VI(1) VEC_CONVERT_VI_VI_VI(2) VEC_CONVERT_VI_VI_VI(4) VEC_CONVERT_VI_VI_VI(8) 986 VEC_CONVERT_VU_VI_VU(1) VEC_CONVERT_VU_VI_VU(2) VEC_CONVERT_VU_VI_VU(4) VEC_CONVERT_VU_VI_VU(8) 987 VEC_CONVERT_VR_VI_VR(4) VEC_CONVERT_VR_VI_VR(8) 988 interface vec_convert 989 procedure :: CONVERT_VI_VI_VI(1), CONVERT_VI_VI_VI(2), CONVERT_VI_VI_VI(4), CONVERT_VI_VI_VI(8) 990 procedure :: CONVERT_VU_VI_VU(1), CONVERT_VU_VI_VU(2), CONVERT_VU_VI_VU(4), CONVERT_VU_VI_VU(8) 991 procedure :: CONVERT_VR_VI_VR(4), CONVERT_VR_VI_VR(8) 992 end interface vec_convert 993 public :: vec_convert 994 995#undef VEC_CONVERT_VR_VI_VR 996#undef VEC_CONVERT_VU_VI_VU 997#undef VEC_CONVERT_VI_VI_VI 998#undef CONVERT_VR_VI_VR 999#undef CONVERT_VU_VI_VU 1000#undef CONVERT_VI_VI_VI 1001 1002! vec_max 1003 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) 1004 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) 1005 VEC_VR_VR_VR(vec_max,4) VEC_VR_VR_VR(vec_max,8) 1006 interface vec_max 1007 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) 1008 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) 1009 procedure :: VR_VR_VR(vec_max,4), VR_VR_VR(vec_max,8) 1010 end interface vec_max 1011 public :: vec_max 1012 1013! vec_mergeh 1014 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) 1015 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) 1016 VEC_VR_VR_VR(vec_mergeh,4) VEC_VR_VR_VR(vec_mergeh,8) 1017 interface vec_mergeh 1018 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) 1019 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) 1020 procedure :: VR_VR_VR(vec_mergeh,4), VR_VR_VR(vec_mergeh,8) 1021 end interface vec_mergeh 1022 public :: vec_mergeh 1023 1024! vec_mergel 1025 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) 1026 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) 1027 VEC_VR_VR_VR(vec_mergel,4) VEC_VR_VR_VR(vec_mergel,8) 1028 interface vec_mergel 1029 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) 1030 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) 1031 procedure :: VR_VR_VR(vec_mergel,4), VR_VR_VR(vec_mergel,8) 1032 end interface vec_mergel 1033 public :: vec_mergel 1034 1035! vec_min 1036 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) 1037 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) 1038 VEC_VR_VR_VR(vec_min,4) VEC_VR_VR_VR(vec_min,8) 1039 interface vec_min 1040 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) 1041 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) 1042 procedure :: VR_VR_VR(vec_min,4), VR_VR_VR(vec_min,8) 1043 end interface vec_min 1044 public :: vec_min 1045 1046! vec_mul 1047 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) 1048 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) 1049 VEC_VR_VR_VR(vec_mul,4) VEC_VR_VR_VR(vec_mul,8) 1050 interface vec_mul 1051 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) 1052 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) 1053 procedure :: VR_VR_VR(vec_mul,4), VR_VR_VR(vec_mul,8) 1054 end interface vec_mul 1055 public :: vec_mul 1056 1057! vec_sub 1058 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) 1059 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) 1060 VEC_VR_VR_VR(vec_sub,4) VEC_VR_VR_VR(vec_sub,8) 1061 interface vec_sub 1062 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) 1063 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) 1064 procedure :: VR_VR_VR(vec_sub,4), VR_VR_VR(vec_sub,8) 1065 end interface vec_sub 1066 public :: vec_sub 1067 1068! vec_sl 1069 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) 1070 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) 1071 interface vec_sl 1072 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) 1073 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) 1074 end interface vec_sl 1075 public :: vec_sl 1076 1077! vec_sll 1078 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) 1079 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) 1080 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) 1081 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) 1082 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) 1083 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) 1084 interface vec_sll 1085 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) 1086 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) 1087 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) 1088 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) 1089 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) 1090 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) 1091 end interface vec_sll 1092 public :: vec_sll 1093 1094! vec_slo 1095 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) 1096 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) 1097 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) 1098 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) 1099 VEC_VR_VR_VU(vec_slo,4,1) VEC_VR_VR_VU(vec_slo,4,2) 1100 interface vec_slo 1101 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) 1102 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) 1103 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) 1104 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) 1105 procedure :: VR_VR_VU_2(vec_slo,4,1), VR_VR_VU_2(vec_slo,4,2) 1106 end interface vec_slo 1107 public :: vec_slo 1108 1109! vec_sr 1110 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) 1111 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) 1112 interface vec_sr 1113 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) 1114 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) 1115 end interface vec_sr 1116 public :: vec_sr 1117 1118! vec_srl 1119 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) 1120 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) 1121 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) 1122 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) 1123 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) 1124 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) 1125 interface vec_srl 1126 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) 1127 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) 1128 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) 1129 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) 1130 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) 1131 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) 1132 end interface vec_srl 1133 public :: vec_srl 1134 1135! vec_sro 1136 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) 1137 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) 1138 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) 1139 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) 1140 VEC_VR_VR_VU(vec_sro,4,1) VEC_VR_VR_VU(vec_sro,4,2) 1141 interface vec_sro 1142 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) 1143 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) 1144 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) 1145 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) 1146 procedure :: VR_VR_VU_2(vec_sro,4,1), VR_VR_VU_2(vec_sro,4,2) 1147 end interface vec_sro 1148 public :: vec_sro 1149 1150! vec_xor 1151 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) 1152 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) 1153 VEC_VR_VR_VR(vec_xor,4) VEC_VR_VR_VR(vec_xor,8) 1154 interface vec_xor 1155 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) 1156 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) 1157 procedure :: VR_VR_VR(vec_xor,4), VR_VR_VR(vec_xor,8) 1158 end interface vec_xor 1159 public :: vec_xor 1160 1161#undef VEC_VU_VR_VR 1162#undef VEC_VR_VR_VR 1163#undef VEC_VU_VU_VU 1164#undef VEC_VU_VU_VU_2 1165#undef VEC_VI_VI_VI 1166#undef VEC_VU_VI_VI 1167#undef VEC_VI_VI_VU 1168#undef VEC_VI_VI_VU_2 1169#undef VU_VR_VR 1170#undef VR_VR_VU_2 1171#undef VR_VR_VR 1172#undef VU_VU_VU 1173#undef VU_VU_VU_2 1174#undef VI_VI_VU 1175#undef VI_VI_VU_2 1176#undef VU_VI_VI 1177#undef VI_VI_VI 1178 1179!------------------------------------------------------- 1180! vector(unsigned(1)) function(integer, i/r) 1181!------------------------------------------------------- 1182#define VU1_I0_I(NAME, KIND) __ppc_##NAME##_vu1i0i##KIND 1183#define VU1_I0_R(NAME, KIND) __ppc_##NAME##_vu1i0r##KIND 1184 1185#define VEC_VU1_I0_I(NAME, KIND) \ 1186 procedure(func_vu1i0i##KIND) :: VU1_I0_I(NAME, KIND); 1187#define VEC_VU1_I0_R(NAME, KIND) \ 1188 procedure(func_vu1i0r##KIND) :: VU1_I0_R(NAME, KIND); 1189 1190! vec_lvsl 1191 VEC_VU1_I0_I(vec_lvsl,1) VEC_VU1_I0_I(vec_lvsl,2) VEC_VU1_I0_I(vec_lvsl,4) 1192 VEC_VU1_I0_R(vec_lvsl,4) 1193 interface vec_lvsl 1194 procedure :: VU1_I0_I(vec_lvsl,1), VU1_I0_I(vec_lvsl,2), VU1_I0_I(vec_lvsl,4) 1195 procedure :: VU1_I0_R(vec_lvsl,4) 1196 end interface 1197 public :: vec_lvsl 1198 1199! vec_lvsr 1200 VEC_VU1_I0_I(vec_lvsr,1) VEC_VU1_I0_I(vec_lvsr,2) VEC_VU1_I0_I(vec_lvsr,4) 1201 VEC_VU1_I0_R(vec_lvsr,4) 1202 interface vec_lvsr 1203 procedure :: VU1_I0_I(vec_lvsr,1), VU1_I0_I(vec_lvsr,2), VU1_I0_I(vec_lvsr,4) 1204 procedure :: VU1_I0_R(vec_lvsr,4) 1205 end interface 1206 public :: vec_lvsr 1207 1208#undef VEC_VU1_I0_R 1209#undef VEC_VU1_I0_I 1210#undef VU1_I0_R 1211#undef VU1_I0_I 1212 1213!------------------------------------------------------- 1214! vector function(integer, i/u/r/vector) 1215!------------------------------------------------------- 1216! i0 means the integer argument has ignore_tkr(k) 1217#define VI_I0_VI(NAME, VKIND) __ppc_##NAME##_vi##VKIND##i0##vi##VKIND 1218#define VU_I0_VU(NAME, VKIND) __ppc_##NAME##_vu##VKIND##i0##vu##VKIND 1219#define VR_I0_VR(NAME, VKIND) __ppc_##NAME##_vr##VKIND##i0##vr##VKIND 1220#define VI_I0_I(NAME, VKIND) __ppc_##NAME##_vi##VKIND##i0##i##VKIND 1221#define VR_I0_R(NAME, VKIND) __ppc_##NAME##_vr##VKIND##i0##r##VKIND 1222 1223#define VEC_VI_I0_VI(NAME, VKIND) \ 1224 procedure(func_vi##VKIND##i0##vi##VKIND) :: VI_I0_VI(NAME, VKIND); 1225#define VEC_VU_I0_VU(NAME, VKIND) \ 1226 procedure(func_vu##VKIND##i0##vu##VKIND) :: VU_I0_VU(NAME, VKIND); 1227#define VEC_VR_I0_VR(NAME, VKIND) \ 1228 procedure(func_vr##VKIND##i0##vr##VKIND) :: VR_I0_VR(NAME, VKIND); 1229#define VEC_VI_I0_I(NAME, VKIND) \ 1230 procedure(func_vi##VKIND##i0##i##VKIND) :: VI_I0_I(NAME, VKIND); 1231#define VEC_VR_I0_R(NAME, VKIND) \ 1232 procedure(func_vr##VKIND##i0##r##VKIND) :: VR_I0_R(NAME, VKIND); 1233 1234! vec_ld 1235 VEC_VI_I0_VI(vec_ld,1) VEC_VI_I0_VI(vec_ld,2) VEC_VI_I0_VI(vec_ld,4) 1236 VEC_VU_I0_VU(vec_ld,1) VEC_VU_I0_VU(vec_ld,2) VEC_VU_I0_VU(vec_ld,4) 1237 VEC_VR_I0_VR(vec_ld,4) 1238 VEC_VI_I0_I(vec_ld,1) VEC_VI_I0_I(vec_ld,2) VEC_VI_I0_I(vec_ld,4) 1239 VEC_VR_I0_R(vec_ld,4) 1240 interface vec_ld 1241 procedure :: VI_I0_VI(vec_ld,1), VI_I0_VI(vec_ld,2), VI_I0_VI(vec_ld,4) 1242 procedure :: VU_I0_VU(vec_ld,1), VU_I0_VU(vec_ld,2), VU_I0_VU(vec_ld,4) 1243 procedure :: VR_I0_VR(vec_ld,4) 1244 procedure :: VI_I0_I(vec_ld,1), VI_I0_I(vec_ld,2), VI_I0_I(vec_ld,4) 1245 procedure :: VR_I0_R(vec_ld,4) 1246 end interface 1247 public :: vec_ld 1248 1249! vec_lde 1250 VEC_VI_I0_I(vec_lde,1) VEC_VI_I0_I(vec_lde,2) VEC_VI_I0_I(vec_lde,4) 1251 VEC_VR_I0_R(vec_lde,4) 1252 interface vec_lde 1253 procedure :: VI_I0_I(vec_lde,1), VI_I0_I(vec_lde,2), VI_I0_I(vec_lde,4) 1254 procedure :: VR_I0_R(vec_lde,4) 1255 end interface 1256 public :: vec_lde 1257 1258! vec_ldl 1259 VEC_VI_I0_VI(vec_ldl,1) VEC_VI_I0_VI(vec_ldl,2) VEC_VI_I0_VI(vec_ldl,4) 1260 VEC_VU_I0_VU(vec_ldl,1) VEC_VU_I0_VU(vec_ldl,2) VEC_VU_I0_VU(vec_ldl,4) 1261 VEC_VR_I0_VR(vec_ldl,4) 1262 VEC_VI_I0_I(vec_ldl,1) VEC_VI_I0_I(vec_ldl,2) VEC_VI_I0_I(vec_ldl,4) 1263 VEC_VR_I0_R(vec_ldl,4) 1264 interface vec_ldl 1265 procedure :: VI_I0_VI(vec_ldl,1), VI_I0_VI(vec_ldl,2), VI_I0_VI(vec_ldl,4) 1266 procedure :: VU_I0_VU(vec_ldl,1), VU_I0_VU(vec_ldl,2), VU_I0_VU(vec_ldl,4) 1267 procedure :: VR_I0_VR(vec_ldl,4) 1268 procedure :: VI_I0_I(vec_ldl,1), VI_I0_I(vec_ldl,2), VI_I0_I(vec_ldl,4) 1269 procedure :: VR_I0_R(vec_ldl,4) 1270 end interface 1271 public :: vec_ldl 1272 1273! vec_lxv 1274 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) 1275 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) 1276 VEC_VR_I0_VR(vec_lxv,4) VEC_VR_I0_VR(vec_lxv,8) 1277 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) 1278 VEC_VR_I0_R(vec_lxv,4) VEC_VR_I0_R(vec_lxv,8) 1279 interface vec_lxv 1280 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) 1281 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) 1282 procedure :: VR_I0_VR(vec_lxv,4), VR_I0_VR(vec_lxv,8) 1283 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) 1284 procedure :: VR_I0_R(vec_lxv,4), VR_I0_R(vec_lxv,8) 1285 end interface 1286 public :: vec_lxv 1287 1288! vec_xl 1289 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) 1290 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) 1291 VEC_VR_I0_VR(vec_xl,4) VEC_VR_I0_VR(vec_xl,8) 1292 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) 1293 VEC_VR_I0_R(vec_xl,4) VEC_VR_I0_R(vec_xl,8) 1294 interface vec_xl 1295 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) 1296 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) 1297 procedure :: VR_I0_VR(vec_xl,4), VR_I0_VR(vec_xl,8) 1298 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) 1299 procedure :: VR_I0_R(vec_xl,4), VR_I0_R(vec_xl,8) 1300 end interface 1301 public :: vec_xl 1302 1303! vec_xl_be 1304 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) 1305 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) 1306 VEC_VR_I0_VR(vec_xl_be,4) VEC_VR_I0_VR(vec_xl_be,8) 1307 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) 1308 VEC_VR_I0_R(vec_xl_be,4) VEC_VR_I0_R(vec_xl_be,8) 1309 interface vec_xl_be 1310 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) 1311 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) 1312 procedure :: VR_I0_VR(vec_xl_be,4), VR_I0_VR(vec_xl_be,8) 1313 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) 1314 procedure :: VR_I0_R(vec_xl_be,4), VR_I0_R(vec_xl_be,8) 1315 end interface 1316 public :: vec_xl_be 1317 1318! vec_xld2 1319 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) 1320 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) 1321 VEC_VR_I0_VR(vec_xld2_,4) VEC_VR_I0_VR(vec_xld2_,8) 1322 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) 1323 VEC_VR_I0_R(vec_xld2_,4) VEC_VR_I0_R(vec_xld2_,8) 1324 interface vec_xld2 1325 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) 1326 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) 1327 procedure :: VR_I0_VR(vec_xld2_,4), VR_I0_VR(vec_xld2_,8) 1328 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) 1329 procedure :: VR_I0_R(vec_xld2_,4), VR_I0_R(vec_xld2_,8) 1330 end interface 1331 public :: vec_xld2 1332 1333! vec_xlds 1334 VEC_VI_I0_VI(vec_xlds,8) 1335 VEC_VU_I0_VU(vec_xlds,8) 1336 VEC_VR_I0_VR(vec_xlds,8) 1337 VEC_VI_I0_I(vec_xlds,8) 1338 VEC_VR_I0_R(vec_xlds,8) 1339 interface vec_xlds 1340 procedure :: VI_I0_VI(vec_xlds,8) 1341 procedure :: VU_I0_VU(vec_xlds,8) 1342 procedure :: VR_I0_VR(vec_xlds,8) 1343 procedure :: VI_I0_I(vec_xlds,8) 1344 procedure :: VR_I0_R(vec_xlds,8) 1345 end interface 1346 public :: vec_xlds 1347 1348! vec_xlw4 1349 VEC_VI_I0_VI(vec_xlw4_,1) VEC_VI_I0_VI(vec_xlw4_,2) 1350 VEC_VU_I0_VU(vec_xlw4_,1) VEC_VU_I0_VU(vec_xlw4_,2) VEC_VU_I0_VU(vec_xlw4_,4) 1351 VEC_VR_I0_VR(vec_xlw4_,4) 1352 VEC_VI_I0_I(vec_xlw4_,1) VEC_VI_I0_I(vec_xlw4_,2) VEC_VI_I0_I(vec_xlw4_,4) 1353 VEC_VR_I0_R(vec_xlw4_,4) 1354 interface vec_xlw4 1355 procedure :: VI_I0_VI(vec_xlw4_,1), VI_I0_VI(vec_xlw4_,2) 1356 procedure :: VU_I0_VU(vec_xlw4_,1), VU_I0_VU(vec_xlw4_,2), VU_I0_VU(vec_xlw4_,4) 1357 procedure :: VR_I0_VR(vec_xlw4_,4) 1358 procedure :: VI_I0_I(vec_xlw4_,1), VI_I0_I(vec_xlw4_,2), VI_I0_I(vec_xlw4_,4) 1359 procedure :: VR_I0_R(vec_xlw4_,4) 1360 end interface 1361 public :: vec_xlw4 1362 1363#undef VEC_VR_I0_R 1364#undef VEC_VI_I0_I 1365#undef VEC_VR_I0_VR 1366#undef VEC_VU_I0_VU 1367#undef VEC_VI_I0_VI 1368#undef VR_I0_R 1369#undef VI_I0_I 1370#undef VR_I0_VR 1371#undef VU_I0_VU 1372#undef VI_I0_VI 1373 1374!------------------------------------------------------- 1375! __vector_pair function(integer, vector/__vector_pair) 1376!------------------------------------------------------- 1377#define VP_I0_VI(NAME, VKIND) __ppc_##NAME##_vpi0##vi##VKIND 1378#define VP_I0_VU(NAME, VKIND) __ppc_##NAME##_vpi0##vu##VKIND 1379#define VP_I0_VR(NAME, VKIND) __ppc_##NAME##_vpi0##vr##VKIND 1380#define VP_I0_VP(NAME) __ppc_##NAME##_vpi0vp0 1381 1382#define VEC_VP_I0_VI(NAME, VKIND) \ 1383 procedure(func_vpi0vi##VKIND) :: VP_I0_VI(NAME, VKIND); 1384#define VEC_VP_I0_VU(NAME, VKIND) \ 1385 procedure(func_vpi0vu##VKIND) :: VP_I0_VU(NAME, VKIND); 1386#define VEC_VP_I0_VR(NAME, VKIND) \ 1387 procedure(func_vpi0vr##VKIND) :: VP_I0_VR(NAME, VKIND); 1388#define VEC_VP_I0_VP(NAME) procedure(func_vpi0vp) :: VP_I0_VP(NAME); 1389 1390! vec_lxvp 1391 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) 1392 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) 1393 VEC_VP_I0_VR(vec_lxvp,4) VEC_VP_I0_VR(vec_lxvp,8) 1394 VEC_VP_I0_VP(vec_lxvp) 1395 interface vec_lxvp 1396 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) 1397 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) 1398 procedure :: VP_I0_VR(vec_lxvp,4), VP_I0_VR(vec_lxvp,8) 1399 procedure :: VP_I0_VP(vec_lxvp) 1400 end interface vec_lxvp 1401 public :: vec_lxvp 1402 1403! vsx_lxvp (alias to vec_lxvp) 1404 interface vsx_lxvp 1405 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) 1406 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) 1407 procedure :: VP_I0_VR(vec_lxvp,4), VP_I0_VR(vec_lxvp,8) 1408 procedure :: VP_I0_VP(vec_lxvp) 1409 end interface vsx_lxvp 1410 public :: vsx_lxvp 1411 1412#undef VEC_VP_I0_VP 1413#undef VEC_VP_I0_VR 1414#undef VEC_VP_I0_VU 1415#undef VEC_VP_I0_VI 1416#undef VP_I0_VP 1417#undef VP_I0_VR 1418#undef VP_I0_VU 1419#undef VP_I0_VI 1420 1421!----------------------------------------- 1422! vector function(vector, vector, vector) 1423!----------------------------------------- 1424#define VR_VR_VR_VR(NAME, VKIND) __ppc_##NAME##_vr##VKIND##vr##VKIND##vr##VKIND##vr##VKIND 1425#define VI_VI_VI_VU_2(NAME, VKIND, UKIND) __ppc_##NAME##_vi##VKIND##vi##VKIND##vi##VKIND##vu##UKIND 1426#define VI_VI_VI_VU(NAME, VKIND) VI_VI_VI_VU_2(NAME, VKIND, VKIND) 1427#define VU_VU_VU_VU_2(NAME, VKIND, UKIND) __ppc_##NAME##_vu##VKIND##vu##VKIND##vu##VKIND##vu##UKIND 1428#define VU_VU_VU_VU(NAME, VKIND) VU_VU_VU_VU_2(NAME, VKIND, VKIND) 1429#define VR_VR_VR_VU_2(NAME, VKIND, UKIND) __ppc_##NAME##_vr##VKIND##vr##VKIND##vr##VKIND##vu##UKIND 1430#define VR_VR_VR_VU(NAME, VKIND) VR_VR_VR_VU_2(NAME, VKIND, VKIND) 1431! i0 indicates "!dir$ ignore_tkr(k) arg3" 1432#define VI_VI_VI_I(NAME, VKIND) __ppc_##NAME##_vi##VKIND##vi##VKIND##vi##VKIND##i0 1433#define VU_VU_VU_I(NAME, VKIND) __ppc_##NAME##_vu##VKIND##vu##VKIND##vu##VKIND##i0 1434#define VR_VR_VR_I(NAME, VKIND) __ppc_##NAME##_vr##VKIND##vr##VKIND##vr##VKIND##i0 1435 1436#define VEC_VR_VR_VR_VR(NAME, VKIND) \ 1437 procedure(elem_func_vr##VKIND##vr##VKIND##vr##VKIND##vr##VKIND) :: VR_VR_VR_VR(NAME, VKIND); 1438#define VEC_VI_VI_VI_VU_2(NAME, VKIND, UKIND) \ 1439 procedure(elem_func_vi##VKIND##vi##VKIND##vi##VKIND##vu##UKIND) :: VI_VI_VI_VU_2(NAME, VKIND, UKIND); 1440#define VEC_VI_VI_VI_VU(NAME, VKIND) VEC_VI_VI_VI_VU_2(NAME, VKIND, VKIND) 1441#define VEC_VU_VU_VU_VU_2(NAME, VKIND, UKIND) \ 1442 procedure(elem_func_vu##VKIND##vu##VKIND##vu##VKIND##vu##UKIND) :: VU_VU_VU_VU_2(NAME, VKIND, UKIND); 1443#define VEC_VU_VU_VU_VU(NAME, VKIND) VEC_VU_VU_VU_VU_2(NAME, VKIND, VKIND) 1444#define VEC_VR_VR_VR_VU_2(NAME, VKIND, UKIND) \ 1445 procedure(elem_func_vr##VKIND##vr##VKIND##vr##VKIND##vu##UKIND) :: VR_VR_VR_VU_2(NAME, VKIND, UKIND); 1446#define VEC_VR_VR_VR_VU(NAME, VKIND) VEC_VR_VR_VR_VU_2(NAME, VKIND, VKIND) 1447#define VEC_VI_VI_VI_I(NAME, VKIND) \ 1448 procedure(elem_func_vi##VKIND##vi##VKIND##vi##VKIND##i) :: VI_VI_VI_I(NAME, VKIND); 1449#define VEC_VU_VU_VU_I(NAME, VKIND) \ 1450 procedure(elem_func_vu##VKIND##vu##VKIND##vu##VKIND##i) :: VU_VU_VU_I(NAME, VKIND); 1451#define VEC_VR_VR_VR_I(NAME, VKIND) \ 1452 procedure(elem_func_vr##VKIND##vr##VKIND##vr##VKIND##i) :: VR_VR_VR_I(NAME, VKIND); 1453 1454! vec_madd 1455 VEC_VR_VR_VR_VR(vec_madd,4) VEC_VR_VR_VR_VR(vec_madd,8) 1456 interface vec_madd 1457 procedure :: VR_VR_VR_VR(vec_madd,4), VR_VR_VR_VR(vec_madd,8) 1458 end interface vec_madd 1459 public :: vec_madd 1460 1461! vec_msub 1462 VEC_VR_VR_VR_VR(vec_msub,4) VEC_VR_VR_VR_VR(vec_msub,8) 1463 interface vec_msub 1464 procedure :: VR_VR_VR_VR(vec_msub,4), VR_VR_VR_VR(vec_msub,8) 1465 end interface vec_msub 1466 public :: vec_msub 1467 1468! vec_nmadd 1469 VEC_VR_VR_VR_VR(vec_nmadd,4) VEC_VR_VR_VR_VR(vec_nmadd,8) 1470 interface vec_nmadd 1471 procedure :: VR_VR_VR_VR(vec_nmadd,4), VR_VR_VR_VR(vec_nmadd,8) 1472 end interface vec_nmadd 1473 public :: vec_nmadd 1474 1475! vec_nmsub 1476 VEC_VR_VR_VR_VR(vec_nmsub,4) VEC_VR_VR_VR_VR(vec_nmsub,8) 1477 interface vec_nmsub 1478 procedure :: VR_VR_VR_VR(vec_nmsub,4), VR_VR_VR_VR(vec_nmsub,8) 1479 end interface vec_nmsub 1480 public :: vec_nmsub 1481 1482! vec_perm 1483 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) 1484 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) 1485 VEC_VR_VR_VR_VU_2(vec_perm,4,1) VEC_VR_VR_VR_VU_2(vec_perm,8,1) 1486 interface vec_perm 1487 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) 1488 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) 1489 procedure :: VR_VR_VR_VU_2(vec_perm,4,1), VR_VR_VR_VU_2(vec_perm,8,1) 1490 end interface vec_perm 1491 public :: vec_perm 1492 1493! vec_permi 1494 VEC_VI_VI_VI_I(vec_permi,8) 1495 VEC_VU_VU_VU_I(vec_permi,8) 1496 VEC_VR_VR_VR_I(vec_permi,4) VEC_VR_VR_VR_I(vec_permi,8) 1497 interface vec_permi 1498 procedure :: VI_VI_VI_I(vec_permi,8) 1499 procedure :: VU_VU_VU_I(vec_permi,8) 1500 procedure :: VR_VR_VR_I(vec_permi,4), VR_VR_VR_I(vec_permi,8) 1501 end interface vec_permi 1502 public :: vec_permi 1503 1504! vec_sel 1505 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) 1506 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) 1507 VEC_VR_VR_VR_VU(vec_sel,4) VEC_VR_VR_VR_VU(vec_sel,8) 1508 interface vec_sel 1509 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) 1510 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) 1511 procedure :: VR_VR_VR_VU(vec_sel,4), VR_VR_VR_VU(vec_sel,8) 1512 end interface vec_sel 1513 public :: vec_sel 1514 1515#undef VEC_VR_VR_VR_I 1516#undef VEC_VU_VU_VU_I 1517#undef VEC_VI_VI_VI_I 1518#undef VEC_VI_VI_VI_VU_2 1519#undef VEC_VI_VI_VI_VU 1520#undef VEC_VU_VU_VU_VU_2 1521#undef VEC_VU_VU_VU_VU 1522#undef VEC_VR_VR_VR_VU_2 1523#undef VEC_VR_VR_VR_VU 1524#undef VEC_VR_VR_VR_VR 1525#undef VR_VR_VR_I 1526#undef VU_VU_VU_I 1527#undef VI_VI_VI_I 1528#undef VI_VI_VI_VU 1529#undef VI_VI_VI_VU_2 1530#undef VU_VU_VU_VU 1531#undef VU_VU_VU_VU_2 1532#undef VR_VR_VR_VU 1533#undef VR_VR_VR_VU_2 1534#undef VR_VR_VR_VR 1535 1536!------------------------------------------ 1537! vector function(integer, vector, integer) 1538! vector function(real, vector, integer) 1539!------------------------------------------ 1540#define VI_I_VI_I(NAME, VKIND) __ppc_##NAME##_vi##VKIND##i##VKIND##vi##VKIND##i0 1541#define VR_R_VR_I(NAME, VKIND) __ppc_##NAME##_vr##VKIND##r##VKIND##vr##VKIND##i0 1542 1543#define VEC_VI_I_VI_I(NAME, VKIND) \ 1544 procedure(elem_func_vi##VKIND##i##VKIND##vi##VKIND##i) :: VI_I_VI_I(NAME, VKIND); 1545#define VEC_VR_R_VR_I(NAME, VKIND) \ 1546 procedure(elem_func_vr##VKIND##r##VKIND##vr##VKIND##i) :: VR_R_VR_I(NAME, VKIND); 1547 1548! vec_insert 1549 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) 1550 VEC_VR_R_VR_I(vec_insert,4) VEC_VR_R_VR_I(vec_insert,8) 1551 interface vec_insert 1552 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) 1553 procedure :: VR_R_VR_I(vec_insert,4), VR_R_VR_I(vec_insert,8) 1554 end interface vec_insert 1555 public :: vec_insert 1556 1557#undef VEC_VR_R_VR_I 1558#undef VEC_VI_I_VI_I 1559#undef VR_R_VR_I 1560#undef VI_I_VI_I 1561 1562!---------------------------------- 1563! integer function(vector, vector) 1564!---------------------------------- 1565#define I_VI_VI(NAME, RKIND, VKIND) __ppc_##NAME##_i##RKIND##vi##VKIND##vi##VKIND 1566#define I_VU_VU(NAME, RKIND, VKIND) __ppc_##NAME##_i##RKIND##vu##VKIND##vu##VKIND 1567#define I_VR_VR(NAME, RKIND, VKIND) __ppc_##NAME##_i##RKIND##vr##VKIND##vr##VKIND 1568 1569#define VEC_I_VI_VI(NAME, RKIND, VKIND) \ 1570 procedure(elem_func_i##RKIND##vi##VKIND##vi##VKIND) :: I_VI_VI(NAME, RKIND, VKIND); 1571#define VEC_I_VU_VU(NAME, RKIND, VKIND) \ 1572 procedure(elem_func_i##RKIND##vu##VKIND##vu##VKIND) :: I_VU_VU(NAME, RKIND, VKIND); 1573#define VEC_I_VR_VR(NAME, RKIND, VKIND) \ 1574 procedure(elem_func_i##RKIND##vr##VKIND##vr##VKIND) :: I_VR_VR(NAME, RKIND, VKIND); 1575 1576! vec_any_ge 1577 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) 1578 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) 1579 VEC_I_VR_VR(vec_any_ge,4,4) VEC_I_VR_VR(vec_any_ge,4,8) 1580 interface vec_any_ge 1581 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) 1582 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) 1583 procedure :: I_VR_VR(vec_any_ge,4,4), I_VR_VR(vec_any_ge,4,8) 1584 end interface vec_any_ge 1585 public :: vec_any_ge 1586 1587#undef VEC_I_VR_VR 1588#undef VEC_I_VU_VU 1589#undef VEC_I_VI_VI 1590#undef I_VR_VR 1591#undef I_VU_VU 1592#undef I_VI_VI 1593 1594!---------------------------------------- 1595! integer/real function(vector, integer) 1596!---------------------------------------- 1597#define I_VI_I(NAME, VKIND) __ppc_##NAME##_i##VKIND##vi##VKIND##i0 1598#define R_VR_I(NAME, VKIND) __ppc_##NAME##_r##VKIND##vr##VKIND##i0 1599 1600#define VEC_I_VI_I(NAME, VKIND) \ 1601 procedure(elem_func_i##VKIND##vi##VKIND##i) :: I_VI_I(NAME, VKIND); 1602#define VEC_R_VR_I(NAME, VKIND) \ 1603 procedure(elem_func_r##VKIND##vr##VKIND##i) :: R_VR_I(NAME, VKIND); 1604 1605! vec_extract 1606 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) 1607 VEC_R_VR_I(vec_extract,4) VEC_R_VR_I(vec_extract,8) 1608 interface vec_extract 1609 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) 1610 procedure :: R_VR_I(vec_extract,4), R_VR_I(vec_extract,8) 1611 end interface 1612 public :: vec_extract 1613 1614!------------------------------------------ 1615! vector function(vector, vector, integer) 1616!------------------------------------------ 1617! i0 means the integer argument has ignore_tkr(k) 1618#define VI_VI_VI_I(NAME, VKIND) __ppc_##NAME##_vi##VKIND##vi##VKIND##vi##VKIND##i0 1619#define VU_VU_VU_I(NAME, VKIND) __ppc_##NAME##_vu##VKIND##vu##VKIND##vu##VKIND##i0 1620#define VR_VR_VR_I(NAME, VKIND) __ppc_##NAME##_vr##VKIND##vr##VKIND##vr##VKIND##i0 1621 1622#define VEC_VI_VI_VI_I(NAME, VKIND) \ 1623 procedure(elem_func_vi##VKIND##vi##VKIND##vi##VKIND##i) :: VI_VI_VI_I(NAME, VKIND); 1624#define VEC_VU_VU_VU_I(NAME, VKIND) \ 1625 procedure(elem_func_vu##VKIND##vu##VKIND##vu##VKIND##i) :: VU_VU_VU_I(NAME, VKIND); 1626#define VEC_VR_VR_VR_I(NAME, VKIND) \ 1627 procedure(elem_func_vr##VKIND##vr##VKIND##vr##VKIND##i) :: VR_VR_VR_I(NAME, VKIND); 1628 1629! vec_sld 1630 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) 1631 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) 1632 VEC_VR_VR_VR_I(vec_sld,4) VEC_VR_VR_VR_I(vec_sld,8) 1633 interface vec_sld 1634 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) 1635 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) 1636 procedure :: VR_VR_VR_I(vec_sld,4), VR_VR_VR_I(vec_sld,8) 1637 end interface vec_sld 1638 public :: vec_sld 1639 1640! vec_sldw 1641 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) 1642 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) 1643 VEC_VR_VR_VR_I(vec_sldw,4) VEC_VR_VR_VR_I(vec_sldw,8) 1644 interface vec_sldw 1645 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) 1646 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) 1647 procedure :: VR_VR_VR_I(vec_sldw,4), VR_VR_VR_I(vec_sldw,8) 1648 end interface vec_sldw 1649 public :: vec_sldw 1650 1651#undef VEC_VR_VR_VR_I 1652#undef VEC_VU_VU_VU_I 1653#undef VEC_VI_VI_VI_I 1654#undef VR_VR_VR_I 1655#undef VU_VU_VU_I 1656#undef VI_VI_VI_I 1657 1658!---------------------------------- 1659! vector function(vector, integer) 1660!---------------------------------- 1661! 'i0' stands for the integer argument being ignored via 1662! the `ignore_tkr' directive. 1663#define VR_VI_I(NAME, VKIND) __ppc_##NAME##_vr##VKIND##vi##VKIND##i0 1664#define VR_VU_I(NAME, VKIND) __ppc_##NAME##_vr##VKIND##vu##VKIND##i0 1665#define VI_VI_I0(NAME, VKIND) __ppc_##NAME##_vi##VKIND##vi##VKIND##i0 1666#define VU_VU_I0(NAME, VKIND) __ppc_##NAME##_vu##VKIND##vu##VKIND##i0 1667#define VR_VR_I0(NAME, VKIND) __ppc_##NAME##_vr##VKIND##vr##VKIND##i0 1668 1669#define VEC_VR_VI_I(NAME, VKIND) \ 1670 procedure(elem_func_vr##VKIND##vi##VKIND##i) :: VR_VI_I(NAME, VKIND); 1671#define VEC_VR_VU_I(NAME, VKIND) \ 1672 procedure(elem_func_vr##VKIND##vu##VKIND##i) :: VR_VU_I(NAME, VKIND); 1673#define VEC_VI_VI_I0(NAME, VKIND) \ 1674 procedure(elem_func_vi##VKIND##vi##VKIND##i0) :: VI_VI_I0(NAME, VKIND); 1675#define VEC_VU_VU_I0(NAME, VKIND) \ 1676 procedure(elem_func_vu##VKIND##vu##VKIND##i0) :: VU_VU_I0(NAME, VKIND); 1677#define VEC_VR_VR_I0(NAME, VKIND) \ 1678 procedure(elem_func_vr##VKIND##vr##VKIND##i0) :: VR_VR_I0(NAME, VKIND); 1679 1680! vec_ctf 1681 VEC_VR_VI_I(vec_ctf,4) VEC_VR_VI_I(vec_ctf,8) 1682 VEC_VR_VU_I(vec_ctf,4) VEC_VR_VU_I(vec_ctf,8) 1683 interface vec_ctf 1684 procedure :: VR_VI_I(vec_ctf,4), VR_VI_I(vec_ctf,8) 1685 procedure :: VR_VU_I(vec_ctf,4), VR_VU_I(vec_ctf,8) 1686 end interface vec_ctf 1687 public :: vec_ctf 1688 1689! vec_splat 1690 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) 1691 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) 1692 VEC_VR_VR_I0(vec_splat,4) VEC_VR_VR_I0(vec_splat,8) 1693 interface vec_splat 1694 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) 1695 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) 1696 procedure :: VR_VR_I0(vec_splat,4), VR_VR_I0(vec_splat,8) 1697 end interface vec_splat 1698 public :: vec_splat 1699 1700#undef VEC_VR_VR_I0 1701#undef VEC_VU_VU_I0 1702#undef VEC_VI_VI_I0 1703#undef VEC_VR_VU_I 1704#undef VEC_VR_VI_I 1705#undef VR_VR_I0 1706#undef VU_VU_I0 1707#undef VI_VI_I0 1708#undef VR_VU_I 1709#undef VR_VI_I 1710 1711!-------------------------------------------------- 1712! subroutine(vector, integer, vector/integer/real) 1713!-------------------------------------------------- 1714! 'i0' stands for the integer argument being ignored via 1715! the `ignore_tkr' directive. 1716#define SUB_VI_I_VI(NAME, VKIND) __ppc_##NAME##_vi##VKIND##i0vi##VKIND 1717#define SUB_VU_I_VU(NAME, VKIND) __ppc_##NAME##_vu##VKIND##i0vu##VKIND 1718#define SUB_VR_I_VR(NAME, VKIND) __ppc_##NAME##_vr##VKIND##i0vr##VKIND 1719#define SUB_VI_I_I(NAME, VKIND) __ppc_##NAME##_vi##VKIND##i0i##VKIND 1720#define SUB_VU_I_I(NAME, VKIND) __ppc_##NAME##_vu##VKIND##i0u##VKIND 1721#define SUB_VR_I_R(NAME, VKIND) __ppc_##NAME##_vr##VKIND##i0r##VKIND 1722 1723#define VEC_SUB_VI_I_VI(NAME, VKIND) \ 1724 procedure(sub_vi##VKIND##ivi##VKIND) :: SUB_VI_I_VI(NAME, VKIND); 1725#define VEC_SUB_VU_I_VU(NAME, VKIND) \ 1726 procedure(sub_vu##VKIND##ivu##VKIND) :: SUB_VU_I_VU(NAME, VKIND); 1727#define VEC_SUB_VR_I_VR(NAME, VKIND) \ 1728 procedure(sub_vr##VKIND##ivr##VKIND) :: SUB_VR_I_VR(NAME, VKIND); 1729#define VEC_SUB_VI_I_I(NAME, VKIND) \ 1730 procedure(sub_vi##VKIND##ii##VKIND) :: SUB_VI_I_I(NAME, VKIND); 1731#define VEC_SUB_VU_I_I(NAME, VKIND) \ 1732 procedure(sub_vu##VKIND##ii##VKIND) :: SUB_VU_I_I(NAME, VKIND); 1733#define VEC_SUB_VR_I_R(NAME, VKIND) \ 1734 procedure(sub_vr##VKIND##ir##VKIND) :: SUB_VR_I_R(NAME, VKIND); 1735 1736! vec_st 1737 VEC_SUB_VI_I_VI(vec_st,1) VEC_SUB_VI_I_VI(vec_st,2) VEC_SUB_VI_I_VI(vec_st,4) 1738 VEC_SUB_VU_I_VU(vec_st,1) VEC_SUB_VU_I_VU(vec_st,2) VEC_SUB_VU_I_VU(vec_st,4) 1739 VEC_SUB_VR_I_VR(vec_st,4) 1740 VEC_SUB_VI_I_I(vec_st,1) VEC_SUB_VI_I_I(vec_st,2) VEC_SUB_VI_I_I(vec_st,4) 1741 VEC_SUB_VU_I_I(vec_st,1) VEC_SUB_VU_I_I(vec_st,2) VEC_SUB_VU_I_I(vec_st,4) 1742 VEC_SUB_VR_I_R(vec_st,4) 1743 interface vec_st 1744 procedure :: SUB_VI_I_VI(vec_st,1), SUB_VI_I_VI(vec_st,2), SUB_VI_I_VI(vec_st,4) 1745 procedure :: SUB_VU_I_VU(vec_st,1), SUB_VU_I_VU(vec_st,2), SUB_VU_I_VU(vec_st,4) 1746 procedure :: SUB_VR_I_VR(vec_st,4) 1747 procedure :: SUB_VI_I_I(vec_st,1), SUB_VI_I_I(vec_st,2), SUB_VI_I_I(vec_st,4) 1748 procedure :: SUB_VU_I_I(vec_st,1), SUB_VU_I_I(vec_st,2), SUB_VU_I_I(vec_st,4) 1749 procedure :: SUB_VR_I_R(vec_st,4) 1750 end interface vec_st 1751 public :: vec_st 1752 1753! vec_ste 1754 VEC_SUB_VI_I_I(vec_ste,1) VEC_SUB_VI_I_I(vec_ste,2) VEC_SUB_VI_I_I(vec_ste,4) 1755 VEC_SUB_VU_I_I(vec_ste,1) VEC_SUB_VU_I_I(vec_ste,2) VEC_SUB_VU_I_I(vec_ste,4) 1756 VEC_SUB_VR_I_R(vec_ste,4) 1757 interface vec_ste 1758 procedure :: SUB_VI_I_I(vec_ste,1), SUB_VI_I_I(vec_ste,2), SUB_VI_I_I(vec_ste,4) 1759 procedure :: SUB_VU_I_I(vec_ste,1), SUB_VU_I_I(vec_ste,2), SUB_VU_I_I(vec_ste,4) 1760 procedure :: SUB_VR_I_R(vec_ste,4) 1761 end interface vec_ste 1762 public :: vec_ste 1763 1764! vec_stxv 1765 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) 1766 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) 1767 VEC_SUB_VR_I_VR(vec_stxv,4) VEC_SUB_VR_I_VR(vec_stxv,8) 1768 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) 1769 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) 1770 VEC_SUB_VR_I_R(vec_stxv,4) VEC_SUB_VR_I_R(vec_stxv,8) 1771 interface vec_stxv 1772 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) 1773 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) 1774 procedure :: SUB_VR_I_VR(vec_stxv,4), SUB_VR_I_VR(vec_stxv,8) 1775 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) 1776 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) 1777 procedure :: SUB_VR_I_R(vec_stxv,4), SUB_VR_I_R(vec_stxv,8) 1778 end interface vec_stxv 1779 public :: vec_stxv 1780 1781! vec_xst 1782 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) 1783 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) 1784 VEC_SUB_VR_I_VR(vec_xst,4) VEC_SUB_VR_I_VR(vec_xst,8) 1785 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) 1786 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) 1787 VEC_SUB_VR_I_R(vec_xst,4) VEC_SUB_VR_I_R(vec_xst,8) 1788 interface vec_xst 1789 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) 1790 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) 1791 procedure :: SUB_VR_I_VR(vec_xst,4), SUB_VR_I_VR(vec_xst,8) 1792 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) 1793 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) 1794 procedure :: SUB_VR_I_R(vec_xst,4), SUB_VR_I_R(vec_xst,8) 1795 end interface vec_xst 1796 public :: vec_xst 1797 1798! vec_xst_be 1799 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) 1800 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) 1801 VEC_SUB_VR_I_VR(vec_xst_be,4) VEC_SUB_VR_I_VR(vec_xst_be,8) 1802 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) 1803 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) 1804 VEC_SUB_VR_I_R(vec_xst_be,4) VEC_SUB_VR_I_R(vec_xst_be,8) 1805 interface vec_xst_be 1806 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) 1807 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) 1808 procedure :: SUB_VR_I_VR(vec_xst_be,4), SUB_VR_I_VR(vec_xst_be,8) 1809 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) 1810 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) 1811 procedure :: SUB_VR_I_R(vec_xst_be,4), SUB_VR_I_R(vec_xst_be,8) 1812 end interface vec_xst_be 1813 public :: vec_xst_be 1814 1815! vec_xstd2 1816 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) 1817 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) 1818 VEC_SUB_VR_I_VR(vec_xstd2_,4) VEC_SUB_VR_I_VR(vec_xstd2_,8) 1819 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) 1820 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) 1821 VEC_SUB_VR_I_R(vec_xstd2_,4) VEC_SUB_VR_I_R(vec_xstd2_,8) 1822 interface vec_xstd2 1823 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) 1824 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) 1825 procedure :: SUB_VR_I_VR(vec_xstd2_,4), SUB_VR_I_VR(vec_xstd2_,8) 1826 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) 1827 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) 1828 procedure :: SUB_VR_I_R(vec_xstd2_,4), SUB_VR_I_R(vec_xstd2_,8) 1829 end interface vec_xstd2 1830 public :: vec_xstd2 1831 1832! vec_xstw4 1833 VEC_SUB_VI_I_VI(vec_xstw4_,1) VEC_SUB_VI_I_VI(vec_xstw4_,2) VEC_SUB_VI_I_VI(vec_xstw4_,4) 1834 VEC_SUB_VU_I_VU(vec_xstw4_,1) VEC_SUB_VU_I_VU(vec_xstw4_,2) VEC_SUB_VU_I_VU(vec_xstw4_,4) 1835 VEC_SUB_VR_I_VR(vec_xstw4_,4) 1836 VEC_SUB_VI_I_I(vec_xstw4_,1) VEC_SUB_VI_I_I(vec_xstw4_,2) VEC_SUB_VI_I_I(vec_xstw4_,4) 1837 VEC_SUB_VU_I_I(vec_xstw4_,1) VEC_SUB_VU_I_I(vec_xstw4_,2) VEC_SUB_VU_I_I(vec_xstw4_,4) 1838 VEC_SUB_VR_I_R(vec_xstw4_,4) 1839 interface vec_xstw4 1840 procedure :: SUB_VI_I_VI(vec_xstw4_,1), SUB_VI_I_VI(vec_xstw4_,2), SUB_VI_I_VI(vec_xstw4_,4) 1841 procedure :: SUB_VU_I_VU(vec_xstw4_,1), SUB_VU_I_VU(vec_xstw4_,2), SUB_VU_I_VU(vec_xstw4_,4) 1842 procedure :: SUB_VR_I_VR(vec_xstw4_,4) 1843 procedure :: SUB_VI_I_I(vec_xstw4_,1), SUB_VI_I_I(vec_xstw4_,2), SUB_VI_I_I(vec_xstw4_,4) 1844 procedure :: SUB_VU_I_I(vec_xstw4_,1), SUB_VU_I_I(vec_xstw4_,2), SUB_VU_I_I(vec_xstw4_,4) 1845 procedure :: SUB_VR_I_R(vec_xstw4_,4) 1846 end interface vec_xstw4 1847 public :: vec_xstw4 1848 1849#undef VEC_SUB_VI_I_VI 1850#undef VEC_SUB_VU_I_VU 1851#undef VEC_SUB_VR_I_VR 1852#undef VEC_SUB_VI_I_I 1853#undef VEC_SUB_VU_I_I 1854#undef VEC_SUB_VR_I_R 1855#undef SUB_VI_I_VI 1856#undef SUB_VU_I_VU 1857#undef SUB_VR_I_VR 1858#undef SUB_VI_I_I 1859#undef SUB_VU_I_I 1860#undef SUB_VR_Ik_R 1861 1862!----------------------------------------------------------------------- 1863! subroutine(__vector_pair, integer, __vector_pair/vector/integer/real) 1864!----------------------------------------------------------------------- 1865#define VP_I0_VI(NAME, VKIND) __ppc_##NAME##_vpi0vi##VKIND 1866#define VP_I0_VU(NAME, VKIND) __ppc_##NAME##_vpi0vu##VKIND 1867#define VP_I0_VR(NAME, VKIND) __ppc_##NAME##_vpi0vr##VKIND 1868 1869#define VEC_VP_I0_VI(NAME, VKIND) \ 1870 procedure(sub_vpi0vi##VKIND) :: VP_I0_VI(NAME, VKIND); 1871#define VEC_VP_I0_VU(NAME, VKIND) \ 1872 procedure(sub_vpi0vu##VKIND) :: VP_I0_VU(NAME, VKIND); 1873#define VEC_VP_I0_VR(NAME, VKIND) \ 1874 procedure(sub_vpi0vr##VKIND) :: VP_I0_VR(NAME, VKIND); 1875 1876! vec_stxvp 1877 procedure(sub_vpi0vp) :: __ppc_vec_stxvp_vpi0vp0 1878 procedure(sub_vpi0i0) :: __ppc_vec_stxvp_vpi0i0 1879 procedure(sub_vpi0r0) :: __ppc_vec_stxvp_vpi0r0 1880 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) 1881 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) 1882 VEC_VP_I0_VR(vec_stxvp, 4) VEC_VP_I0_VR(vec_stxvp, 8) 1883 interface vec_stxvp 1884 procedure :: __ppc_vec_stxvp_vpi0vp0 1885 procedure :: __ppc_vec_stxvp_vpi0i0 1886 procedure :: __ppc_vec_stxvp_vpi0r0 1887 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) 1888 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) 1889 procedure :: VP_I0_VR(vec_stxvp, 4), VP_I0_VR(vec_stxvp, 8) 1890 end interface vec_stxvp 1891 public :: vec_stxvp 1892 1893! vsx_stxvp (alias to vec_stxvp) 1894 interface vsx_stxvp 1895 procedure :: __ppc_vec_stxvp_vpi0vp0 1896 procedure :: __ppc_vec_stxvp_vpi0i0 1897 procedure :: __ppc_vec_stxvp_vpi0r0 1898 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) 1899 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) 1900 procedure :: VP_I0_VR(vec_stxvp, 4), VP_I0_VR(vec_stxvp, 8) 1901 end interface vsx_stxvp 1902 public :: vsx_stxvp 1903 1904#undef VEC_VP_I0_VR 1905#undef VEC_VP_I0_VU 1906#undef VEC_VP_I0_VI 1907#undef VP_I0_VR 1908#undef VP_I0_VU 1909#undef VP_I0_VI 1910 1911end module __ppc_intrinsics 1912