llvm-project

__ppc_intrinsics.f90
1911 строк · 79.7 Кб
Перенос по словам
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

9
module __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

1911
end module __ppc_intrinsics
1912
llvm-project

Использование cookies
