1use crate::{
6 dr::{self, Builder},
7 spirv,
8};
9impl Builder {
10 #[allow(clippy::too_many_arguments)]
11 pub fn cl_acos(
12 &mut self,
13 result_type: spirv::Word,
14 x: spirv::Word,
15 ) -> Result<spirv::Word, dr::Error> {
16 self.cl_acos_id(result_type, None, x)
17 }
18 #[allow(clippy::too_many_arguments)]
19 pub fn cl_acos_id(
20 &mut self,
21 result_type: spirv::Word,
22 result_id: Option<spirv::Word>,
23 x: spirv::Word,
24 ) -> Result<spirv::Word, dr::Error> {
25 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
26 #[allow(unused_mut)]
27 let mut args = vec![dr::Operand::IdRef(x)];
28 self.ext_inst(
29 result_type,
30 result_id,
31 extension_set,
32 crate::spirv::CLOp::acos as spirv::Word,
33 args,
34 )
35 }
36 #[allow(clippy::too_many_arguments)]
37 pub fn cl_acosh(
38 &mut self,
39 result_type: spirv::Word,
40 x: spirv::Word,
41 ) -> Result<spirv::Word, dr::Error> {
42 self.cl_acosh_id(result_type, None, x)
43 }
44 #[allow(clippy::too_many_arguments)]
45 pub fn cl_acosh_id(
46 &mut self,
47 result_type: spirv::Word,
48 result_id: Option<spirv::Word>,
49 x: spirv::Word,
50 ) -> Result<spirv::Word, dr::Error> {
51 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
52 #[allow(unused_mut)]
53 let mut args = vec![dr::Operand::IdRef(x)];
54 self.ext_inst(
55 result_type,
56 result_id,
57 extension_set,
58 crate::spirv::CLOp::acosh as spirv::Word,
59 args,
60 )
61 }
62 #[allow(clippy::too_many_arguments)]
63 pub fn cl_acospi(
64 &mut self,
65 result_type: spirv::Word,
66 x: spirv::Word,
67 ) -> Result<spirv::Word, dr::Error> {
68 self.cl_acospi_id(result_type, None, x)
69 }
70 #[allow(clippy::too_many_arguments)]
71 pub fn cl_acospi_id(
72 &mut self,
73 result_type: spirv::Word,
74 result_id: Option<spirv::Word>,
75 x: spirv::Word,
76 ) -> Result<spirv::Word, dr::Error> {
77 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
78 #[allow(unused_mut)]
79 let mut args = vec![dr::Operand::IdRef(x)];
80 self.ext_inst(
81 result_type,
82 result_id,
83 extension_set,
84 crate::spirv::CLOp::acospi as spirv::Word,
85 args,
86 )
87 }
88 #[allow(clippy::too_many_arguments)]
89 pub fn cl_asin(
90 &mut self,
91 result_type: spirv::Word,
92 x: spirv::Word,
93 ) -> Result<spirv::Word, dr::Error> {
94 self.cl_asin_id(result_type, None, x)
95 }
96 #[allow(clippy::too_many_arguments)]
97 pub fn cl_asin_id(
98 &mut self,
99 result_type: spirv::Word,
100 result_id: Option<spirv::Word>,
101 x: spirv::Word,
102 ) -> Result<spirv::Word, dr::Error> {
103 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
104 #[allow(unused_mut)]
105 let mut args = vec![dr::Operand::IdRef(x)];
106 self.ext_inst(
107 result_type,
108 result_id,
109 extension_set,
110 crate::spirv::CLOp::asin as spirv::Word,
111 args,
112 )
113 }
114 #[allow(clippy::too_many_arguments)]
115 pub fn cl_asinh(
116 &mut self,
117 result_type: spirv::Word,
118 x: spirv::Word,
119 ) -> Result<spirv::Word, dr::Error> {
120 self.cl_asinh_id(result_type, None, x)
121 }
122 #[allow(clippy::too_many_arguments)]
123 pub fn cl_asinh_id(
124 &mut self,
125 result_type: spirv::Word,
126 result_id: Option<spirv::Word>,
127 x: spirv::Word,
128 ) -> Result<spirv::Word, dr::Error> {
129 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
130 #[allow(unused_mut)]
131 let mut args = vec![dr::Operand::IdRef(x)];
132 self.ext_inst(
133 result_type,
134 result_id,
135 extension_set,
136 crate::spirv::CLOp::asinh as spirv::Word,
137 args,
138 )
139 }
140 #[allow(clippy::too_many_arguments)]
141 pub fn cl_asinpi(
142 &mut self,
143 result_type: spirv::Word,
144 x: spirv::Word,
145 ) -> Result<spirv::Word, dr::Error> {
146 self.cl_asinpi_id(result_type, None, x)
147 }
148 #[allow(clippy::too_many_arguments)]
149 pub fn cl_asinpi_id(
150 &mut self,
151 result_type: spirv::Word,
152 result_id: Option<spirv::Word>,
153 x: spirv::Word,
154 ) -> Result<spirv::Word, dr::Error> {
155 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
156 #[allow(unused_mut)]
157 let mut args = vec![dr::Operand::IdRef(x)];
158 self.ext_inst(
159 result_type,
160 result_id,
161 extension_set,
162 crate::spirv::CLOp::asinpi as spirv::Word,
163 args,
164 )
165 }
166 #[allow(clippy::too_many_arguments)]
167 pub fn cl_atan(
168 &mut self,
169 result_type: spirv::Word,
170 x: spirv::Word,
171 ) -> Result<spirv::Word, dr::Error> {
172 self.cl_atan_id(result_type, None, x)
173 }
174 #[allow(clippy::too_many_arguments)]
175 pub fn cl_atan_id(
176 &mut self,
177 result_type: spirv::Word,
178 result_id: Option<spirv::Word>,
179 x: spirv::Word,
180 ) -> Result<spirv::Word, dr::Error> {
181 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
182 #[allow(unused_mut)]
183 let mut args = vec![dr::Operand::IdRef(x)];
184 self.ext_inst(
185 result_type,
186 result_id,
187 extension_set,
188 crate::spirv::CLOp::atan as spirv::Word,
189 args,
190 )
191 }
192 #[allow(clippy::too_many_arguments)]
193 pub fn cl_atan2(
194 &mut self,
195 result_type: spirv::Word,
196 y: spirv::Word,
197 x: spirv::Word,
198 ) -> Result<spirv::Word, dr::Error> {
199 self.cl_atan2_id(result_type, None, y, x)
200 }
201 #[allow(clippy::too_many_arguments)]
202 pub fn cl_atan2_id(
203 &mut self,
204 result_type: spirv::Word,
205 result_id: Option<spirv::Word>,
206 y: spirv::Word,
207 x: spirv::Word,
208 ) -> Result<spirv::Word, dr::Error> {
209 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
210 #[allow(unused_mut)]
211 let mut args = vec![dr::Operand::IdRef(y), dr::Operand::IdRef(x)];
212 self.ext_inst(
213 result_type,
214 result_id,
215 extension_set,
216 crate::spirv::CLOp::atan2 as spirv::Word,
217 args,
218 )
219 }
220 #[allow(clippy::too_many_arguments)]
221 pub fn cl_atanh(
222 &mut self,
223 result_type: spirv::Word,
224 x: spirv::Word,
225 ) -> Result<spirv::Word, dr::Error> {
226 self.cl_atanh_id(result_type, None, x)
227 }
228 #[allow(clippy::too_many_arguments)]
229 pub fn cl_atanh_id(
230 &mut self,
231 result_type: spirv::Word,
232 result_id: Option<spirv::Word>,
233 x: spirv::Word,
234 ) -> Result<spirv::Word, dr::Error> {
235 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
236 #[allow(unused_mut)]
237 let mut args = vec![dr::Operand::IdRef(x)];
238 self.ext_inst(
239 result_type,
240 result_id,
241 extension_set,
242 crate::spirv::CLOp::atanh as spirv::Word,
243 args,
244 )
245 }
246 #[allow(clippy::too_many_arguments)]
247 pub fn cl_atanpi(
248 &mut self,
249 result_type: spirv::Word,
250 x: spirv::Word,
251 ) -> Result<spirv::Word, dr::Error> {
252 self.cl_atanpi_id(result_type, None, x)
253 }
254 #[allow(clippy::too_many_arguments)]
255 pub fn cl_atanpi_id(
256 &mut self,
257 result_type: spirv::Word,
258 result_id: Option<spirv::Word>,
259 x: spirv::Word,
260 ) -> Result<spirv::Word, dr::Error> {
261 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
262 #[allow(unused_mut)]
263 let mut args = vec![dr::Operand::IdRef(x)];
264 self.ext_inst(
265 result_type,
266 result_id,
267 extension_set,
268 crate::spirv::CLOp::atanpi as spirv::Word,
269 args,
270 )
271 }
272 #[allow(clippy::too_many_arguments)]
273 pub fn cl_atan2pi(
274 &mut self,
275 result_type: spirv::Word,
276 y: spirv::Word,
277 x: spirv::Word,
278 ) -> Result<spirv::Word, dr::Error> {
279 self.cl_atan2pi_id(result_type, None, y, x)
280 }
281 #[allow(clippy::too_many_arguments)]
282 pub fn cl_atan2pi_id(
283 &mut self,
284 result_type: spirv::Word,
285 result_id: Option<spirv::Word>,
286 y: spirv::Word,
287 x: spirv::Word,
288 ) -> Result<spirv::Word, dr::Error> {
289 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
290 #[allow(unused_mut)]
291 let mut args = vec![dr::Operand::IdRef(y), dr::Operand::IdRef(x)];
292 self.ext_inst(
293 result_type,
294 result_id,
295 extension_set,
296 crate::spirv::CLOp::atan2pi as spirv::Word,
297 args,
298 )
299 }
300 #[allow(clippy::too_many_arguments)]
301 pub fn cl_cbrt(
302 &mut self,
303 result_type: spirv::Word,
304 x: spirv::Word,
305 ) -> Result<spirv::Word, dr::Error> {
306 self.cl_cbrt_id(result_type, None, x)
307 }
308 #[allow(clippy::too_many_arguments)]
309 pub fn cl_cbrt_id(
310 &mut self,
311 result_type: spirv::Word,
312 result_id: Option<spirv::Word>,
313 x: spirv::Word,
314 ) -> Result<spirv::Word, dr::Error> {
315 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
316 #[allow(unused_mut)]
317 let mut args = vec![dr::Operand::IdRef(x)];
318 self.ext_inst(
319 result_type,
320 result_id,
321 extension_set,
322 crate::spirv::CLOp::cbrt as spirv::Word,
323 args,
324 )
325 }
326 #[allow(clippy::too_many_arguments)]
327 pub fn cl_ceil(
328 &mut self,
329 result_type: spirv::Word,
330 x: spirv::Word,
331 ) -> Result<spirv::Word, dr::Error> {
332 self.cl_ceil_id(result_type, None, x)
333 }
334 #[allow(clippy::too_many_arguments)]
335 pub fn cl_ceil_id(
336 &mut self,
337 result_type: spirv::Word,
338 result_id: Option<spirv::Word>,
339 x: spirv::Word,
340 ) -> Result<spirv::Word, dr::Error> {
341 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
342 #[allow(unused_mut)]
343 let mut args = vec![dr::Operand::IdRef(x)];
344 self.ext_inst(
345 result_type,
346 result_id,
347 extension_set,
348 crate::spirv::CLOp::ceil as spirv::Word,
349 args,
350 )
351 }
352 #[allow(clippy::too_many_arguments)]
353 pub fn cl_copysign(
354 &mut self,
355 result_type: spirv::Word,
356 x: spirv::Word,
357 y: spirv::Word,
358 ) -> Result<spirv::Word, dr::Error> {
359 self.cl_copysign_id(result_type, None, x, y)
360 }
361 #[allow(clippy::too_many_arguments)]
362 pub fn cl_copysign_id(
363 &mut self,
364 result_type: spirv::Word,
365 result_id: Option<spirv::Word>,
366 x: spirv::Word,
367 y: spirv::Word,
368 ) -> Result<spirv::Word, dr::Error> {
369 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
370 #[allow(unused_mut)]
371 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
372 self.ext_inst(
373 result_type,
374 result_id,
375 extension_set,
376 crate::spirv::CLOp::copysign as spirv::Word,
377 args,
378 )
379 }
380 #[allow(clippy::too_many_arguments)]
381 pub fn cl_cos(
382 &mut self,
383 result_type: spirv::Word,
384 x: spirv::Word,
385 ) -> Result<spirv::Word, dr::Error> {
386 self.cl_cos_id(result_type, None, x)
387 }
388 #[allow(clippy::too_many_arguments)]
389 pub fn cl_cos_id(
390 &mut self,
391 result_type: spirv::Word,
392 result_id: Option<spirv::Word>,
393 x: spirv::Word,
394 ) -> Result<spirv::Word, dr::Error> {
395 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
396 #[allow(unused_mut)]
397 let mut args = vec![dr::Operand::IdRef(x)];
398 self.ext_inst(
399 result_type,
400 result_id,
401 extension_set,
402 crate::spirv::CLOp::cos as spirv::Word,
403 args,
404 )
405 }
406 #[allow(clippy::too_many_arguments)]
407 pub fn cl_cosh(
408 &mut self,
409 result_type: spirv::Word,
410 x: spirv::Word,
411 ) -> Result<spirv::Word, dr::Error> {
412 self.cl_cosh_id(result_type, None, x)
413 }
414 #[allow(clippy::too_many_arguments)]
415 pub fn cl_cosh_id(
416 &mut self,
417 result_type: spirv::Word,
418 result_id: Option<spirv::Word>,
419 x: spirv::Word,
420 ) -> Result<spirv::Word, dr::Error> {
421 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
422 #[allow(unused_mut)]
423 let mut args = vec![dr::Operand::IdRef(x)];
424 self.ext_inst(
425 result_type,
426 result_id,
427 extension_set,
428 crate::spirv::CLOp::cosh as spirv::Word,
429 args,
430 )
431 }
432 #[allow(clippy::too_many_arguments)]
433 pub fn cl_cospi(
434 &mut self,
435 result_type: spirv::Word,
436 x: spirv::Word,
437 ) -> Result<spirv::Word, dr::Error> {
438 self.cl_cospi_id(result_type, None, x)
439 }
440 #[allow(clippy::too_many_arguments)]
441 pub fn cl_cospi_id(
442 &mut self,
443 result_type: spirv::Word,
444 result_id: Option<spirv::Word>,
445 x: spirv::Word,
446 ) -> Result<spirv::Word, dr::Error> {
447 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
448 #[allow(unused_mut)]
449 let mut args = vec![dr::Operand::IdRef(x)];
450 self.ext_inst(
451 result_type,
452 result_id,
453 extension_set,
454 crate::spirv::CLOp::cospi as spirv::Word,
455 args,
456 )
457 }
458 #[allow(clippy::too_many_arguments)]
459 pub fn cl_erfc(
460 &mut self,
461 result_type: spirv::Word,
462 x: spirv::Word,
463 ) -> Result<spirv::Word, dr::Error> {
464 self.cl_erfc_id(result_type, None, x)
465 }
466 #[allow(clippy::too_many_arguments)]
467 pub fn cl_erfc_id(
468 &mut self,
469 result_type: spirv::Word,
470 result_id: Option<spirv::Word>,
471 x: spirv::Word,
472 ) -> Result<spirv::Word, dr::Error> {
473 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
474 #[allow(unused_mut)]
475 let mut args = vec![dr::Operand::IdRef(x)];
476 self.ext_inst(
477 result_type,
478 result_id,
479 extension_set,
480 crate::spirv::CLOp::erfc as spirv::Word,
481 args,
482 )
483 }
484 #[allow(clippy::too_many_arguments)]
485 pub fn cl_erf(
486 &mut self,
487 result_type: spirv::Word,
488 x: spirv::Word,
489 ) -> Result<spirv::Word, dr::Error> {
490 self.cl_erf_id(result_type, None, x)
491 }
492 #[allow(clippy::too_many_arguments)]
493 pub fn cl_erf_id(
494 &mut self,
495 result_type: spirv::Word,
496 result_id: Option<spirv::Word>,
497 x: spirv::Word,
498 ) -> Result<spirv::Word, dr::Error> {
499 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
500 #[allow(unused_mut)]
501 let mut args = vec![dr::Operand::IdRef(x)];
502 self.ext_inst(
503 result_type,
504 result_id,
505 extension_set,
506 crate::spirv::CLOp::erf as spirv::Word,
507 args,
508 )
509 }
510 #[allow(clippy::too_many_arguments)]
511 pub fn cl_exp(
512 &mut self,
513 result_type: spirv::Word,
514 x: spirv::Word,
515 ) -> Result<spirv::Word, dr::Error> {
516 self.cl_exp_id(result_type, None, x)
517 }
518 #[allow(clippy::too_many_arguments)]
519 pub fn cl_exp_id(
520 &mut self,
521 result_type: spirv::Word,
522 result_id: Option<spirv::Word>,
523 x: spirv::Word,
524 ) -> Result<spirv::Word, dr::Error> {
525 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
526 #[allow(unused_mut)]
527 let mut args = vec![dr::Operand::IdRef(x)];
528 self.ext_inst(
529 result_type,
530 result_id,
531 extension_set,
532 crate::spirv::CLOp::exp as spirv::Word,
533 args,
534 )
535 }
536 #[allow(clippy::too_many_arguments)]
537 pub fn cl_exp2(
538 &mut self,
539 result_type: spirv::Word,
540 x: spirv::Word,
541 ) -> Result<spirv::Word, dr::Error> {
542 self.cl_exp2_id(result_type, None, x)
543 }
544 #[allow(clippy::too_many_arguments)]
545 pub fn cl_exp2_id(
546 &mut self,
547 result_type: spirv::Word,
548 result_id: Option<spirv::Word>,
549 x: spirv::Word,
550 ) -> Result<spirv::Word, dr::Error> {
551 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
552 #[allow(unused_mut)]
553 let mut args = vec![dr::Operand::IdRef(x)];
554 self.ext_inst(
555 result_type,
556 result_id,
557 extension_set,
558 crate::spirv::CLOp::exp2 as spirv::Word,
559 args,
560 )
561 }
562 #[allow(clippy::too_many_arguments)]
563 pub fn cl_exp10(
564 &mut self,
565 result_type: spirv::Word,
566 x: spirv::Word,
567 ) -> Result<spirv::Word, dr::Error> {
568 self.cl_exp10_id(result_type, None, x)
569 }
570 #[allow(clippy::too_many_arguments)]
571 pub fn cl_exp10_id(
572 &mut self,
573 result_type: spirv::Word,
574 result_id: Option<spirv::Word>,
575 x: spirv::Word,
576 ) -> Result<spirv::Word, dr::Error> {
577 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
578 #[allow(unused_mut)]
579 let mut args = vec![dr::Operand::IdRef(x)];
580 self.ext_inst(
581 result_type,
582 result_id,
583 extension_set,
584 crate::spirv::CLOp::exp10 as spirv::Word,
585 args,
586 )
587 }
588 #[allow(clippy::too_many_arguments)]
589 pub fn cl_expm1(
590 &mut self,
591 result_type: spirv::Word,
592 x: spirv::Word,
593 ) -> Result<spirv::Word, dr::Error> {
594 self.cl_expm1_id(result_type, None, x)
595 }
596 #[allow(clippy::too_many_arguments)]
597 pub fn cl_expm1_id(
598 &mut self,
599 result_type: spirv::Word,
600 result_id: Option<spirv::Word>,
601 x: spirv::Word,
602 ) -> Result<spirv::Word, dr::Error> {
603 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
604 #[allow(unused_mut)]
605 let mut args = vec![dr::Operand::IdRef(x)];
606 self.ext_inst(
607 result_type,
608 result_id,
609 extension_set,
610 crate::spirv::CLOp::expm1 as spirv::Word,
611 args,
612 )
613 }
614 #[allow(clippy::too_many_arguments)]
615 pub fn cl_fabs(
616 &mut self,
617 result_type: spirv::Word,
618 x: spirv::Word,
619 ) -> Result<spirv::Word, dr::Error> {
620 self.cl_fabs_id(result_type, None, x)
621 }
622 #[allow(clippy::too_many_arguments)]
623 pub fn cl_fabs_id(
624 &mut self,
625 result_type: spirv::Word,
626 result_id: Option<spirv::Word>,
627 x: spirv::Word,
628 ) -> Result<spirv::Word, dr::Error> {
629 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
630 #[allow(unused_mut)]
631 let mut args = vec![dr::Operand::IdRef(x)];
632 self.ext_inst(
633 result_type,
634 result_id,
635 extension_set,
636 crate::spirv::CLOp::fabs as spirv::Word,
637 args,
638 )
639 }
640 #[allow(clippy::too_many_arguments)]
641 pub fn cl_fdim(
642 &mut self,
643 result_type: spirv::Word,
644 x: spirv::Word,
645 y: spirv::Word,
646 ) -> Result<spirv::Word, dr::Error> {
647 self.cl_fdim_id(result_type, None, x, y)
648 }
649 #[allow(clippy::too_many_arguments)]
650 pub fn cl_fdim_id(
651 &mut self,
652 result_type: spirv::Word,
653 result_id: Option<spirv::Word>,
654 x: spirv::Word,
655 y: spirv::Word,
656 ) -> Result<spirv::Word, dr::Error> {
657 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
658 #[allow(unused_mut)]
659 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
660 self.ext_inst(
661 result_type,
662 result_id,
663 extension_set,
664 crate::spirv::CLOp::fdim as spirv::Word,
665 args,
666 )
667 }
668 #[allow(clippy::too_many_arguments)]
669 pub fn cl_floor(
670 &mut self,
671 result_type: spirv::Word,
672 x: spirv::Word,
673 ) -> Result<spirv::Word, dr::Error> {
674 self.cl_floor_id(result_type, None, x)
675 }
676 #[allow(clippy::too_many_arguments)]
677 pub fn cl_floor_id(
678 &mut self,
679 result_type: spirv::Word,
680 result_id: Option<spirv::Word>,
681 x: spirv::Word,
682 ) -> Result<spirv::Word, dr::Error> {
683 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
684 #[allow(unused_mut)]
685 let mut args = vec![dr::Operand::IdRef(x)];
686 self.ext_inst(
687 result_type,
688 result_id,
689 extension_set,
690 crate::spirv::CLOp::floor as spirv::Word,
691 args,
692 )
693 }
694 #[allow(clippy::too_many_arguments)]
695 pub fn cl_fma(
696 &mut self,
697 result_type: spirv::Word,
698 a: spirv::Word,
699 b: spirv::Word,
700 c: spirv::Word,
701 ) -> Result<spirv::Word, dr::Error> {
702 self.cl_fma_id(result_type, None, a, b, c)
703 }
704 #[allow(clippy::too_many_arguments)]
705 pub fn cl_fma_id(
706 &mut self,
707 result_type: spirv::Word,
708 result_id: Option<spirv::Word>,
709 a: spirv::Word,
710 b: spirv::Word,
711 c: spirv::Word,
712 ) -> Result<spirv::Word, dr::Error> {
713 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
714 #[allow(unused_mut)]
715 let mut args = vec![
716 dr::Operand::IdRef(a),
717 dr::Operand::IdRef(b),
718 dr::Operand::IdRef(c),
719 ];
720 self.ext_inst(
721 result_type,
722 result_id,
723 extension_set,
724 crate::spirv::CLOp::fma as spirv::Word,
725 args,
726 )
727 }
728 #[allow(clippy::too_many_arguments)]
729 pub fn cl_fmax(
730 &mut self,
731 result_type: spirv::Word,
732 x: spirv::Word,
733 y: spirv::Word,
734 ) -> Result<spirv::Word, dr::Error> {
735 self.cl_fmax_id(result_type, None, x, y)
736 }
737 #[allow(clippy::too_many_arguments)]
738 pub fn cl_fmax_id(
739 &mut self,
740 result_type: spirv::Word,
741 result_id: Option<spirv::Word>,
742 x: spirv::Word,
743 y: spirv::Word,
744 ) -> Result<spirv::Word, dr::Error> {
745 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
746 #[allow(unused_mut)]
747 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
748 self.ext_inst(
749 result_type,
750 result_id,
751 extension_set,
752 crate::spirv::CLOp::fmax as spirv::Word,
753 args,
754 )
755 }
756 #[allow(clippy::too_many_arguments)]
757 pub fn cl_fmin(
758 &mut self,
759 result_type: spirv::Word,
760 x: spirv::Word,
761 y: spirv::Word,
762 ) -> Result<spirv::Word, dr::Error> {
763 self.cl_fmin_id(result_type, None, x, y)
764 }
765 #[allow(clippy::too_many_arguments)]
766 pub fn cl_fmin_id(
767 &mut self,
768 result_type: spirv::Word,
769 result_id: Option<spirv::Word>,
770 x: spirv::Word,
771 y: spirv::Word,
772 ) -> Result<spirv::Word, dr::Error> {
773 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
774 #[allow(unused_mut)]
775 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
776 self.ext_inst(
777 result_type,
778 result_id,
779 extension_set,
780 crate::spirv::CLOp::fmin as spirv::Word,
781 args,
782 )
783 }
784 #[allow(clippy::too_many_arguments)]
785 pub fn cl_fmod(
786 &mut self,
787 result_type: spirv::Word,
788 x: spirv::Word,
789 y: spirv::Word,
790 ) -> Result<spirv::Word, dr::Error> {
791 self.cl_fmod_id(result_type, None, x, y)
792 }
793 #[allow(clippy::too_many_arguments)]
794 pub fn cl_fmod_id(
795 &mut self,
796 result_type: spirv::Word,
797 result_id: Option<spirv::Word>,
798 x: spirv::Word,
799 y: spirv::Word,
800 ) -> Result<spirv::Word, dr::Error> {
801 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
802 #[allow(unused_mut)]
803 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
804 self.ext_inst(
805 result_type,
806 result_id,
807 extension_set,
808 crate::spirv::CLOp::fmod as spirv::Word,
809 args,
810 )
811 }
812 #[allow(clippy::too_many_arguments)]
813 pub fn cl_fract(
814 &mut self,
815 result_type: spirv::Word,
816 x: spirv::Word,
817 ptr: spirv::Word,
818 ) -> Result<spirv::Word, dr::Error> {
819 self.cl_fract_id(result_type, None, x, ptr)
820 }
821 #[allow(clippy::too_many_arguments)]
822 pub fn cl_fract_id(
823 &mut self,
824 result_type: spirv::Word,
825 result_id: Option<spirv::Word>,
826 x: spirv::Word,
827 ptr: spirv::Word,
828 ) -> Result<spirv::Word, dr::Error> {
829 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
830 #[allow(unused_mut)]
831 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(ptr)];
832 self.ext_inst(
833 result_type,
834 result_id,
835 extension_set,
836 crate::spirv::CLOp::fract as spirv::Word,
837 args,
838 )
839 }
840 #[allow(clippy::too_many_arguments)]
841 pub fn cl_frexp(
842 &mut self,
843 result_type: spirv::Word,
844 x: spirv::Word,
845 exp: spirv::Word,
846 ) -> Result<spirv::Word, dr::Error> {
847 self.cl_frexp_id(result_type, None, x, exp)
848 }
849 #[allow(clippy::too_many_arguments)]
850 pub fn cl_frexp_id(
851 &mut self,
852 result_type: spirv::Word,
853 result_id: Option<spirv::Word>,
854 x: spirv::Word,
855 exp: spirv::Word,
856 ) -> Result<spirv::Word, dr::Error> {
857 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
858 #[allow(unused_mut)]
859 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(exp)];
860 self.ext_inst(
861 result_type,
862 result_id,
863 extension_set,
864 crate::spirv::CLOp::frexp as spirv::Word,
865 args,
866 )
867 }
868 #[allow(clippy::too_many_arguments)]
869 pub fn cl_hypot(
870 &mut self,
871 result_type: spirv::Word,
872 x: spirv::Word,
873 y: spirv::Word,
874 ) -> Result<spirv::Word, dr::Error> {
875 self.cl_hypot_id(result_type, None, x, y)
876 }
877 #[allow(clippy::too_many_arguments)]
878 pub fn cl_hypot_id(
879 &mut self,
880 result_type: spirv::Word,
881 result_id: Option<spirv::Word>,
882 x: spirv::Word,
883 y: spirv::Word,
884 ) -> Result<spirv::Word, dr::Error> {
885 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
886 #[allow(unused_mut)]
887 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
888 self.ext_inst(
889 result_type,
890 result_id,
891 extension_set,
892 crate::spirv::CLOp::hypot as spirv::Word,
893 args,
894 )
895 }
896 #[allow(clippy::too_many_arguments)]
897 pub fn cl_ilogb(
898 &mut self,
899 result_type: spirv::Word,
900 x: spirv::Word,
901 ) -> Result<spirv::Word, dr::Error> {
902 self.cl_ilogb_id(result_type, None, x)
903 }
904 #[allow(clippy::too_many_arguments)]
905 pub fn cl_ilogb_id(
906 &mut self,
907 result_type: spirv::Word,
908 result_id: Option<spirv::Word>,
909 x: spirv::Word,
910 ) -> Result<spirv::Word, dr::Error> {
911 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
912 #[allow(unused_mut)]
913 let mut args = vec![dr::Operand::IdRef(x)];
914 self.ext_inst(
915 result_type,
916 result_id,
917 extension_set,
918 crate::spirv::CLOp::ilogb as spirv::Word,
919 args,
920 )
921 }
922 #[allow(clippy::too_many_arguments)]
923 pub fn cl_ldexp(
924 &mut self,
925 result_type: spirv::Word,
926 x: spirv::Word,
927 k: spirv::Word,
928 ) -> Result<spirv::Word, dr::Error> {
929 self.cl_ldexp_id(result_type, None, x, k)
930 }
931 #[allow(clippy::too_many_arguments)]
932 pub fn cl_ldexp_id(
933 &mut self,
934 result_type: spirv::Word,
935 result_id: Option<spirv::Word>,
936 x: spirv::Word,
937 k: spirv::Word,
938 ) -> Result<spirv::Word, dr::Error> {
939 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
940 #[allow(unused_mut)]
941 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(k)];
942 self.ext_inst(
943 result_type,
944 result_id,
945 extension_set,
946 crate::spirv::CLOp::ldexp as spirv::Word,
947 args,
948 )
949 }
950 #[allow(clippy::too_many_arguments)]
951 pub fn cl_lgamma(
952 &mut self,
953 result_type: spirv::Word,
954 x: spirv::Word,
955 ) -> Result<spirv::Word, dr::Error> {
956 self.cl_lgamma_id(result_type, None, x)
957 }
958 #[allow(clippy::too_many_arguments)]
959 pub fn cl_lgamma_id(
960 &mut self,
961 result_type: spirv::Word,
962 result_id: Option<spirv::Word>,
963 x: spirv::Word,
964 ) -> Result<spirv::Word, dr::Error> {
965 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
966 #[allow(unused_mut)]
967 let mut args = vec![dr::Operand::IdRef(x)];
968 self.ext_inst(
969 result_type,
970 result_id,
971 extension_set,
972 crate::spirv::CLOp::lgamma as spirv::Word,
973 args,
974 )
975 }
976 #[allow(clippy::too_many_arguments)]
977 pub fn cl_lgamma_r(
978 &mut self,
979 result_type: spirv::Word,
980 x: spirv::Word,
981 signp: spirv::Word,
982 ) -> Result<spirv::Word, dr::Error> {
983 self.cl_lgamma_r_id(result_type, None, x, signp)
984 }
985 #[allow(clippy::too_many_arguments)]
986 pub fn cl_lgamma_r_id(
987 &mut self,
988 result_type: spirv::Word,
989 result_id: Option<spirv::Word>,
990 x: spirv::Word,
991 signp: spirv::Word,
992 ) -> Result<spirv::Word, dr::Error> {
993 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
994 #[allow(unused_mut)]
995 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(signp)];
996 self.ext_inst(
997 result_type,
998 result_id,
999 extension_set,
1000 crate::spirv::CLOp::lgamma_r as spirv::Word,
1001 args,
1002 )
1003 }
1004 #[allow(clippy::too_many_arguments)]
1005 pub fn cl_log(
1006 &mut self,
1007 result_type: spirv::Word,
1008 x: spirv::Word,
1009 ) -> Result<spirv::Word, dr::Error> {
1010 self.cl_log_id(result_type, None, x)
1011 }
1012 #[allow(clippy::too_many_arguments)]
1013 pub fn cl_log_id(
1014 &mut self,
1015 result_type: spirv::Word,
1016 result_id: Option<spirv::Word>,
1017 x: spirv::Word,
1018 ) -> Result<spirv::Word, dr::Error> {
1019 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1020 #[allow(unused_mut)]
1021 let mut args = vec![dr::Operand::IdRef(x)];
1022 self.ext_inst(
1023 result_type,
1024 result_id,
1025 extension_set,
1026 crate::spirv::CLOp::log as spirv::Word,
1027 args,
1028 )
1029 }
1030 #[allow(clippy::too_many_arguments)]
1031 pub fn cl_log2(
1032 &mut self,
1033 result_type: spirv::Word,
1034 x: spirv::Word,
1035 ) -> Result<spirv::Word, dr::Error> {
1036 self.cl_log2_id(result_type, None, x)
1037 }
1038 #[allow(clippy::too_many_arguments)]
1039 pub fn cl_log2_id(
1040 &mut self,
1041 result_type: spirv::Word,
1042 result_id: Option<spirv::Word>,
1043 x: spirv::Word,
1044 ) -> Result<spirv::Word, dr::Error> {
1045 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1046 #[allow(unused_mut)]
1047 let mut args = vec![dr::Operand::IdRef(x)];
1048 self.ext_inst(
1049 result_type,
1050 result_id,
1051 extension_set,
1052 crate::spirv::CLOp::log2 as spirv::Word,
1053 args,
1054 )
1055 }
1056 #[allow(clippy::too_many_arguments)]
1057 pub fn cl_log10(
1058 &mut self,
1059 result_type: spirv::Word,
1060 x: spirv::Word,
1061 ) -> Result<spirv::Word, dr::Error> {
1062 self.cl_log10_id(result_type, None, x)
1063 }
1064 #[allow(clippy::too_many_arguments)]
1065 pub fn cl_log10_id(
1066 &mut self,
1067 result_type: spirv::Word,
1068 result_id: Option<spirv::Word>,
1069 x: spirv::Word,
1070 ) -> Result<spirv::Word, dr::Error> {
1071 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1072 #[allow(unused_mut)]
1073 let mut args = vec![dr::Operand::IdRef(x)];
1074 self.ext_inst(
1075 result_type,
1076 result_id,
1077 extension_set,
1078 crate::spirv::CLOp::log10 as spirv::Word,
1079 args,
1080 )
1081 }
1082 #[allow(clippy::too_many_arguments)]
1083 pub fn cl_log1p(
1084 &mut self,
1085 result_type: spirv::Word,
1086 x: spirv::Word,
1087 ) -> Result<spirv::Word, dr::Error> {
1088 self.cl_log1p_id(result_type, None, x)
1089 }
1090 #[allow(clippy::too_many_arguments)]
1091 pub fn cl_log1p_id(
1092 &mut self,
1093 result_type: spirv::Word,
1094 result_id: Option<spirv::Word>,
1095 x: spirv::Word,
1096 ) -> Result<spirv::Word, dr::Error> {
1097 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1098 #[allow(unused_mut)]
1099 let mut args = vec![dr::Operand::IdRef(x)];
1100 self.ext_inst(
1101 result_type,
1102 result_id,
1103 extension_set,
1104 crate::spirv::CLOp::log1p as spirv::Word,
1105 args,
1106 )
1107 }
1108 #[allow(clippy::too_many_arguments)]
1109 pub fn cl_logb(
1110 &mut self,
1111 result_type: spirv::Word,
1112 x: spirv::Word,
1113 ) -> Result<spirv::Word, dr::Error> {
1114 self.cl_logb_id(result_type, None, x)
1115 }
1116 #[allow(clippy::too_many_arguments)]
1117 pub fn cl_logb_id(
1118 &mut self,
1119 result_type: spirv::Word,
1120 result_id: Option<spirv::Word>,
1121 x: spirv::Word,
1122 ) -> Result<spirv::Word, dr::Error> {
1123 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1124 #[allow(unused_mut)]
1125 let mut args = vec![dr::Operand::IdRef(x)];
1126 self.ext_inst(
1127 result_type,
1128 result_id,
1129 extension_set,
1130 crate::spirv::CLOp::logb as spirv::Word,
1131 args,
1132 )
1133 }
1134 #[allow(clippy::too_many_arguments)]
1135 pub fn cl_mad(
1136 &mut self,
1137 result_type: spirv::Word,
1138 a: spirv::Word,
1139 b: spirv::Word,
1140 c: spirv::Word,
1141 ) -> Result<spirv::Word, dr::Error> {
1142 self.cl_mad_id(result_type, None, a, b, c)
1143 }
1144 #[allow(clippy::too_many_arguments)]
1145 pub fn cl_mad_id(
1146 &mut self,
1147 result_type: spirv::Word,
1148 result_id: Option<spirv::Word>,
1149 a: spirv::Word,
1150 b: spirv::Word,
1151 c: spirv::Word,
1152 ) -> Result<spirv::Word, dr::Error> {
1153 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1154 #[allow(unused_mut)]
1155 let mut args = vec![
1156 dr::Operand::IdRef(a),
1157 dr::Operand::IdRef(b),
1158 dr::Operand::IdRef(c),
1159 ];
1160 self.ext_inst(
1161 result_type,
1162 result_id,
1163 extension_set,
1164 crate::spirv::CLOp::mad as spirv::Word,
1165 args,
1166 )
1167 }
1168 #[allow(clippy::too_many_arguments)]
1169 pub fn cl_maxmag(
1170 &mut self,
1171 result_type: spirv::Word,
1172 x: spirv::Word,
1173 y: spirv::Word,
1174 ) -> Result<spirv::Word, dr::Error> {
1175 self.cl_maxmag_id(result_type, None, x, y)
1176 }
1177 #[allow(clippy::too_many_arguments)]
1178 pub fn cl_maxmag_id(
1179 &mut self,
1180 result_type: spirv::Word,
1181 result_id: Option<spirv::Word>,
1182 x: spirv::Word,
1183 y: spirv::Word,
1184 ) -> Result<spirv::Word, dr::Error> {
1185 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1186 #[allow(unused_mut)]
1187 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
1188 self.ext_inst(
1189 result_type,
1190 result_id,
1191 extension_set,
1192 crate::spirv::CLOp::maxmag as spirv::Word,
1193 args,
1194 )
1195 }
1196 #[allow(clippy::too_many_arguments)]
1197 pub fn cl_minmag(
1198 &mut self,
1199 result_type: spirv::Word,
1200 x: spirv::Word,
1201 y: spirv::Word,
1202 ) -> Result<spirv::Word, dr::Error> {
1203 self.cl_minmag_id(result_type, None, x, y)
1204 }
1205 #[allow(clippy::too_many_arguments)]
1206 pub fn cl_minmag_id(
1207 &mut self,
1208 result_type: spirv::Word,
1209 result_id: Option<spirv::Word>,
1210 x: spirv::Word,
1211 y: spirv::Word,
1212 ) -> Result<spirv::Word, dr::Error> {
1213 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1214 #[allow(unused_mut)]
1215 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
1216 self.ext_inst(
1217 result_type,
1218 result_id,
1219 extension_set,
1220 crate::spirv::CLOp::minmag as spirv::Word,
1221 args,
1222 )
1223 }
1224 #[allow(clippy::too_many_arguments)]
1225 pub fn cl_modf(
1226 &mut self,
1227 result_type: spirv::Word,
1228 x: spirv::Word,
1229 iptr: spirv::Word,
1230 ) -> Result<spirv::Word, dr::Error> {
1231 self.cl_modf_id(result_type, None, x, iptr)
1232 }
1233 #[allow(clippy::too_many_arguments)]
1234 pub fn cl_modf_id(
1235 &mut self,
1236 result_type: spirv::Word,
1237 result_id: Option<spirv::Word>,
1238 x: spirv::Word,
1239 iptr: spirv::Word,
1240 ) -> Result<spirv::Word, dr::Error> {
1241 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1242 #[allow(unused_mut)]
1243 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(iptr)];
1244 self.ext_inst(
1245 result_type,
1246 result_id,
1247 extension_set,
1248 crate::spirv::CLOp::modf as spirv::Word,
1249 args,
1250 )
1251 }
1252 #[allow(clippy::too_many_arguments)]
1253 pub fn cl_nan(
1254 &mut self,
1255 result_type: spirv::Word,
1256 nancode: spirv::Word,
1257 ) -> Result<spirv::Word, dr::Error> {
1258 self.cl_nan_id(result_type, None, nancode)
1259 }
1260 #[allow(clippy::too_many_arguments)]
1261 pub fn cl_nan_id(
1262 &mut self,
1263 result_type: spirv::Word,
1264 result_id: Option<spirv::Word>,
1265 nancode: spirv::Word,
1266 ) -> Result<spirv::Word, dr::Error> {
1267 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1268 #[allow(unused_mut)]
1269 let mut args = vec![dr::Operand::IdRef(nancode)];
1270 self.ext_inst(
1271 result_type,
1272 result_id,
1273 extension_set,
1274 crate::spirv::CLOp::nan as spirv::Word,
1275 args,
1276 )
1277 }
1278 #[allow(clippy::too_many_arguments)]
1279 pub fn cl_nextafter(
1280 &mut self,
1281 result_type: spirv::Word,
1282 x: spirv::Word,
1283 y: spirv::Word,
1284 ) -> Result<spirv::Word, dr::Error> {
1285 self.cl_nextafter_id(result_type, None, x, y)
1286 }
1287 #[allow(clippy::too_many_arguments)]
1288 pub fn cl_nextafter_id(
1289 &mut self,
1290 result_type: spirv::Word,
1291 result_id: Option<spirv::Word>,
1292 x: spirv::Word,
1293 y: spirv::Word,
1294 ) -> Result<spirv::Word, dr::Error> {
1295 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1296 #[allow(unused_mut)]
1297 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
1298 self.ext_inst(
1299 result_type,
1300 result_id,
1301 extension_set,
1302 crate::spirv::CLOp::nextafter as spirv::Word,
1303 args,
1304 )
1305 }
1306 #[allow(clippy::too_many_arguments)]
1307 pub fn cl_pow(
1308 &mut self,
1309 result_type: spirv::Word,
1310 x: spirv::Word,
1311 y: spirv::Word,
1312 ) -> Result<spirv::Word, dr::Error> {
1313 self.cl_pow_id(result_type, None, x, y)
1314 }
1315 #[allow(clippy::too_many_arguments)]
1316 pub fn cl_pow_id(
1317 &mut self,
1318 result_type: spirv::Word,
1319 result_id: Option<spirv::Word>,
1320 x: spirv::Word,
1321 y: spirv::Word,
1322 ) -> Result<spirv::Word, dr::Error> {
1323 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1324 #[allow(unused_mut)]
1325 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
1326 self.ext_inst(
1327 result_type,
1328 result_id,
1329 extension_set,
1330 crate::spirv::CLOp::pow as spirv::Word,
1331 args,
1332 )
1333 }
1334 #[allow(clippy::too_many_arguments)]
1335 pub fn cl_pown(
1336 &mut self,
1337 result_type: spirv::Word,
1338 x: spirv::Word,
1339 y: spirv::Word,
1340 ) -> Result<spirv::Word, dr::Error> {
1341 self.cl_pown_id(result_type, None, x, y)
1342 }
1343 #[allow(clippy::too_many_arguments)]
1344 pub fn cl_pown_id(
1345 &mut self,
1346 result_type: spirv::Word,
1347 result_id: Option<spirv::Word>,
1348 x: spirv::Word,
1349 y: spirv::Word,
1350 ) -> Result<spirv::Word, dr::Error> {
1351 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1352 #[allow(unused_mut)]
1353 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
1354 self.ext_inst(
1355 result_type,
1356 result_id,
1357 extension_set,
1358 crate::spirv::CLOp::pown as spirv::Word,
1359 args,
1360 )
1361 }
1362 #[allow(clippy::too_many_arguments)]
1363 pub fn cl_powr(
1364 &mut self,
1365 result_type: spirv::Word,
1366 x: spirv::Word,
1367 y: spirv::Word,
1368 ) -> Result<spirv::Word, dr::Error> {
1369 self.cl_powr_id(result_type, None, x, y)
1370 }
1371 #[allow(clippy::too_many_arguments)]
1372 pub fn cl_powr_id(
1373 &mut self,
1374 result_type: spirv::Word,
1375 result_id: Option<spirv::Word>,
1376 x: spirv::Word,
1377 y: spirv::Word,
1378 ) -> Result<spirv::Word, dr::Error> {
1379 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1380 #[allow(unused_mut)]
1381 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
1382 self.ext_inst(
1383 result_type,
1384 result_id,
1385 extension_set,
1386 crate::spirv::CLOp::powr as spirv::Word,
1387 args,
1388 )
1389 }
1390 #[allow(clippy::too_many_arguments)]
1391 pub fn cl_remainder(
1392 &mut self,
1393 result_type: spirv::Word,
1394 x: spirv::Word,
1395 y: spirv::Word,
1396 ) -> Result<spirv::Word, dr::Error> {
1397 self.cl_remainder_id(result_type, None, x, y)
1398 }
1399 #[allow(clippy::too_many_arguments)]
1400 pub fn cl_remainder_id(
1401 &mut self,
1402 result_type: spirv::Word,
1403 result_id: Option<spirv::Word>,
1404 x: spirv::Word,
1405 y: spirv::Word,
1406 ) -> Result<spirv::Word, dr::Error> {
1407 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1408 #[allow(unused_mut)]
1409 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
1410 self.ext_inst(
1411 result_type,
1412 result_id,
1413 extension_set,
1414 crate::spirv::CLOp::remainder as spirv::Word,
1415 args,
1416 )
1417 }
1418 #[allow(clippy::too_many_arguments)]
1419 pub fn cl_remquo(
1420 &mut self,
1421 result_type: spirv::Word,
1422 x: spirv::Word,
1423 y: spirv::Word,
1424 quo: spirv::Word,
1425 ) -> Result<spirv::Word, dr::Error> {
1426 self.cl_remquo_id(result_type, None, x, y, quo)
1427 }
1428 #[allow(clippy::too_many_arguments)]
1429 pub fn cl_remquo_id(
1430 &mut self,
1431 result_type: spirv::Word,
1432 result_id: Option<spirv::Word>,
1433 x: spirv::Word,
1434 y: spirv::Word,
1435 quo: spirv::Word,
1436 ) -> Result<spirv::Word, dr::Error> {
1437 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1438 #[allow(unused_mut)]
1439 let mut args = vec![
1440 dr::Operand::IdRef(x),
1441 dr::Operand::IdRef(y),
1442 dr::Operand::IdRef(quo),
1443 ];
1444 self.ext_inst(
1445 result_type,
1446 result_id,
1447 extension_set,
1448 crate::spirv::CLOp::remquo as spirv::Word,
1449 args,
1450 )
1451 }
1452 #[allow(clippy::too_many_arguments)]
1453 pub fn cl_rint(
1454 &mut self,
1455 result_type: spirv::Word,
1456 x: spirv::Word,
1457 ) -> Result<spirv::Word, dr::Error> {
1458 self.cl_rint_id(result_type, None, x)
1459 }
1460 #[allow(clippy::too_many_arguments)]
1461 pub fn cl_rint_id(
1462 &mut self,
1463 result_type: spirv::Word,
1464 result_id: Option<spirv::Word>,
1465 x: spirv::Word,
1466 ) -> Result<spirv::Word, dr::Error> {
1467 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1468 #[allow(unused_mut)]
1469 let mut args = vec![dr::Operand::IdRef(x)];
1470 self.ext_inst(
1471 result_type,
1472 result_id,
1473 extension_set,
1474 crate::spirv::CLOp::rint as spirv::Word,
1475 args,
1476 )
1477 }
1478 #[allow(clippy::too_many_arguments)]
1479 pub fn cl_rootn(
1480 &mut self,
1481 result_type: spirv::Word,
1482 x: spirv::Word,
1483 y: spirv::Word,
1484 ) -> Result<spirv::Word, dr::Error> {
1485 self.cl_rootn_id(result_type, None, x, y)
1486 }
1487 #[allow(clippy::too_many_arguments)]
1488 pub fn cl_rootn_id(
1489 &mut self,
1490 result_type: spirv::Word,
1491 result_id: Option<spirv::Word>,
1492 x: spirv::Word,
1493 y: spirv::Word,
1494 ) -> Result<spirv::Word, dr::Error> {
1495 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1496 #[allow(unused_mut)]
1497 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
1498 self.ext_inst(
1499 result_type,
1500 result_id,
1501 extension_set,
1502 crate::spirv::CLOp::rootn as spirv::Word,
1503 args,
1504 )
1505 }
1506 #[allow(clippy::too_many_arguments)]
1507 pub fn cl_round(
1508 &mut self,
1509 result_type: spirv::Word,
1510 x: spirv::Word,
1511 ) -> Result<spirv::Word, dr::Error> {
1512 self.cl_round_id(result_type, None, x)
1513 }
1514 #[allow(clippy::too_many_arguments)]
1515 pub fn cl_round_id(
1516 &mut self,
1517 result_type: spirv::Word,
1518 result_id: Option<spirv::Word>,
1519 x: spirv::Word,
1520 ) -> Result<spirv::Word, dr::Error> {
1521 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1522 #[allow(unused_mut)]
1523 let mut args = vec![dr::Operand::IdRef(x)];
1524 self.ext_inst(
1525 result_type,
1526 result_id,
1527 extension_set,
1528 crate::spirv::CLOp::round as spirv::Word,
1529 args,
1530 )
1531 }
1532 #[allow(clippy::too_many_arguments)]
1533 pub fn cl_rsqrt(
1534 &mut self,
1535 result_type: spirv::Word,
1536 x: spirv::Word,
1537 ) -> Result<spirv::Word, dr::Error> {
1538 self.cl_rsqrt_id(result_type, None, x)
1539 }
1540 #[allow(clippy::too_many_arguments)]
1541 pub fn cl_rsqrt_id(
1542 &mut self,
1543 result_type: spirv::Word,
1544 result_id: Option<spirv::Word>,
1545 x: spirv::Word,
1546 ) -> Result<spirv::Word, dr::Error> {
1547 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1548 #[allow(unused_mut)]
1549 let mut args = vec![dr::Operand::IdRef(x)];
1550 self.ext_inst(
1551 result_type,
1552 result_id,
1553 extension_set,
1554 crate::spirv::CLOp::rsqrt as spirv::Word,
1555 args,
1556 )
1557 }
1558 #[allow(clippy::too_many_arguments)]
1559 pub fn cl_sin(
1560 &mut self,
1561 result_type: spirv::Word,
1562 x: spirv::Word,
1563 ) -> Result<spirv::Word, dr::Error> {
1564 self.cl_sin_id(result_type, None, x)
1565 }
1566 #[allow(clippy::too_many_arguments)]
1567 pub fn cl_sin_id(
1568 &mut self,
1569 result_type: spirv::Word,
1570 result_id: Option<spirv::Word>,
1571 x: spirv::Word,
1572 ) -> Result<spirv::Word, dr::Error> {
1573 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1574 #[allow(unused_mut)]
1575 let mut args = vec![dr::Operand::IdRef(x)];
1576 self.ext_inst(
1577 result_type,
1578 result_id,
1579 extension_set,
1580 crate::spirv::CLOp::sin as spirv::Word,
1581 args,
1582 )
1583 }
1584 #[allow(clippy::too_many_arguments)]
1585 pub fn cl_sincos(
1586 &mut self,
1587 result_type: spirv::Word,
1588 x: spirv::Word,
1589 cosval: spirv::Word,
1590 ) -> Result<spirv::Word, dr::Error> {
1591 self.cl_sincos_id(result_type, None, x, cosval)
1592 }
1593 #[allow(clippy::too_many_arguments)]
1594 pub fn cl_sincos_id(
1595 &mut self,
1596 result_type: spirv::Word,
1597 result_id: Option<spirv::Word>,
1598 x: spirv::Word,
1599 cosval: spirv::Word,
1600 ) -> Result<spirv::Word, dr::Error> {
1601 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1602 #[allow(unused_mut)]
1603 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(cosval)];
1604 self.ext_inst(
1605 result_type,
1606 result_id,
1607 extension_set,
1608 crate::spirv::CLOp::sincos as spirv::Word,
1609 args,
1610 )
1611 }
1612 #[allow(clippy::too_many_arguments)]
1613 pub fn cl_sinh(
1614 &mut self,
1615 result_type: spirv::Word,
1616 x: spirv::Word,
1617 ) -> Result<spirv::Word, dr::Error> {
1618 self.cl_sinh_id(result_type, None, x)
1619 }
1620 #[allow(clippy::too_many_arguments)]
1621 pub fn cl_sinh_id(
1622 &mut self,
1623 result_type: spirv::Word,
1624 result_id: Option<spirv::Word>,
1625 x: spirv::Word,
1626 ) -> Result<spirv::Word, dr::Error> {
1627 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1628 #[allow(unused_mut)]
1629 let mut args = vec![dr::Operand::IdRef(x)];
1630 self.ext_inst(
1631 result_type,
1632 result_id,
1633 extension_set,
1634 crate::spirv::CLOp::sinh as spirv::Word,
1635 args,
1636 )
1637 }
1638 #[allow(clippy::too_many_arguments)]
1639 pub fn cl_sinpi(
1640 &mut self,
1641 result_type: spirv::Word,
1642 x: spirv::Word,
1643 ) -> Result<spirv::Word, dr::Error> {
1644 self.cl_sinpi_id(result_type, None, x)
1645 }
1646 #[allow(clippy::too_many_arguments)]
1647 pub fn cl_sinpi_id(
1648 &mut self,
1649 result_type: spirv::Word,
1650 result_id: Option<spirv::Word>,
1651 x: spirv::Word,
1652 ) -> Result<spirv::Word, dr::Error> {
1653 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1654 #[allow(unused_mut)]
1655 let mut args = vec![dr::Operand::IdRef(x)];
1656 self.ext_inst(
1657 result_type,
1658 result_id,
1659 extension_set,
1660 crate::spirv::CLOp::sinpi as spirv::Word,
1661 args,
1662 )
1663 }
1664 #[allow(clippy::too_many_arguments)]
1665 pub fn cl_sqrt(
1666 &mut self,
1667 result_type: spirv::Word,
1668 x: spirv::Word,
1669 ) -> Result<spirv::Word, dr::Error> {
1670 self.cl_sqrt_id(result_type, None, x)
1671 }
1672 #[allow(clippy::too_many_arguments)]
1673 pub fn cl_sqrt_id(
1674 &mut self,
1675 result_type: spirv::Word,
1676 result_id: Option<spirv::Word>,
1677 x: spirv::Word,
1678 ) -> Result<spirv::Word, dr::Error> {
1679 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1680 #[allow(unused_mut)]
1681 let mut args = vec![dr::Operand::IdRef(x)];
1682 self.ext_inst(
1683 result_type,
1684 result_id,
1685 extension_set,
1686 crate::spirv::CLOp::sqrt as spirv::Word,
1687 args,
1688 )
1689 }
1690 #[allow(clippy::too_many_arguments)]
1691 pub fn cl_tan(
1692 &mut self,
1693 result_type: spirv::Word,
1694 x: spirv::Word,
1695 ) -> Result<spirv::Word, dr::Error> {
1696 self.cl_tan_id(result_type, None, x)
1697 }
1698 #[allow(clippy::too_many_arguments)]
1699 pub fn cl_tan_id(
1700 &mut self,
1701 result_type: spirv::Word,
1702 result_id: Option<spirv::Word>,
1703 x: spirv::Word,
1704 ) -> Result<spirv::Word, dr::Error> {
1705 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1706 #[allow(unused_mut)]
1707 let mut args = vec![dr::Operand::IdRef(x)];
1708 self.ext_inst(
1709 result_type,
1710 result_id,
1711 extension_set,
1712 crate::spirv::CLOp::tan as spirv::Word,
1713 args,
1714 )
1715 }
1716 #[allow(clippy::too_many_arguments)]
1717 pub fn cl_tanh(
1718 &mut self,
1719 result_type: spirv::Word,
1720 x: spirv::Word,
1721 ) -> Result<spirv::Word, dr::Error> {
1722 self.cl_tanh_id(result_type, None, x)
1723 }
1724 #[allow(clippy::too_many_arguments)]
1725 pub fn cl_tanh_id(
1726 &mut self,
1727 result_type: spirv::Word,
1728 result_id: Option<spirv::Word>,
1729 x: spirv::Word,
1730 ) -> Result<spirv::Word, dr::Error> {
1731 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1732 #[allow(unused_mut)]
1733 let mut args = vec![dr::Operand::IdRef(x)];
1734 self.ext_inst(
1735 result_type,
1736 result_id,
1737 extension_set,
1738 crate::spirv::CLOp::tanh as spirv::Word,
1739 args,
1740 )
1741 }
1742 #[allow(clippy::too_many_arguments)]
1743 pub fn cl_tanpi(
1744 &mut self,
1745 result_type: spirv::Word,
1746 x: spirv::Word,
1747 ) -> Result<spirv::Word, dr::Error> {
1748 self.cl_tanpi_id(result_type, None, x)
1749 }
1750 #[allow(clippy::too_many_arguments)]
1751 pub fn cl_tanpi_id(
1752 &mut self,
1753 result_type: spirv::Word,
1754 result_id: Option<spirv::Word>,
1755 x: spirv::Word,
1756 ) -> Result<spirv::Word, dr::Error> {
1757 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1758 #[allow(unused_mut)]
1759 let mut args = vec![dr::Operand::IdRef(x)];
1760 self.ext_inst(
1761 result_type,
1762 result_id,
1763 extension_set,
1764 crate::spirv::CLOp::tanpi as spirv::Word,
1765 args,
1766 )
1767 }
1768 #[allow(clippy::too_many_arguments)]
1769 pub fn cl_tgamma(
1770 &mut self,
1771 result_type: spirv::Word,
1772 x: spirv::Word,
1773 ) -> Result<spirv::Word, dr::Error> {
1774 self.cl_tgamma_id(result_type, None, x)
1775 }
1776 #[allow(clippy::too_many_arguments)]
1777 pub fn cl_tgamma_id(
1778 &mut self,
1779 result_type: spirv::Word,
1780 result_id: Option<spirv::Word>,
1781 x: spirv::Word,
1782 ) -> Result<spirv::Word, dr::Error> {
1783 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1784 #[allow(unused_mut)]
1785 let mut args = vec![dr::Operand::IdRef(x)];
1786 self.ext_inst(
1787 result_type,
1788 result_id,
1789 extension_set,
1790 crate::spirv::CLOp::tgamma as spirv::Word,
1791 args,
1792 )
1793 }
1794 #[allow(clippy::too_many_arguments)]
1795 pub fn cl_trunc(
1796 &mut self,
1797 result_type: spirv::Word,
1798 x: spirv::Word,
1799 ) -> Result<spirv::Word, dr::Error> {
1800 self.cl_trunc_id(result_type, None, x)
1801 }
1802 #[allow(clippy::too_many_arguments)]
1803 pub fn cl_trunc_id(
1804 &mut self,
1805 result_type: spirv::Word,
1806 result_id: Option<spirv::Word>,
1807 x: spirv::Word,
1808 ) -> Result<spirv::Word, dr::Error> {
1809 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1810 #[allow(unused_mut)]
1811 let mut args = vec![dr::Operand::IdRef(x)];
1812 self.ext_inst(
1813 result_type,
1814 result_id,
1815 extension_set,
1816 crate::spirv::CLOp::trunc as spirv::Word,
1817 args,
1818 )
1819 }
1820 #[allow(clippy::too_many_arguments)]
1821 pub fn cl_half_cos(
1822 &mut self,
1823 result_type: spirv::Word,
1824 x: spirv::Word,
1825 ) -> Result<spirv::Word, dr::Error> {
1826 self.cl_half_cos_id(result_type, None, x)
1827 }
1828 #[allow(clippy::too_many_arguments)]
1829 pub fn cl_half_cos_id(
1830 &mut self,
1831 result_type: spirv::Word,
1832 result_id: Option<spirv::Word>,
1833 x: spirv::Word,
1834 ) -> Result<spirv::Word, dr::Error> {
1835 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1836 #[allow(unused_mut)]
1837 let mut args = vec![dr::Operand::IdRef(x)];
1838 self.ext_inst(
1839 result_type,
1840 result_id,
1841 extension_set,
1842 crate::spirv::CLOp::half_cos as spirv::Word,
1843 args,
1844 )
1845 }
1846 #[allow(clippy::too_many_arguments)]
1847 pub fn cl_half_divide(
1848 &mut self,
1849 result_type: spirv::Word,
1850 x: spirv::Word,
1851 y: spirv::Word,
1852 ) -> Result<spirv::Word, dr::Error> {
1853 self.cl_half_divide_id(result_type, None, x, y)
1854 }
1855 #[allow(clippy::too_many_arguments)]
1856 pub fn cl_half_divide_id(
1857 &mut self,
1858 result_type: spirv::Word,
1859 result_id: Option<spirv::Word>,
1860 x: spirv::Word,
1861 y: spirv::Word,
1862 ) -> Result<spirv::Word, dr::Error> {
1863 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1864 #[allow(unused_mut)]
1865 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
1866 self.ext_inst(
1867 result_type,
1868 result_id,
1869 extension_set,
1870 crate::spirv::CLOp::half_divide as spirv::Word,
1871 args,
1872 )
1873 }
1874 #[allow(clippy::too_many_arguments)]
1875 pub fn cl_half_exp(
1876 &mut self,
1877 result_type: spirv::Word,
1878 x: spirv::Word,
1879 ) -> Result<spirv::Word, dr::Error> {
1880 self.cl_half_exp_id(result_type, None, x)
1881 }
1882 #[allow(clippy::too_many_arguments)]
1883 pub fn cl_half_exp_id(
1884 &mut self,
1885 result_type: spirv::Word,
1886 result_id: Option<spirv::Word>,
1887 x: spirv::Word,
1888 ) -> Result<spirv::Word, dr::Error> {
1889 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1890 #[allow(unused_mut)]
1891 let mut args = vec![dr::Operand::IdRef(x)];
1892 self.ext_inst(
1893 result_type,
1894 result_id,
1895 extension_set,
1896 crate::spirv::CLOp::half_exp as spirv::Word,
1897 args,
1898 )
1899 }
1900 #[allow(clippy::too_many_arguments)]
1901 pub fn cl_half_exp2(
1902 &mut self,
1903 result_type: spirv::Word,
1904 x: spirv::Word,
1905 ) -> Result<spirv::Word, dr::Error> {
1906 self.cl_half_exp2_id(result_type, None, x)
1907 }
1908 #[allow(clippy::too_many_arguments)]
1909 pub fn cl_half_exp2_id(
1910 &mut self,
1911 result_type: spirv::Word,
1912 result_id: Option<spirv::Word>,
1913 x: spirv::Word,
1914 ) -> Result<spirv::Word, dr::Error> {
1915 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1916 #[allow(unused_mut)]
1917 let mut args = vec![dr::Operand::IdRef(x)];
1918 self.ext_inst(
1919 result_type,
1920 result_id,
1921 extension_set,
1922 crate::spirv::CLOp::half_exp2 as spirv::Word,
1923 args,
1924 )
1925 }
1926 #[allow(clippy::too_many_arguments)]
1927 pub fn cl_half_exp10(
1928 &mut self,
1929 result_type: spirv::Word,
1930 x: spirv::Word,
1931 ) -> Result<spirv::Word, dr::Error> {
1932 self.cl_half_exp10_id(result_type, None, x)
1933 }
1934 #[allow(clippy::too_many_arguments)]
1935 pub fn cl_half_exp10_id(
1936 &mut self,
1937 result_type: spirv::Word,
1938 result_id: Option<spirv::Word>,
1939 x: spirv::Word,
1940 ) -> Result<spirv::Word, dr::Error> {
1941 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1942 #[allow(unused_mut)]
1943 let mut args = vec![dr::Operand::IdRef(x)];
1944 self.ext_inst(
1945 result_type,
1946 result_id,
1947 extension_set,
1948 crate::spirv::CLOp::half_exp10 as spirv::Word,
1949 args,
1950 )
1951 }
1952 #[allow(clippy::too_many_arguments)]
1953 pub fn cl_half_log(
1954 &mut self,
1955 result_type: spirv::Word,
1956 x: spirv::Word,
1957 ) -> Result<spirv::Word, dr::Error> {
1958 self.cl_half_log_id(result_type, None, x)
1959 }
1960 #[allow(clippy::too_many_arguments)]
1961 pub fn cl_half_log_id(
1962 &mut self,
1963 result_type: spirv::Word,
1964 result_id: Option<spirv::Word>,
1965 x: spirv::Word,
1966 ) -> Result<spirv::Word, dr::Error> {
1967 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1968 #[allow(unused_mut)]
1969 let mut args = vec![dr::Operand::IdRef(x)];
1970 self.ext_inst(
1971 result_type,
1972 result_id,
1973 extension_set,
1974 crate::spirv::CLOp::half_log as spirv::Word,
1975 args,
1976 )
1977 }
1978 #[allow(clippy::too_many_arguments)]
1979 pub fn cl_half_log2(
1980 &mut self,
1981 result_type: spirv::Word,
1982 x: spirv::Word,
1983 ) -> Result<spirv::Word, dr::Error> {
1984 self.cl_half_log2_id(result_type, None, x)
1985 }
1986 #[allow(clippy::too_many_arguments)]
1987 pub fn cl_half_log2_id(
1988 &mut self,
1989 result_type: spirv::Word,
1990 result_id: Option<spirv::Word>,
1991 x: spirv::Word,
1992 ) -> Result<spirv::Word, dr::Error> {
1993 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
1994 #[allow(unused_mut)]
1995 let mut args = vec![dr::Operand::IdRef(x)];
1996 self.ext_inst(
1997 result_type,
1998 result_id,
1999 extension_set,
2000 crate::spirv::CLOp::half_log2 as spirv::Word,
2001 args,
2002 )
2003 }
2004 #[allow(clippy::too_many_arguments)]
2005 pub fn cl_half_log10(
2006 &mut self,
2007 result_type: spirv::Word,
2008 x: spirv::Word,
2009 ) -> Result<spirv::Word, dr::Error> {
2010 self.cl_half_log10_id(result_type, None, x)
2011 }
2012 #[allow(clippy::too_many_arguments)]
2013 pub fn cl_half_log10_id(
2014 &mut self,
2015 result_type: spirv::Word,
2016 result_id: Option<spirv::Word>,
2017 x: spirv::Word,
2018 ) -> Result<spirv::Word, dr::Error> {
2019 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2020 #[allow(unused_mut)]
2021 let mut args = vec![dr::Operand::IdRef(x)];
2022 self.ext_inst(
2023 result_type,
2024 result_id,
2025 extension_set,
2026 crate::spirv::CLOp::half_log10 as spirv::Word,
2027 args,
2028 )
2029 }
2030 #[allow(clippy::too_many_arguments)]
2031 pub fn cl_half_powr(
2032 &mut self,
2033 result_type: spirv::Word,
2034 x: spirv::Word,
2035 y: spirv::Word,
2036 ) -> Result<spirv::Word, dr::Error> {
2037 self.cl_half_powr_id(result_type, None, x, y)
2038 }
2039 #[allow(clippy::too_many_arguments)]
2040 pub fn cl_half_powr_id(
2041 &mut self,
2042 result_type: spirv::Word,
2043 result_id: Option<spirv::Word>,
2044 x: spirv::Word,
2045 y: spirv::Word,
2046 ) -> Result<spirv::Word, dr::Error> {
2047 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2048 #[allow(unused_mut)]
2049 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
2050 self.ext_inst(
2051 result_type,
2052 result_id,
2053 extension_set,
2054 crate::spirv::CLOp::half_powr as spirv::Word,
2055 args,
2056 )
2057 }
2058 #[allow(clippy::too_many_arguments)]
2059 pub fn cl_half_recip(
2060 &mut self,
2061 result_type: spirv::Word,
2062 x: spirv::Word,
2063 ) -> Result<spirv::Word, dr::Error> {
2064 self.cl_half_recip_id(result_type, None, x)
2065 }
2066 #[allow(clippy::too_many_arguments)]
2067 pub fn cl_half_recip_id(
2068 &mut self,
2069 result_type: spirv::Word,
2070 result_id: Option<spirv::Word>,
2071 x: spirv::Word,
2072 ) -> Result<spirv::Word, dr::Error> {
2073 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2074 #[allow(unused_mut)]
2075 let mut args = vec![dr::Operand::IdRef(x)];
2076 self.ext_inst(
2077 result_type,
2078 result_id,
2079 extension_set,
2080 crate::spirv::CLOp::half_recip as spirv::Word,
2081 args,
2082 )
2083 }
2084 #[allow(clippy::too_many_arguments)]
2085 pub fn cl_half_rsqrt(
2086 &mut self,
2087 result_type: spirv::Word,
2088 x: spirv::Word,
2089 ) -> Result<spirv::Word, dr::Error> {
2090 self.cl_half_rsqrt_id(result_type, None, x)
2091 }
2092 #[allow(clippy::too_many_arguments)]
2093 pub fn cl_half_rsqrt_id(
2094 &mut self,
2095 result_type: spirv::Word,
2096 result_id: Option<spirv::Word>,
2097 x: spirv::Word,
2098 ) -> Result<spirv::Word, dr::Error> {
2099 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2100 #[allow(unused_mut)]
2101 let mut args = vec![dr::Operand::IdRef(x)];
2102 self.ext_inst(
2103 result_type,
2104 result_id,
2105 extension_set,
2106 crate::spirv::CLOp::half_rsqrt as spirv::Word,
2107 args,
2108 )
2109 }
2110 #[allow(clippy::too_many_arguments)]
2111 pub fn cl_half_sin(
2112 &mut self,
2113 result_type: spirv::Word,
2114 x: spirv::Word,
2115 ) -> Result<spirv::Word, dr::Error> {
2116 self.cl_half_sin_id(result_type, None, x)
2117 }
2118 #[allow(clippy::too_many_arguments)]
2119 pub fn cl_half_sin_id(
2120 &mut self,
2121 result_type: spirv::Word,
2122 result_id: Option<spirv::Word>,
2123 x: spirv::Word,
2124 ) -> Result<spirv::Word, dr::Error> {
2125 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2126 #[allow(unused_mut)]
2127 let mut args = vec![dr::Operand::IdRef(x)];
2128 self.ext_inst(
2129 result_type,
2130 result_id,
2131 extension_set,
2132 crate::spirv::CLOp::half_sin as spirv::Word,
2133 args,
2134 )
2135 }
2136 #[allow(clippy::too_many_arguments)]
2137 pub fn cl_half_sqrt(
2138 &mut self,
2139 result_type: spirv::Word,
2140 x: spirv::Word,
2141 ) -> Result<spirv::Word, dr::Error> {
2142 self.cl_half_sqrt_id(result_type, None, x)
2143 }
2144 #[allow(clippy::too_many_arguments)]
2145 pub fn cl_half_sqrt_id(
2146 &mut self,
2147 result_type: spirv::Word,
2148 result_id: Option<spirv::Word>,
2149 x: spirv::Word,
2150 ) -> Result<spirv::Word, dr::Error> {
2151 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2152 #[allow(unused_mut)]
2153 let mut args = vec![dr::Operand::IdRef(x)];
2154 self.ext_inst(
2155 result_type,
2156 result_id,
2157 extension_set,
2158 crate::spirv::CLOp::half_sqrt as spirv::Word,
2159 args,
2160 )
2161 }
2162 #[allow(clippy::too_many_arguments)]
2163 pub fn cl_half_tan(
2164 &mut self,
2165 result_type: spirv::Word,
2166 x: spirv::Word,
2167 ) -> Result<spirv::Word, dr::Error> {
2168 self.cl_half_tan_id(result_type, None, x)
2169 }
2170 #[allow(clippy::too_many_arguments)]
2171 pub fn cl_half_tan_id(
2172 &mut self,
2173 result_type: spirv::Word,
2174 result_id: Option<spirv::Word>,
2175 x: spirv::Word,
2176 ) -> Result<spirv::Word, dr::Error> {
2177 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2178 #[allow(unused_mut)]
2179 let mut args = vec![dr::Operand::IdRef(x)];
2180 self.ext_inst(
2181 result_type,
2182 result_id,
2183 extension_set,
2184 crate::spirv::CLOp::half_tan as spirv::Word,
2185 args,
2186 )
2187 }
2188 #[allow(clippy::too_many_arguments)]
2189 pub fn cl_native_cos(
2190 &mut self,
2191 result_type: spirv::Word,
2192 x: spirv::Word,
2193 ) -> Result<spirv::Word, dr::Error> {
2194 self.cl_native_cos_id(result_type, None, x)
2195 }
2196 #[allow(clippy::too_many_arguments)]
2197 pub fn cl_native_cos_id(
2198 &mut self,
2199 result_type: spirv::Word,
2200 result_id: Option<spirv::Word>,
2201 x: spirv::Word,
2202 ) -> Result<spirv::Word, dr::Error> {
2203 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2204 #[allow(unused_mut)]
2205 let mut args = vec![dr::Operand::IdRef(x)];
2206 self.ext_inst(
2207 result_type,
2208 result_id,
2209 extension_set,
2210 crate::spirv::CLOp::native_cos as spirv::Word,
2211 args,
2212 )
2213 }
2214 #[allow(clippy::too_many_arguments)]
2215 pub fn cl_native_divide(
2216 &mut self,
2217 result_type: spirv::Word,
2218 x: spirv::Word,
2219 y: spirv::Word,
2220 ) -> Result<spirv::Word, dr::Error> {
2221 self.cl_native_divide_id(result_type, None, x, y)
2222 }
2223 #[allow(clippy::too_many_arguments)]
2224 pub fn cl_native_divide_id(
2225 &mut self,
2226 result_type: spirv::Word,
2227 result_id: Option<spirv::Word>,
2228 x: spirv::Word,
2229 y: spirv::Word,
2230 ) -> Result<spirv::Word, dr::Error> {
2231 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2232 #[allow(unused_mut)]
2233 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
2234 self.ext_inst(
2235 result_type,
2236 result_id,
2237 extension_set,
2238 crate::spirv::CLOp::native_divide as spirv::Word,
2239 args,
2240 )
2241 }
2242 #[allow(clippy::too_many_arguments)]
2243 pub fn cl_native_exp(
2244 &mut self,
2245 result_type: spirv::Word,
2246 x: spirv::Word,
2247 ) -> Result<spirv::Word, dr::Error> {
2248 self.cl_native_exp_id(result_type, None, x)
2249 }
2250 #[allow(clippy::too_many_arguments)]
2251 pub fn cl_native_exp_id(
2252 &mut self,
2253 result_type: spirv::Word,
2254 result_id: Option<spirv::Word>,
2255 x: spirv::Word,
2256 ) -> Result<spirv::Word, dr::Error> {
2257 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2258 #[allow(unused_mut)]
2259 let mut args = vec![dr::Operand::IdRef(x)];
2260 self.ext_inst(
2261 result_type,
2262 result_id,
2263 extension_set,
2264 crate::spirv::CLOp::native_exp as spirv::Word,
2265 args,
2266 )
2267 }
2268 #[allow(clippy::too_many_arguments)]
2269 pub fn cl_native_exp2(
2270 &mut self,
2271 result_type: spirv::Word,
2272 x: spirv::Word,
2273 ) -> Result<spirv::Word, dr::Error> {
2274 self.cl_native_exp2_id(result_type, None, x)
2275 }
2276 #[allow(clippy::too_many_arguments)]
2277 pub fn cl_native_exp2_id(
2278 &mut self,
2279 result_type: spirv::Word,
2280 result_id: Option<spirv::Word>,
2281 x: spirv::Word,
2282 ) -> Result<spirv::Word, dr::Error> {
2283 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2284 #[allow(unused_mut)]
2285 let mut args = vec![dr::Operand::IdRef(x)];
2286 self.ext_inst(
2287 result_type,
2288 result_id,
2289 extension_set,
2290 crate::spirv::CLOp::native_exp2 as spirv::Word,
2291 args,
2292 )
2293 }
2294 #[allow(clippy::too_many_arguments)]
2295 pub fn cl_native_exp10(
2296 &mut self,
2297 result_type: spirv::Word,
2298 x: spirv::Word,
2299 ) -> Result<spirv::Word, dr::Error> {
2300 self.cl_native_exp10_id(result_type, None, x)
2301 }
2302 #[allow(clippy::too_many_arguments)]
2303 pub fn cl_native_exp10_id(
2304 &mut self,
2305 result_type: spirv::Word,
2306 result_id: Option<spirv::Word>,
2307 x: spirv::Word,
2308 ) -> Result<spirv::Word, dr::Error> {
2309 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2310 #[allow(unused_mut)]
2311 let mut args = vec![dr::Operand::IdRef(x)];
2312 self.ext_inst(
2313 result_type,
2314 result_id,
2315 extension_set,
2316 crate::spirv::CLOp::native_exp10 as spirv::Word,
2317 args,
2318 )
2319 }
2320 #[allow(clippy::too_many_arguments)]
2321 pub fn cl_native_log(
2322 &mut self,
2323 result_type: spirv::Word,
2324 x: spirv::Word,
2325 ) -> Result<spirv::Word, dr::Error> {
2326 self.cl_native_log_id(result_type, None, x)
2327 }
2328 #[allow(clippy::too_many_arguments)]
2329 pub fn cl_native_log_id(
2330 &mut self,
2331 result_type: spirv::Word,
2332 result_id: Option<spirv::Word>,
2333 x: spirv::Word,
2334 ) -> Result<spirv::Word, dr::Error> {
2335 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2336 #[allow(unused_mut)]
2337 let mut args = vec![dr::Operand::IdRef(x)];
2338 self.ext_inst(
2339 result_type,
2340 result_id,
2341 extension_set,
2342 crate::spirv::CLOp::native_log as spirv::Word,
2343 args,
2344 )
2345 }
2346 #[allow(clippy::too_many_arguments)]
2347 pub fn cl_native_log2(
2348 &mut self,
2349 result_type: spirv::Word,
2350 x: spirv::Word,
2351 ) -> Result<spirv::Word, dr::Error> {
2352 self.cl_native_log2_id(result_type, None, x)
2353 }
2354 #[allow(clippy::too_many_arguments)]
2355 pub fn cl_native_log2_id(
2356 &mut self,
2357 result_type: spirv::Word,
2358 result_id: Option<spirv::Word>,
2359 x: spirv::Word,
2360 ) -> Result<spirv::Word, dr::Error> {
2361 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2362 #[allow(unused_mut)]
2363 let mut args = vec![dr::Operand::IdRef(x)];
2364 self.ext_inst(
2365 result_type,
2366 result_id,
2367 extension_set,
2368 crate::spirv::CLOp::native_log2 as spirv::Word,
2369 args,
2370 )
2371 }
2372 #[allow(clippy::too_many_arguments)]
2373 pub fn cl_native_log10(
2374 &mut self,
2375 result_type: spirv::Word,
2376 x: spirv::Word,
2377 ) -> Result<spirv::Word, dr::Error> {
2378 self.cl_native_log10_id(result_type, None, x)
2379 }
2380 #[allow(clippy::too_many_arguments)]
2381 pub fn cl_native_log10_id(
2382 &mut self,
2383 result_type: spirv::Word,
2384 result_id: Option<spirv::Word>,
2385 x: spirv::Word,
2386 ) -> Result<spirv::Word, dr::Error> {
2387 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2388 #[allow(unused_mut)]
2389 let mut args = vec![dr::Operand::IdRef(x)];
2390 self.ext_inst(
2391 result_type,
2392 result_id,
2393 extension_set,
2394 crate::spirv::CLOp::native_log10 as spirv::Word,
2395 args,
2396 )
2397 }
2398 #[allow(clippy::too_many_arguments)]
2399 pub fn cl_native_powr(
2400 &mut self,
2401 result_type: spirv::Word,
2402 x: spirv::Word,
2403 y: spirv::Word,
2404 ) -> Result<spirv::Word, dr::Error> {
2405 self.cl_native_powr_id(result_type, None, x, y)
2406 }
2407 #[allow(clippy::too_many_arguments)]
2408 pub fn cl_native_powr_id(
2409 &mut self,
2410 result_type: spirv::Word,
2411 result_id: Option<spirv::Word>,
2412 x: spirv::Word,
2413 y: spirv::Word,
2414 ) -> Result<spirv::Word, dr::Error> {
2415 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2416 #[allow(unused_mut)]
2417 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
2418 self.ext_inst(
2419 result_type,
2420 result_id,
2421 extension_set,
2422 crate::spirv::CLOp::native_powr as spirv::Word,
2423 args,
2424 )
2425 }
2426 #[allow(clippy::too_many_arguments)]
2427 pub fn cl_native_recip(
2428 &mut self,
2429 result_type: spirv::Word,
2430 x: spirv::Word,
2431 ) -> Result<spirv::Word, dr::Error> {
2432 self.cl_native_recip_id(result_type, None, x)
2433 }
2434 #[allow(clippy::too_many_arguments)]
2435 pub fn cl_native_recip_id(
2436 &mut self,
2437 result_type: spirv::Word,
2438 result_id: Option<spirv::Word>,
2439 x: spirv::Word,
2440 ) -> Result<spirv::Word, dr::Error> {
2441 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2442 #[allow(unused_mut)]
2443 let mut args = vec![dr::Operand::IdRef(x)];
2444 self.ext_inst(
2445 result_type,
2446 result_id,
2447 extension_set,
2448 crate::spirv::CLOp::native_recip as spirv::Word,
2449 args,
2450 )
2451 }
2452 #[allow(clippy::too_many_arguments)]
2453 pub fn cl_native_rsqrt(
2454 &mut self,
2455 result_type: spirv::Word,
2456 x: spirv::Word,
2457 ) -> Result<spirv::Word, dr::Error> {
2458 self.cl_native_rsqrt_id(result_type, None, x)
2459 }
2460 #[allow(clippy::too_many_arguments)]
2461 pub fn cl_native_rsqrt_id(
2462 &mut self,
2463 result_type: spirv::Word,
2464 result_id: Option<spirv::Word>,
2465 x: spirv::Word,
2466 ) -> Result<spirv::Word, dr::Error> {
2467 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2468 #[allow(unused_mut)]
2469 let mut args = vec![dr::Operand::IdRef(x)];
2470 self.ext_inst(
2471 result_type,
2472 result_id,
2473 extension_set,
2474 crate::spirv::CLOp::native_rsqrt as spirv::Word,
2475 args,
2476 )
2477 }
2478 #[allow(clippy::too_many_arguments)]
2479 pub fn cl_native_sin(
2480 &mut self,
2481 result_type: spirv::Word,
2482 x: spirv::Word,
2483 ) -> Result<spirv::Word, dr::Error> {
2484 self.cl_native_sin_id(result_type, None, x)
2485 }
2486 #[allow(clippy::too_many_arguments)]
2487 pub fn cl_native_sin_id(
2488 &mut self,
2489 result_type: spirv::Word,
2490 result_id: Option<spirv::Word>,
2491 x: spirv::Word,
2492 ) -> Result<spirv::Word, dr::Error> {
2493 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2494 #[allow(unused_mut)]
2495 let mut args = vec![dr::Operand::IdRef(x)];
2496 self.ext_inst(
2497 result_type,
2498 result_id,
2499 extension_set,
2500 crate::spirv::CLOp::native_sin as spirv::Word,
2501 args,
2502 )
2503 }
2504 #[allow(clippy::too_many_arguments)]
2505 pub fn cl_native_sqrt(
2506 &mut self,
2507 result_type: spirv::Word,
2508 x: spirv::Word,
2509 ) -> Result<spirv::Word, dr::Error> {
2510 self.cl_native_sqrt_id(result_type, None, x)
2511 }
2512 #[allow(clippy::too_many_arguments)]
2513 pub fn cl_native_sqrt_id(
2514 &mut self,
2515 result_type: spirv::Word,
2516 result_id: Option<spirv::Word>,
2517 x: spirv::Word,
2518 ) -> Result<spirv::Word, dr::Error> {
2519 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2520 #[allow(unused_mut)]
2521 let mut args = vec![dr::Operand::IdRef(x)];
2522 self.ext_inst(
2523 result_type,
2524 result_id,
2525 extension_set,
2526 crate::spirv::CLOp::native_sqrt as spirv::Word,
2527 args,
2528 )
2529 }
2530 #[allow(clippy::too_many_arguments)]
2531 pub fn cl_native_tan(
2532 &mut self,
2533 result_type: spirv::Word,
2534 x: spirv::Word,
2535 ) -> Result<spirv::Word, dr::Error> {
2536 self.cl_native_tan_id(result_type, None, x)
2537 }
2538 #[allow(clippy::too_many_arguments)]
2539 pub fn cl_native_tan_id(
2540 &mut self,
2541 result_type: spirv::Word,
2542 result_id: Option<spirv::Word>,
2543 x: spirv::Word,
2544 ) -> Result<spirv::Word, dr::Error> {
2545 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2546 #[allow(unused_mut)]
2547 let mut args = vec![dr::Operand::IdRef(x)];
2548 self.ext_inst(
2549 result_type,
2550 result_id,
2551 extension_set,
2552 crate::spirv::CLOp::native_tan as spirv::Word,
2553 args,
2554 )
2555 }
2556 #[allow(clippy::too_many_arguments)]
2557 pub fn cl_s_abs(
2558 &mut self,
2559 result_type: spirv::Word,
2560 x: spirv::Word,
2561 ) -> Result<spirv::Word, dr::Error> {
2562 self.cl_s_abs_id(result_type, None, x)
2563 }
2564 #[allow(clippy::too_many_arguments)]
2565 pub fn cl_s_abs_id(
2566 &mut self,
2567 result_type: spirv::Word,
2568 result_id: Option<spirv::Word>,
2569 x: spirv::Word,
2570 ) -> Result<spirv::Word, dr::Error> {
2571 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2572 #[allow(unused_mut)]
2573 let mut args = vec![dr::Operand::IdRef(x)];
2574 self.ext_inst(
2575 result_type,
2576 result_id,
2577 extension_set,
2578 crate::spirv::CLOp::s_abs as spirv::Word,
2579 args,
2580 )
2581 }
2582 #[allow(clippy::too_many_arguments)]
2583 pub fn cl_s_abs_diff(
2584 &mut self,
2585 result_type: spirv::Word,
2586 x: spirv::Word,
2587 y: spirv::Word,
2588 ) -> Result<spirv::Word, dr::Error> {
2589 self.cl_s_abs_diff_id(result_type, None, x, y)
2590 }
2591 #[allow(clippy::too_many_arguments)]
2592 pub fn cl_s_abs_diff_id(
2593 &mut self,
2594 result_type: spirv::Word,
2595 result_id: Option<spirv::Word>,
2596 x: spirv::Word,
2597 y: spirv::Word,
2598 ) -> Result<spirv::Word, dr::Error> {
2599 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2600 #[allow(unused_mut)]
2601 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
2602 self.ext_inst(
2603 result_type,
2604 result_id,
2605 extension_set,
2606 crate::spirv::CLOp::s_abs_diff as spirv::Word,
2607 args,
2608 )
2609 }
2610 #[allow(clippy::too_many_arguments)]
2611 pub fn cl_s_add_sat(
2612 &mut self,
2613 result_type: spirv::Word,
2614 x: spirv::Word,
2615 y: spirv::Word,
2616 ) -> Result<spirv::Word, dr::Error> {
2617 self.cl_s_add_sat_id(result_type, None, x, y)
2618 }
2619 #[allow(clippy::too_many_arguments)]
2620 pub fn cl_s_add_sat_id(
2621 &mut self,
2622 result_type: spirv::Word,
2623 result_id: Option<spirv::Word>,
2624 x: spirv::Word,
2625 y: spirv::Word,
2626 ) -> Result<spirv::Word, dr::Error> {
2627 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2628 #[allow(unused_mut)]
2629 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
2630 self.ext_inst(
2631 result_type,
2632 result_id,
2633 extension_set,
2634 crate::spirv::CLOp::s_add_sat as spirv::Word,
2635 args,
2636 )
2637 }
2638 #[allow(clippy::too_many_arguments)]
2639 pub fn cl_u_add_sat(
2640 &mut self,
2641 result_type: spirv::Word,
2642 x: spirv::Word,
2643 y: spirv::Word,
2644 ) -> Result<spirv::Word, dr::Error> {
2645 self.cl_u_add_sat_id(result_type, None, x, y)
2646 }
2647 #[allow(clippy::too_many_arguments)]
2648 pub fn cl_u_add_sat_id(
2649 &mut self,
2650 result_type: spirv::Word,
2651 result_id: Option<spirv::Word>,
2652 x: spirv::Word,
2653 y: spirv::Word,
2654 ) -> Result<spirv::Word, dr::Error> {
2655 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2656 #[allow(unused_mut)]
2657 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
2658 self.ext_inst(
2659 result_type,
2660 result_id,
2661 extension_set,
2662 crate::spirv::CLOp::u_add_sat as spirv::Word,
2663 args,
2664 )
2665 }
2666 #[allow(clippy::too_many_arguments)]
2667 pub fn cl_s_hadd(
2668 &mut self,
2669 result_type: spirv::Word,
2670 x: spirv::Word,
2671 y: spirv::Word,
2672 ) -> Result<spirv::Word, dr::Error> {
2673 self.cl_s_hadd_id(result_type, None, x, y)
2674 }
2675 #[allow(clippy::too_many_arguments)]
2676 pub fn cl_s_hadd_id(
2677 &mut self,
2678 result_type: spirv::Word,
2679 result_id: Option<spirv::Word>,
2680 x: spirv::Word,
2681 y: spirv::Word,
2682 ) -> Result<spirv::Word, dr::Error> {
2683 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2684 #[allow(unused_mut)]
2685 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
2686 self.ext_inst(
2687 result_type,
2688 result_id,
2689 extension_set,
2690 crate::spirv::CLOp::s_hadd as spirv::Word,
2691 args,
2692 )
2693 }
2694 #[allow(clippy::too_many_arguments)]
2695 pub fn cl_u_hadd(
2696 &mut self,
2697 result_type: spirv::Word,
2698 x: spirv::Word,
2699 y: spirv::Word,
2700 ) -> Result<spirv::Word, dr::Error> {
2701 self.cl_u_hadd_id(result_type, None, x, y)
2702 }
2703 #[allow(clippy::too_many_arguments)]
2704 pub fn cl_u_hadd_id(
2705 &mut self,
2706 result_type: spirv::Word,
2707 result_id: Option<spirv::Word>,
2708 x: spirv::Word,
2709 y: spirv::Word,
2710 ) -> Result<spirv::Word, dr::Error> {
2711 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2712 #[allow(unused_mut)]
2713 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
2714 self.ext_inst(
2715 result_type,
2716 result_id,
2717 extension_set,
2718 crate::spirv::CLOp::u_hadd as spirv::Word,
2719 args,
2720 )
2721 }
2722 #[allow(clippy::too_many_arguments)]
2723 pub fn cl_s_rhadd(
2724 &mut self,
2725 result_type: spirv::Word,
2726 x: spirv::Word,
2727 y: spirv::Word,
2728 ) -> Result<spirv::Word, dr::Error> {
2729 self.cl_s_rhadd_id(result_type, None, x, y)
2730 }
2731 #[allow(clippy::too_many_arguments)]
2732 pub fn cl_s_rhadd_id(
2733 &mut self,
2734 result_type: spirv::Word,
2735 result_id: Option<spirv::Word>,
2736 x: spirv::Word,
2737 y: spirv::Word,
2738 ) -> Result<spirv::Word, dr::Error> {
2739 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2740 #[allow(unused_mut)]
2741 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
2742 self.ext_inst(
2743 result_type,
2744 result_id,
2745 extension_set,
2746 crate::spirv::CLOp::s_rhadd as spirv::Word,
2747 args,
2748 )
2749 }
2750 #[allow(clippy::too_many_arguments)]
2751 pub fn cl_u_rhadd(
2752 &mut self,
2753 result_type: spirv::Word,
2754 x: spirv::Word,
2755 y: spirv::Word,
2756 ) -> Result<spirv::Word, dr::Error> {
2757 self.cl_u_rhadd_id(result_type, None, x, y)
2758 }
2759 #[allow(clippy::too_many_arguments)]
2760 pub fn cl_u_rhadd_id(
2761 &mut self,
2762 result_type: spirv::Word,
2763 result_id: Option<spirv::Word>,
2764 x: spirv::Word,
2765 y: spirv::Word,
2766 ) -> Result<spirv::Word, dr::Error> {
2767 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2768 #[allow(unused_mut)]
2769 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
2770 self.ext_inst(
2771 result_type,
2772 result_id,
2773 extension_set,
2774 crate::spirv::CLOp::u_rhadd as spirv::Word,
2775 args,
2776 )
2777 }
2778 #[allow(clippy::too_many_arguments)]
2779 pub fn cl_s_clamp(
2780 &mut self,
2781 result_type: spirv::Word,
2782 x: spirv::Word,
2783 minval: spirv::Word,
2784 maxval: spirv::Word,
2785 ) -> Result<spirv::Word, dr::Error> {
2786 self.cl_s_clamp_id(result_type, None, x, minval, maxval)
2787 }
2788 #[allow(clippy::too_many_arguments)]
2789 pub fn cl_s_clamp_id(
2790 &mut self,
2791 result_type: spirv::Word,
2792 result_id: Option<spirv::Word>,
2793 x: spirv::Word,
2794 minval: spirv::Word,
2795 maxval: spirv::Word,
2796 ) -> Result<spirv::Word, dr::Error> {
2797 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2798 #[allow(unused_mut)]
2799 let mut args = vec![
2800 dr::Operand::IdRef(x),
2801 dr::Operand::IdRef(minval),
2802 dr::Operand::IdRef(maxval),
2803 ];
2804 self.ext_inst(
2805 result_type,
2806 result_id,
2807 extension_set,
2808 crate::spirv::CLOp::s_clamp as spirv::Word,
2809 args,
2810 )
2811 }
2812 #[allow(clippy::too_many_arguments)]
2813 pub fn cl_u_clamp(
2814 &mut self,
2815 result_type: spirv::Word,
2816 x: spirv::Word,
2817 minval: spirv::Word,
2818 maxval: spirv::Word,
2819 ) -> Result<spirv::Word, dr::Error> {
2820 self.cl_u_clamp_id(result_type, None, x, minval, maxval)
2821 }
2822 #[allow(clippy::too_many_arguments)]
2823 pub fn cl_u_clamp_id(
2824 &mut self,
2825 result_type: spirv::Word,
2826 result_id: Option<spirv::Word>,
2827 x: spirv::Word,
2828 minval: spirv::Word,
2829 maxval: spirv::Word,
2830 ) -> Result<spirv::Word, dr::Error> {
2831 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2832 #[allow(unused_mut)]
2833 let mut args = vec![
2834 dr::Operand::IdRef(x),
2835 dr::Operand::IdRef(minval),
2836 dr::Operand::IdRef(maxval),
2837 ];
2838 self.ext_inst(
2839 result_type,
2840 result_id,
2841 extension_set,
2842 crate::spirv::CLOp::u_clamp as spirv::Word,
2843 args,
2844 )
2845 }
2846 #[allow(clippy::too_many_arguments)]
2847 pub fn cl_clz(
2848 &mut self,
2849 result_type: spirv::Word,
2850 x: spirv::Word,
2851 ) -> Result<spirv::Word, dr::Error> {
2852 self.cl_clz_id(result_type, None, x)
2853 }
2854 #[allow(clippy::too_many_arguments)]
2855 pub fn cl_clz_id(
2856 &mut self,
2857 result_type: spirv::Word,
2858 result_id: Option<spirv::Word>,
2859 x: spirv::Word,
2860 ) -> Result<spirv::Word, dr::Error> {
2861 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2862 #[allow(unused_mut)]
2863 let mut args = vec![dr::Operand::IdRef(x)];
2864 self.ext_inst(
2865 result_type,
2866 result_id,
2867 extension_set,
2868 crate::spirv::CLOp::clz as spirv::Word,
2869 args,
2870 )
2871 }
2872 #[allow(clippy::too_many_arguments)]
2873 pub fn cl_ctz(
2874 &mut self,
2875 result_type: spirv::Word,
2876 x: spirv::Word,
2877 ) -> Result<spirv::Word, dr::Error> {
2878 self.cl_ctz_id(result_type, None, x)
2879 }
2880 #[allow(clippy::too_many_arguments)]
2881 pub fn cl_ctz_id(
2882 &mut self,
2883 result_type: spirv::Word,
2884 result_id: Option<spirv::Word>,
2885 x: spirv::Word,
2886 ) -> Result<spirv::Word, dr::Error> {
2887 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2888 #[allow(unused_mut)]
2889 let mut args = vec![dr::Operand::IdRef(x)];
2890 self.ext_inst(
2891 result_type,
2892 result_id,
2893 extension_set,
2894 crate::spirv::CLOp::ctz as spirv::Word,
2895 args,
2896 )
2897 }
2898 #[allow(clippy::too_many_arguments)]
2899 pub fn cl_s_mad_hi(
2900 &mut self,
2901 result_type: spirv::Word,
2902 a: spirv::Word,
2903 b: spirv::Word,
2904 c: spirv::Word,
2905 ) -> Result<spirv::Word, dr::Error> {
2906 self.cl_s_mad_hi_id(result_type, None, a, b, c)
2907 }
2908 #[allow(clippy::too_many_arguments)]
2909 pub fn cl_s_mad_hi_id(
2910 &mut self,
2911 result_type: spirv::Word,
2912 result_id: Option<spirv::Word>,
2913 a: spirv::Word,
2914 b: spirv::Word,
2915 c: spirv::Word,
2916 ) -> Result<spirv::Word, dr::Error> {
2917 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2918 #[allow(unused_mut)]
2919 let mut args = vec![
2920 dr::Operand::IdRef(a),
2921 dr::Operand::IdRef(b),
2922 dr::Operand::IdRef(c),
2923 ];
2924 self.ext_inst(
2925 result_type,
2926 result_id,
2927 extension_set,
2928 crate::spirv::CLOp::s_mad_hi as spirv::Word,
2929 args,
2930 )
2931 }
2932 #[allow(clippy::too_many_arguments)]
2933 pub fn cl_u_mad_sat(
2934 &mut self,
2935 result_type: spirv::Word,
2936 x: spirv::Word,
2937 y: spirv::Word,
2938 z: spirv::Word,
2939 ) -> Result<spirv::Word, dr::Error> {
2940 self.cl_u_mad_sat_id(result_type, None, x, y, z)
2941 }
2942 #[allow(clippy::too_many_arguments)]
2943 pub fn cl_u_mad_sat_id(
2944 &mut self,
2945 result_type: spirv::Word,
2946 result_id: Option<spirv::Word>,
2947 x: spirv::Word,
2948 y: spirv::Word,
2949 z: spirv::Word,
2950 ) -> Result<spirv::Word, dr::Error> {
2951 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2952 #[allow(unused_mut)]
2953 let mut args = vec![
2954 dr::Operand::IdRef(x),
2955 dr::Operand::IdRef(y),
2956 dr::Operand::IdRef(z),
2957 ];
2958 self.ext_inst(
2959 result_type,
2960 result_id,
2961 extension_set,
2962 crate::spirv::CLOp::u_mad_sat as spirv::Word,
2963 args,
2964 )
2965 }
2966 #[allow(clippy::too_many_arguments)]
2967 pub fn cl_s_mad_sat(
2968 &mut self,
2969 result_type: spirv::Word,
2970 x: spirv::Word,
2971 y: spirv::Word,
2972 z: spirv::Word,
2973 ) -> Result<spirv::Word, dr::Error> {
2974 self.cl_s_mad_sat_id(result_type, None, x, y, z)
2975 }
2976 #[allow(clippy::too_many_arguments)]
2977 pub fn cl_s_mad_sat_id(
2978 &mut self,
2979 result_type: spirv::Word,
2980 result_id: Option<spirv::Word>,
2981 x: spirv::Word,
2982 y: spirv::Word,
2983 z: spirv::Word,
2984 ) -> Result<spirv::Word, dr::Error> {
2985 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
2986 #[allow(unused_mut)]
2987 let mut args = vec![
2988 dr::Operand::IdRef(x),
2989 dr::Operand::IdRef(y),
2990 dr::Operand::IdRef(z),
2991 ];
2992 self.ext_inst(
2993 result_type,
2994 result_id,
2995 extension_set,
2996 crate::spirv::CLOp::s_mad_sat as spirv::Word,
2997 args,
2998 )
2999 }
3000 #[allow(clippy::too_many_arguments)]
3001 pub fn cl_s_max(
3002 &mut self,
3003 result_type: spirv::Word,
3004 x: spirv::Word,
3005 y: spirv::Word,
3006 ) -> Result<spirv::Word, dr::Error> {
3007 self.cl_s_max_id(result_type, None, x, y)
3008 }
3009 #[allow(clippy::too_many_arguments)]
3010 pub fn cl_s_max_id(
3011 &mut self,
3012 result_type: spirv::Word,
3013 result_id: Option<spirv::Word>,
3014 x: spirv::Word,
3015 y: spirv::Word,
3016 ) -> Result<spirv::Word, dr::Error> {
3017 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3018 #[allow(unused_mut)]
3019 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
3020 self.ext_inst(
3021 result_type,
3022 result_id,
3023 extension_set,
3024 crate::spirv::CLOp::s_max as spirv::Word,
3025 args,
3026 )
3027 }
3028 #[allow(clippy::too_many_arguments)]
3029 pub fn cl_u_max(
3030 &mut self,
3031 result_type: spirv::Word,
3032 x: spirv::Word,
3033 y: spirv::Word,
3034 ) -> Result<spirv::Word, dr::Error> {
3035 self.cl_u_max_id(result_type, None, x, y)
3036 }
3037 #[allow(clippy::too_many_arguments)]
3038 pub fn cl_u_max_id(
3039 &mut self,
3040 result_type: spirv::Word,
3041 result_id: Option<spirv::Word>,
3042 x: spirv::Word,
3043 y: spirv::Word,
3044 ) -> Result<spirv::Word, dr::Error> {
3045 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3046 #[allow(unused_mut)]
3047 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
3048 self.ext_inst(
3049 result_type,
3050 result_id,
3051 extension_set,
3052 crate::spirv::CLOp::u_max as spirv::Word,
3053 args,
3054 )
3055 }
3056 #[allow(clippy::too_many_arguments)]
3057 pub fn cl_s_min(
3058 &mut self,
3059 result_type: spirv::Word,
3060 x: spirv::Word,
3061 y: spirv::Word,
3062 ) -> Result<spirv::Word, dr::Error> {
3063 self.cl_s_min_id(result_type, None, x, y)
3064 }
3065 #[allow(clippy::too_many_arguments)]
3066 pub fn cl_s_min_id(
3067 &mut self,
3068 result_type: spirv::Word,
3069 result_id: Option<spirv::Word>,
3070 x: spirv::Word,
3071 y: spirv::Word,
3072 ) -> Result<spirv::Word, dr::Error> {
3073 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3074 #[allow(unused_mut)]
3075 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
3076 self.ext_inst(
3077 result_type,
3078 result_id,
3079 extension_set,
3080 crate::spirv::CLOp::s_min as spirv::Word,
3081 args,
3082 )
3083 }
3084 #[allow(clippy::too_many_arguments)]
3085 pub fn cl_u_min(
3086 &mut self,
3087 result_type: spirv::Word,
3088 x: spirv::Word,
3089 y: spirv::Word,
3090 ) -> Result<spirv::Word, dr::Error> {
3091 self.cl_u_min_id(result_type, None, x, y)
3092 }
3093 #[allow(clippy::too_many_arguments)]
3094 pub fn cl_u_min_id(
3095 &mut self,
3096 result_type: spirv::Word,
3097 result_id: Option<spirv::Word>,
3098 x: spirv::Word,
3099 y: spirv::Word,
3100 ) -> Result<spirv::Word, dr::Error> {
3101 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3102 #[allow(unused_mut)]
3103 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
3104 self.ext_inst(
3105 result_type,
3106 result_id,
3107 extension_set,
3108 crate::spirv::CLOp::u_min as spirv::Word,
3109 args,
3110 )
3111 }
3112 #[allow(clippy::too_many_arguments)]
3113 pub fn cl_s_mul_hi(
3114 &mut self,
3115 result_type: spirv::Word,
3116 x: spirv::Word,
3117 y: spirv::Word,
3118 ) -> Result<spirv::Word, dr::Error> {
3119 self.cl_s_mul_hi_id(result_type, None, x, y)
3120 }
3121 #[allow(clippy::too_many_arguments)]
3122 pub fn cl_s_mul_hi_id(
3123 &mut self,
3124 result_type: spirv::Word,
3125 result_id: Option<spirv::Word>,
3126 x: spirv::Word,
3127 y: spirv::Word,
3128 ) -> Result<spirv::Word, dr::Error> {
3129 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3130 #[allow(unused_mut)]
3131 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
3132 self.ext_inst(
3133 result_type,
3134 result_id,
3135 extension_set,
3136 crate::spirv::CLOp::s_mul_hi as spirv::Word,
3137 args,
3138 )
3139 }
3140 #[allow(clippy::too_many_arguments)]
3141 pub fn cl_rotate(
3142 &mut self,
3143 result_type: spirv::Word,
3144 v: spirv::Word,
3145 i: spirv::Word,
3146 ) -> Result<spirv::Word, dr::Error> {
3147 self.cl_rotate_id(result_type, None, v, i)
3148 }
3149 #[allow(clippy::too_many_arguments)]
3150 pub fn cl_rotate_id(
3151 &mut self,
3152 result_type: spirv::Word,
3153 result_id: Option<spirv::Word>,
3154 v: spirv::Word,
3155 i: spirv::Word,
3156 ) -> Result<spirv::Word, dr::Error> {
3157 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3158 #[allow(unused_mut)]
3159 let mut args = vec![dr::Operand::IdRef(v), dr::Operand::IdRef(i)];
3160 self.ext_inst(
3161 result_type,
3162 result_id,
3163 extension_set,
3164 crate::spirv::CLOp::rotate as spirv::Word,
3165 args,
3166 )
3167 }
3168 #[allow(clippy::too_many_arguments)]
3169 pub fn cl_s_sub_sat(
3170 &mut self,
3171 result_type: spirv::Word,
3172 x: spirv::Word,
3173 y: spirv::Word,
3174 ) -> Result<spirv::Word, dr::Error> {
3175 self.cl_s_sub_sat_id(result_type, None, x, y)
3176 }
3177 #[allow(clippy::too_many_arguments)]
3178 pub fn cl_s_sub_sat_id(
3179 &mut self,
3180 result_type: spirv::Word,
3181 result_id: Option<spirv::Word>,
3182 x: spirv::Word,
3183 y: spirv::Word,
3184 ) -> Result<spirv::Word, dr::Error> {
3185 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3186 #[allow(unused_mut)]
3187 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
3188 self.ext_inst(
3189 result_type,
3190 result_id,
3191 extension_set,
3192 crate::spirv::CLOp::s_sub_sat as spirv::Word,
3193 args,
3194 )
3195 }
3196 #[allow(clippy::too_many_arguments)]
3197 pub fn cl_u_sub_sat(
3198 &mut self,
3199 result_type: spirv::Word,
3200 x: spirv::Word,
3201 y: spirv::Word,
3202 ) -> Result<spirv::Word, dr::Error> {
3203 self.cl_u_sub_sat_id(result_type, None, x, y)
3204 }
3205 #[allow(clippy::too_many_arguments)]
3206 pub fn cl_u_sub_sat_id(
3207 &mut self,
3208 result_type: spirv::Word,
3209 result_id: Option<spirv::Word>,
3210 x: spirv::Word,
3211 y: spirv::Word,
3212 ) -> Result<spirv::Word, dr::Error> {
3213 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3214 #[allow(unused_mut)]
3215 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
3216 self.ext_inst(
3217 result_type,
3218 result_id,
3219 extension_set,
3220 crate::spirv::CLOp::u_sub_sat as spirv::Word,
3221 args,
3222 )
3223 }
3224 #[allow(clippy::too_many_arguments)]
3225 pub fn cl_u_upsample(
3226 &mut self,
3227 result_type: spirv::Word,
3228 hi: spirv::Word,
3229 lo: spirv::Word,
3230 ) -> Result<spirv::Word, dr::Error> {
3231 self.cl_u_upsample_id(result_type, None, hi, lo)
3232 }
3233 #[allow(clippy::too_many_arguments)]
3234 pub fn cl_u_upsample_id(
3235 &mut self,
3236 result_type: spirv::Word,
3237 result_id: Option<spirv::Word>,
3238 hi: spirv::Word,
3239 lo: spirv::Word,
3240 ) -> Result<spirv::Word, dr::Error> {
3241 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3242 #[allow(unused_mut)]
3243 let mut args = vec![dr::Operand::IdRef(hi), dr::Operand::IdRef(lo)];
3244 self.ext_inst(
3245 result_type,
3246 result_id,
3247 extension_set,
3248 crate::spirv::CLOp::u_upsample as spirv::Word,
3249 args,
3250 )
3251 }
3252 #[allow(clippy::too_many_arguments)]
3253 pub fn cl_s_upsample(
3254 &mut self,
3255 result_type: spirv::Word,
3256 hi: spirv::Word,
3257 lo: spirv::Word,
3258 ) -> Result<spirv::Word, dr::Error> {
3259 self.cl_s_upsample_id(result_type, None, hi, lo)
3260 }
3261 #[allow(clippy::too_many_arguments)]
3262 pub fn cl_s_upsample_id(
3263 &mut self,
3264 result_type: spirv::Word,
3265 result_id: Option<spirv::Word>,
3266 hi: spirv::Word,
3267 lo: spirv::Word,
3268 ) -> Result<spirv::Word, dr::Error> {
3269 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3270 #[allow(unused_mut)]
3271 let mut args = vec![dr::Operand::IdRef(hi), dr::Operand::IdRef(lo)];
3272 self.ext_inst(
3273 result_type,
3274 result_id,
3275 extension_set,
3276 crate::spirv::CLOp::s_upsample as spirv::Word,
3277 args,
3278 )
3279 }
3280 #[allow(clippy::too_many_arguments)]
3281 pub fn cl_popcount(
3282 &mut self,
3283 result_type: spirv::Word,
3284 x: spirv::Word,
3285 ) -> Result<spirv::Word, dr::Error> {
3286 self.cl_popcount_id(result_type, None, x)
3287 }
3288 #[allow(clippy::too_many_arguments)]
3289 pub fn cl_popcount_id(
3290 &mut self,
3291 result_type: spirv::Word,
3292 result_id: Option<spirv::Word>,
3293 x: spirv::Word,
3294 ) -> Result<spirv::Word, dr::Error> {
3295 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3296 #[allow(unused_mut)]
3297 let mut args = vec![dr::Operand::IdRef(x)];
3298 self.ext_inst(
3299 result_type,
3300 result_id,
3301 extension_set,
3302 crate::spirv::CLOp::popcount as spirv::Word,
3303 args,
3304 )
3305 }
3306 #[allow(clippy::too_many_arguments)]
3307 pub fn cl_s_mad24(
3308 &mut self,
3309 result_type: spirv::Word,
3310 x: spirv::Word,
3311 y: spirv::Word,
3312 z: spirv::Word,
3313 ) -> Result<spirv::Word, dr::Error> {
3314 self.cl_s_mad24_id(result_type, None, x, y, z)
3315 }
3316 #[allow(clippy::too_many_arguments)]
3317 pub fn cl_s_mad24_id(
3318 &mut self,
3319 result_type: spirv::Word,
3320 result_id: Option<spirv::Word>,
3321 x: spirv::Word,
3322 y: spirv::Word,
3323 z: spirv::Word,
3324 ) -> Result<spirv::Word, dr::Error> {
3325 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3326 #[allow(unused_mut)]
3327 let mut args = vec![
3328 dr::Operand::IdRef(x),
3329 dr::Operand::IdRef(y),
3330 dr::Operand::IdRef(z),
3331 ];
3332 self.ext_inst(
3333 result_type,
3334 result_id,
3335 extension_set,
3336 crate::spirv::CLOp::s_mad24 as spirv::Word,
3337 args,
3338 )
3339 }
3340 #[allow(clippy::too_many_arguments)]
3341 pub fn cl_u_mad24(
3342 &mut self,
3343 result_type: spirv::Word,
3344 x: spirv::Word,
3345 y: spirv::Word,
3346 z: spirv::Word,
3347 ) -> Result<spirv::Word, dr::Error> {
3348 self.cl_u_mad24_id(result_type, None, x, y, z)
3349 }
3350 #[allow(clippy::too_many_arguments)]
3351 pub fn cl_u_mad24_id(
3352 &mut self,
3353 result_type: spirv::Word,
3354 result_id: Option<spirv::Word>,
3355 x: spirv::Word,
3356 y: spirv::Word,
3357 z: spirv::Word,
3358 ) -> Result<spirv::Word, dr::Error> {
3359 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3360 #[allow(unused_mut)]
3361 let mut args = vec![
3362 dr::Operand::IdRef(x),
3363 dr::Operand::IdRef(y),
3364 dr::Operand::IdRef(z),
3365 ];
3366 self.ext_inst(
3367 result_type,
3368 result_id,
3369 extension_set,
3370 crate::spirv::CLOp::u_mad24 as spirv::Word,
3371 args,
3372 )
3373 }
3374 #[allow(clippy::too_many_arguments)]
3375 pub fn cl_s_mul24(
3376 &mut self,
3377 result_type: spirv::Word,
3378 x: spirv::Word,
3379 y: spirv::Word,
3380 ) -> Result<spirv::Word, dr::Error> {
3381 self.cl_s_mul24_id(result_type, None, x, y)
3382 }
3383 #[allow(clippy::too_many_arguments)]
3384 pub fn cl_s_mul24_id(
3385 &mut self,
3386 result_type: spirv::Word,
3387 result_id: Option<spirv::Word>,
3388 x: spirv::Word,
3389 y: spirv::Word,
3390 ) -> Result<spirv::Word, dr::Error> {
3391 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3392 #[allow(unused_mut)]
3393 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
3394 self.ext_inst(
3395 result_type,
3396 result_id,
3397 extension_set,
3398 crate::spirv::CLOp::s_mul24 as spirv::Word,
3399 args,
3400 )
3401 }
3402 #[allow(clippy::too_many_arguments)]
3403 pub fn cl_u_mul24(
3404 &mut self,
3405 result_type: spirv::Word,
3406 x: spirv::Word,
3407 y: spirv::Word,
3408 ) -> Result<spirv::Word, dr::Error> {
3409 self.cl_u_mul24_id(result_type, None, x, y)
3410 }
3411 #[allow(clippy::too_many_arguments)]
3412 pub fn cl_u_mul24_id(
3413 &mut self,
3414 result_type: spirv::Word,
3415 result_id: Option<spirv::Word>,
3416 x: spirv::Word,
3417 y: spirv::Word,
3418 ) -> Result<spirv::Word, dr::Error> {
3419 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3420 #[allow(unused_mut)]
3421 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
3422 self.ext_inst(
3423 result_type,
3424 result_id,
3425 extension_set,
3426 crate::spirv::CLOp::u_mul24 as spirv::Word,
3427 args,
3428 )
3429 }
3430 #[allow(clippy::too_many_arguments)]
3431 pub fn cl_u_abs(
3432 &mut self,
3433 result_type: spirv::Word,
3434 x: spirv::Word,
3435 ) -> Result<spirv::Word, dr::Error> {
3436 self.cl_u_abs_id(result_type, None, x)
3437 }
3438 #[allow(clippy::too_many_arguments)]
3439 pub fn cl_u_abs_id(
3440 &mut self,
3441 result_type: spirv::Word,
3442 result_id: Option<spirv::Word>,
3443 x: spirv::Word,
3444 ) -> Result<spirv::Word, dr::Error> {
3445 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3446 #[allow(unused_mut)]
3447 let mut args = vec![dr::Operand::IdRef(x)];
3448 self.ext_inst(
3449 result_type,
3450 result_id,
3451 extension_set,
3452 crate::spirv::CLOp::u_abs as spirv::Word,
3453 args,
3454 )
3455 }
3456 #[allow(clippy::too_many_arguments)]
3457 pub fn cl_u_abs_diff(
3458 &mut self,
3459 result_type: spirv::Word,
3460 x: spirv::Word,
3461 y: spirv::Word,
3462 ) -> Result<spirv::Word, dr::Error> {
3463 self.cl_u_abs_diff_id(result_type, None, x, y)
3464 }
3465 #[allow(clippy::too_many_arguments)]
3466 pub fn cl_u_abs_diff_id(
3467 &mut self,
3468 result_type: spirv::Word,
3469 result_id: Option<spirv::Word>,
3470 x: spirv::Word,
3471 y: spirv::Word,
3472 ) -> Result<spirv::Word, dr::Error> {
3473 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3474 #[allow(unused_mut)]
3475 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
3476 self.ext_inst(
3477 result_type,
3478 result_id,
3479 extension_set,
3480 crate::spirv::CLOp::u_abs_diff as spirv::Word,
3481 args,
3482 )
3483 }
3484 #[allow(clippy::too_many_arguments)]
3485 pub fn cl_u_mul_hi(
3486 &mut self,
3487 result_type: spirv::Word,
3488 x: spirv::Word,
3489 y: spirv::Word,
3490 ) -> Result<spirv::Word, dr::Error> {
3491 self.cl_u_mul_hi_id(result_type, None, x, y)
3492 }
3493 #[allow(clippy::too_many_arguments)]
3494 pub fn cl_u_mul_hi_id(
3495 &mut self,
3496 result_type: spirv::Word,
3497 result_id: Option<spirv::Word>,
3498 x: spirv::Word,
3499 y: spirv::Word,
3500 ) -> Result<spirv::Word, dr::Error> {
3501 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3502 #[allow(unused_mut)]
3503 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
3504 self.ext_inst(
3505 result_type,
3506 result_id,
3507 extension_set,
3508 crate::spirv::CLOp::u_mul_hi as spirv::Word,
3509 args,
3510 )
3511 }
3512 #[allow(clippy::too_many_arguments)]
3513 pub fn cl_u_mad_hi(
3514 &mut self,
3515 result_type: spirv::Word,
3516 a: spirv::Word,
3517 b: spirv::Word,
3518 c: spirv::Word,
3519 ) -> Result<spirv::Word, dr::Error> {
3520 self.cl_u_mad_hi_id(result_type, None, a, b, c)
3521 }
3522 #[allow(clippy::too_many_arguments)]
3523 pub fn cl_u_mad_hi_id(
3524 &mut self,
3525 result_type: spirv::Word,
3526 result_id: Option<spirv::Word>,
3527 a: spirv::Word,
3528 b: spirv::Word,
3529 c: spirv::Word,
3530 ) -> Result<spirv::Word, dr::Error> {
3531 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3532 #[allow(unused_mut)]
3533 let mut args = vec![
3534 dr::Operand::IdRef(a),
3535 dr::Operand::IdRef(b),
3536 dr::Operand::IdRef(c),
3537 ];
3538 self.ext_inst(
3539 result_type,
3540 result_id,
3541 extension_set,
3542 crate::spirv::CLOp::u_mad_hi as spirv::Word,
3543 args,
3544 )
3545 }
3546 #[allow(clippy::too_many_arguments)]
3547 pub fn cl_fclamp(
3548 &mut self,
3549 result_type: spirv::Word,
3550 x: spirv::Word,
3551 minval: spirv::Word,
3552 maxval: spirv::Word,
3553 ) -> Result<spirv::Word, dr::Error> {
3554 self.cl_fclamp_id(result_type, None, x, minval, maxval)
3555 }
3556 #[allow(clippy::too_many_arguments)]
3557 pub fn cl_fclamp_id(
3558 &mut self,
3559 result_type: spirv::Word,
3560 result_id: Option<spirv::Word>,
3561 x: spirv::Word,
3562 minval: spirv::Word,
3563 maxval: spirv::Word,
3564 ) -> Result<spirv::Word, dr::Error> {
3565 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3566 #[allow(unused_mut)]
3567 let mut args = vec![
3568 dr::Operand::IdRef(x),
3569 dr::Operand::IdRef(minval),
3570 dr::Operand::IdRef(maxval),
3571 ];
3572 self.ext_inst(
3573 result_type,
3574 result_id,
3575 extension_set,
3576 crate::spirv::CLOp::fclamp as spirv::Word,
3577 args,
3578 )
3579 }
3580 #[allow(clippy::too_many_arguments)]
3581 pub fn cl_degrees(
3582 &mut self,
3583 result_type: spirv::Word,
3584 radians: spirv::Word,
3585 ) -> Result<spirv::Word, dr::Error> {
3586 self.cl_degrees_id(result_type, None, radians)
3587 }
3588 #[allow(clippy::too_many_arguments)]
3589 pub fn cl_degrees_id(
3590 &mut self,
3591 result_type: spirv::Word,
3592 result_id: Option<spirv::Word>,
3593 radians: spirv::Word,
3594 ) -> Result<spirv::Word, dr::Error> {
3595 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3596 #[allow(unused_mut)]
3597 let mut args = vec![dr::Operand::IdRef(radians)];
3598 self.ext_inst(
3599 result_type,
3600 result_id,
3601 extension_set,
3602 crate::spirv::CLOp::degrees as spirv::Word,
3603 args,
3604 )
3605 }
3606 #[allow(clippy::too_many_arguments)]
3607 pub fn cl_fmax_common(
3608 &mut self,
3609 result_type: spirv::Word,
3610 x: spirv::Word,
3611 y: spirv::Word,
3612 ) -> Result<spirv::Word, dr::Error> {
3613 self.cl_fmax_common_id(result_type, None, x, y)
3614 }
3615 #[allow(clippy::too_many_arguments)]
3616 pub fn cl_fmax_common_id(
3617 &mut self,
3618 result_type: spirv::Word,
3619 result_id: Option<spirv::Word>,
3620 x: spirv::Word,
3621 y: spirv::Word,
3622 ) -> Result<spirv::Word, dr::Error> {
3623 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3624 #[allow(unused_mut)]
3625 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
3626 self.ext_inst(
3627 result_type,
3628 result_id,
3629 extension_set,
3630 crate::spirv::CLOp::fmax_common as spirv::Word,
3631 args,
3632 )
3633 }
3634 #[allow(clippy::too_many_arguments)]
3635 pub fn cl_fmin_common(
3636 &mut self,
3637 result_type: spirv::Word,
3638 x: spirv::Word,
3639 y: spirv::Word,
3640 ) -> Result<spirv::Word, dr::Error> {
3641 self.cl_fmin_common_id(result_type, None, x, y)
3642 }
3643 #[allow(clippy::too_many_arguments)]
3644 pub fn cl_fmin_common_id(
3645 &mut self,
3646 result_type: spirv::Word,
3647 result_id: Option<spirv::Word>,
3648 x: spirv::Word,
3649 y: spirv::Word,
3650 ) -> Result<spirv::Word, dr::Error> {
3651 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3652 #[allow(unused_mut)]
3653 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
3654 self.ext_inst(
3655 result_type,
3656 result_id,
3657 extension_set,
3658 crate::spirv::CLOp::fmin_common as spirv::Word,
3659 args,
3660 )
3661 }
3662 #[allow(clippy::too_many_arguments)]
3663 pub fn cl_mix(
3664 &mut self,
3665 result_type: spirv::Word,
3666 x: spirv::Word,
3667 y: spirv::Word,
3668 a: spirv::Word,
3669 ) -> Result<spirv::Word, dr::Error> {
3670 self.cl_mix_id(result_type, None, x, y, a)
3671 }
3672 #[allow(clippy::too_many_arguments)]
3673 pub fn cl_mix_id(
3674 &mut self,
3675 result_type: spirv::Word,
3676 result_id: Option<spirv::Word>,
3677 x: spirv::Word,
3678 y: spirv::Word,
3679 a: spirv::Word,
3680 ) -> Result<spirv::Word, dr::Error> {
3681 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3682 #[allow(unused_mut)]
3683 let mut args = vec![
3684 dr::Operand::IdRef(x),
3685 dr::Operand::IdRef(y),
3686 dr::Operand::IdRef(a),
3687 ];
3688 self.ext_inst(
3689 result_type,
3690 result_id,
3691 extension_set,
3692 crate::spirv::CLOp::mix as spirv::Word,
3693 args,
3694 )
3695 }
3696 #[allow(clippy::too_many_arguments)]
3697 pub fn cl_radians(
3698 &mut self,
3699 result_type: spirv::Word,
3700 degrees: spirv::Word,
3701 ) -> Result<spirv::Word, dr::Error> {
3702 self.cl_radians_id(result_type, None, degrees)
3703 }
3704 #[allow(clippy::too_many_arguments)]
3705 pub fn cl_radians_id(
3706 &mut self,
3707 result_type: spirv::Word,
3708 result_id: Option<spirv::Word>,
3709 degrees: spirv::Word,
3710 ) -> Result<spirv::Word, dr::Error> {
3711 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3712 #[allow(unused_mut)]
3713 let mut args = vec![dr::Operand::IdRef(degrees)];
3714 self.ext_inst(
3715 result_type,
3716 result_id,
3717 extension_set,
3718 crate::spirv::CLOp::radians as spirv::Word,
3719 args,
3720 )
3721 }
3722 #[allow(clippy::too_many_arguments)]
3723 pub fn cl_step(
3724 &mut self,
3725 result_type: spirv::Word,
3726 edge: spirv::Word,
3727 x: spirv::Word,
3728 ) -> Result<spirv::Word, dr::Error> {
3729 self.cl_step_id(result_type, None, edge, x)
3730 }
3731 #[allow(clippy::too_many_arguments)]
3732 pub fn cl_step_id(
3733 &mut self,
3734 result_type: spirv::Word,
3735 result_id: Option<spirv::Word>,
3736 edge: spirv::Word,
3737 x: spirv::Word,
3738 ) -> Result<spirv::Word, dr::Error> {
3739 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3740 #[allow(unused_mut)]
3741 let mut args = vec![dr::Operand::IdRef(edge), dr::Operand::IdRef(x)];
3742 self.ext_inst(
3743 result_type,
3744 result_id,
3745 extension_set,
3746 crate::spirv::CLOp::step as spirv::Word,
3747 args,
3748 )
3749 }
3750 #[allow(clippy::too_many_arguments)]
3751 pub fn cl_smoothstep(
3752 &mut self,
3753 result_type: spirv::Word,
3754 edge0: spirv::Word,
3755 edge1: spirv::Word,
3756 x: spirv::Word,
3757 ) -> Result<spirv::Word, dr::Error> {
3758 self.cl_smoothstep_id(result_type, None, edge0, edge1, x)
3759 }
3760 #[allow(clippy::too_many_arguments)]
3761 pub fn cl_smoothstep_id(
3762 &mut self,
3763 result_type: spirv::Word,
3764 result_id: Option<spirv::Word>,
3765 edge0: spirv::Word,
3766 edge1: spirv::Word,
3767 x: spirv::Word,
3768 ) -> Result<spirv::Word, dr::Error> {
3769 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3770 #[allow(unused_mut)]
3771 let mut args = vec![
3772 dr::Operand::IdRef(edge0),
3773 dr::Operand::IdRef(edge1),
3774 dr::Operand::IdRef(x),
3775 ];
3776 self.ext_inst(
3777 result_type,
3778 result_id,
3779 extension_set,
3780 crate::spirv::CLOp::smoothstep as spirv::Word,
3781 args,
3782 )
3783 }
3784 #[allow(clippy::too_many_arguments)]
3785 pub fn cl_sign(
3786 &mut self,
3787 result_type: spirv::Word,
3788 x: spirv::Word,
3789 ) -> Result<spirv::Word, dr::Error> {
3790 self.cl_sign_id(result_type, None, x)
3791 }
3792 #[allow(clippy::too_many_arguments)]
3793 pub fn cl_sign_id(
3794 &mut self,
3795 result_type: spirv::Word,
3796 result_id: Option<spirv::Word>,
3797 x: spirv::Word,
3798 ) -> Result<spirv::Word, dr::Error> {
3799 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3800 #[allow(unused_mut)]
3801 let mut args = vec![dr::Operand::IdRef(x)];
3802 self.ext_inst(
3803 result_type,
3804 result_id,
3805 extension_set,
3806 crate::spirv::CLOp::sign as spirv::Word,
3807 args,
3808 )
3809 }
3810 #[allow(clippy::too_many_arguments)]
3811 pub fn cl_cross(
3812 &mut self,
3813 result_type: spirv::Word,
3814 p0: spirv::Word,
3815 p1: spirv::Word,
3816 ) -> Result<spirv::Word, dr::Error> {
3817 self.cl_cross_id(result_type, None, p0, p1)
3818 }
3819 #[allow(clippy::too_many_arguments)]
3820 pub fn cl_cross_id(
3821 &mut self,
3822 result_type: spirv::Word,
3823 result_id: Option<spirv::Word>,
3824 p0: spirv::Word,
3825 p1: spirv::Word,
3826 ) -> Result<spirv::Word, dr::Error> {
3827 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3828 #[allow(unused_mut)]
3829 let mut args = vec![dr::Operand::IdRef(p0), dr::Operand::IdRef(p1)];
3830 self.ext_inst(
3831 result_type,
3832 result_id,
3833 extension_set,
3834 crate::spirv::CLOp::cross as spirv::Word,
3835 args,
3836 )
3837 }
3838 #[allow(clippy::too_many_arguments)]
3839 pub fn cl_distance(
3840 &mut self,
3841 result_type: spirv::Word,
3842 p0: spirv::Word,
3843 p1: spirv::Word,
3844 ) -> Result<spirv::Word, dr::Error> {
3845 self.cl_distance_id(result_type, None, p0, p1)
3846 }
3847 #[allow(clippy::too_many_arguments)]
3848 pub fn cl_distance_id(
3849 &mut self,
3850 result_type: spirv::Word,
3851 result_id: Option<spirv::Word>,
3852 p0: spirv::Word,
3853 p1: spirv::Word,
3854 ) -> Result<spirv::Word, dr::Error> {
3855 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3856 #[allow(unused_mut)]
3857 let mut args = vec![dr::Operand::IdRef(p0), dr::Operand::IdRef(p1)];
3858 self.ext_inst(
3859 result_type,
3860 result_id,
3861 extension_set,
3862 crate::spirv::CLOp::distance as spirv::Word,
3863 args,
3864 )
3865 }
3866 #[allow(clippy::too_many_arguments)]
3867 pub fn cl_length(
3868 &mut self,
3869 result_type: spirv::Word,
3870 p: spirv::Word,
3871 ) -> Result<spirv::Word, dr::Error> {
3872 self.cl_length_id(result_type, None, p)
3873 }
3874 #[allow(clippy::too_many_arguments)]
3875 pub fn cl_length_id(
3876 &mut self,
3877 result_type: spirv::Word,
3878 result_id: Option<spirv::Word>,
3879 p: spirv::Word,
3880 ) -> Result<spirv::Word, dr::Error> {
3881 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3882 #[allow(unused_mut)]
3883 let mut args = vec![dr::Operand::IdRef(p)];
3884 self.ext_inst(
3885 result_type,
3886 result_id,
3887 extension_set,
3888 crate::spirv::CLOp::length as spirv::Word,
3889 args,
3890 )
3891 }
3892 #[allow(clippy::too_many_arguments)]
3893 pub fn cl_normalize(
3894 &mut self,
3895 result_type: spirv::Word,
3896 p: spirv::Word,
3897 ) -> Result<spirv::Word, dr::Error> {
3898 self.cl_normalize_id(result_type, None, p)
3899 }
3900 #[allow(clippy::too_many_arguments)]
3901 pub fn cl_normalize_id(
3902 &mut self,
3903 result_type: spirv::Word,
3904 result_id: Option<spirv::Word>,
3905 p: spirv::Word,
3906 ) -> Result<spirv::Word, dr::Error> {
3907 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3908 #[allow(unused_mut)]
3909 let mut args = vec![dr::Operand::IdRef(p)];
3910 self.ext_inst(
3911 result_type,
3912 result_id,
3913 extension_set,
3914 crate::spirv::CLOp::normalize as spirv::Word,
3915 args,
3916 )
3917 }
3918 #[allow(clippy::too_many_arguments)]
3919 pub fn cl_fast_distance(
3920 &mut self,
3921 result_type: spirv::Word,
3922 p0: spirv::Word,
3923 p1: spirv::Word,
3924 ) -> Result<spirv::Word, dr::Error> {
3925 self.cl_fast_distance_id(result_type, None, p0, p1)
3926 }
3927 #[allow(clippy::too_many_arguments)]
3928 pub fn cl_fast_distance_id(
3929 &mut self,
3930 result_type: spirv::Word,
3931 result_id: Option<spirv::Word>,
3932 p0: spirv::Word,
3933 p1: spirv::Word,
3934 ) -> Result<spirv::Word, dr::Error> {
3935 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3936 #[allow(unused_mut)]
3937 let mut args = vec![dr::Operand::IdRef(p0), dr::Operand::IdRef(p1)];
3938 self.ext_inst(
3939 result_type,
3940 result_id,
3941 extension_set,
3942 crate::spirv::CLOp::fast_distance as spirv::Word,
3943 args,
3944 )
3945 }
3946 #[allow(clippy::too_many_arguments)]
3947 pub fn cl_fast_length(
3948 &mut self,
3949 result_type: spirv::Word,
3950 p: spirv::Word,
3951 ) -> Result<spirv::Word, dr::Error> {
3952 self.cl_fast_length_id(result_type, None, p)
3953 }
3954 #[allow(clippy::too_many_arguments)]
3955 pub fn cl_fast_length_id(
3956 &mut self,
3957 result_type: spirv::Word,
3958 result_id: Option<spirv::Word>,
3959 p: spirv::Word,
3960 ) -> Result<spirv::Word, dr::Error> {
3961 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3962 #[allow(unused_mut)]
3963 let mut args = vec![dr::Operand::IdRef(p)];
3964 self.ext_inst(
3965 result_type,
3966 result_id,
3967 extension_set,
3968 crate::spirv::CLOp::fast_length as spirv::Word,
3969 args,
3970 )
3971 }
3972 #[allow(clippy::too_many_arguments)]
3973 pub fn cl_fast_normalize(
3974 &mut self,
3975 result_type: spirv::Word,
3976 p: spirv::Word,
3977 ) -> Result<spirv::Word, dr::Error> {
3978 self.cl_fast_normalize_id(result_type, None, p)
3979 }
3980 #[allow(clippy::too_many_arguments)]
3981 pub fn cl_fast_normalize_id(
3982 &mut self,
3983 result_type: spirv::Word,
3984 result_id: Option<spirv::Word>,
3985 p: spirv::Word,
3986 ) -> Result<spirv::Word, dr::Error> {
3987 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
3988 #[allow(unused_mut)]
3989 let mut args = vec![dr::Operand::IdRef(p)];
3990 self.ext_inst(
3991 result_type,
3992 result_id,
3993 extension_set,
3994 crate::spirv::CLOp::fast_normalize as spirv::Word,
3995 args,
3996 )
3997 }
3998 #[allow(clippy::too_many_arguments)]
3999 pub fn cl_bitselect(
4000 &mut self,
4001 result_type: spirv::Word,
4002 a: spirv::Word,
4003 b: spirv::Word,
4004 c: spirv::Word,
4005 ) -> Result<spirv::Word, dr::Error> {
4006 self.cl_bitselect_id(result_type, None, a, b, c)
4007 }
4008 #[allow(clippy::too_many_arguments)]
4009 pub fn cl_bitselect_id(
4010 &mut self,
4011 result_type: spirv::Word,
4012 result_id: Option<spirv::Word>,
4013 a: spirv::Word,
4014 b: spirv::Word,
4015 c: spirv::Word,
4016 ) -> Result<spirv::Word, dr::Error> {
4017 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
4018 #[allow(unused_mut)]
4019 let mut args = vec![
4020 dr::Operand::IdRef(a),
4021 dr::Operand::IdRef(b),
4022 dr::Operand::IdRef(c),
4023 ];
4024 self.ext_inst(
4025 result_type,
4026 result_id,
4027 extension_set,
4028 crate::spirv::CLOp::bitselect as spirv::Word,
4029 args,
4030 )
4031 }
4032 #[allow(clippy::too_many_arguments)]
4033 pub fn cl_select(
4034 &mut self,
4035 result_type: spirv::Word,
4036 a: spirv::Word,
4037 b: spirv::Word,
4038 c: spirv::Word,
4039 ) -> Result<spirv::Word, dr::Error> {
4040 self.cl_select_id(result_type, None, a, b, c)
4041 }
4042 #[allow(clippy::too_many_arguments)]
4043 pub fn cl_select_id(
4044 &mut self,
4045 result_type: spirv::Word,
4046 result_id: Option<spirv::Word>,
4047 a: spirv::Word,
4048 b: spirv::Word,
4049 c: spirv::Word,
4050 ) -> Result<spirv::Word, dr::Error> {
4051 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
4052 #[allow(unused_mut)]
4053 let mut args = vec![
4054 dr::Operand::IdRef(a),
4055 dr::Operand::IdRef(b),
4056 dr::Operand::IdRef(c),
4057 ];
4058 self.ext_inst(
4059 result_type,
4060 result_id,
4061 extension_set,
4062 crate::spirv::CLOp::select as spirv::Word,
4063 args,
4064 )
4065 }
4066 #[allow(clippy::too_many_arguments)]
4067 pub fn cl_vloadn(
4068 &mut self,
4069 result_type: spirv::Word,
4070 offset: spirv::Word,
4071 p: spirv::Word,
4072 n: u32,
4073 ) -> Result<spirv::Word, dr::Error> {
4074 self.cl_vloadn_id(result_type, None, offset, p, n)
4075 }
4076 #[allow(clippy::too_many_arguments)]
4077 pub fn cl_vloadn_id(
4078 &mut self,
4079 result_type: spirv::Word,
4080 result_id: Option<spirv::Word>,
4081 offset: spirv::Word,
4082 p: spirv::Word,
4083 n: u32,
4084 ) -> Result<spirv::Word, dr::Error> {
4085 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
4086 #[allow(unused_mut)]
4087 let mut args = vec![
4088 dr::Operand::IdRef(offset),
4089 dr::Operand::IdRef(p),
4090 dr::Operand::LiteralBit32(n),
4091 ];
4092 self.ext_inst(
4093 result_type,
4094 result_id,
4095 extension_set,
4096 crate::spirv::CLOp::vloadn as spirv::Word,
4097 args,
4098 )
4099 }
4100 #[allow(clippy::too_many_arguments)]
4101 pub fn cl_vstoren(
4102 &mut self,
4103 result_type: spirv::Word,
4104 data: spirv::Word,
4105 offset: spirv::Word,
4106 p: spirv::Word,
4107 ) -> Result<spirv::Word, dr::Error> {
4108 self.cl_vstoren_id(result_type, None, data, offset, p)
4109 }
4110 #[allow(clippy::too_many_arguments)]
4111 pub fn cl_vstoren_id(
4112 &mut self,
4113 result_type: spirv::Word,
4114 result_id: Option<spirv::Word>,
4115 data: spirv::Word,
4116 offset: spirv::Word,
4117 p: spirv::Word,
4118 ) -> Result<spirv::Word, dr::Error> {
4119 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
4120 #[allow(unused_mut)]
4121 let mut args = vec![
4122 dr::Operand::IdRef(data),
4123 dr::Operand::IdRef(offset),
4124 dr::Operand::IdRef(p),
4125 ];
4126 self.ext_inst(
4127 result_type,
4128 result_id,
4129 extension_set,
4130 crate::spirv::CLOp::vstoren as spirv::Word,
4131 args,
4132 )
4133 }
4134 #[allow(clippy::too_many_arguments)]
4135 pub fn cl_vload_half(
4136 &mut self,
4137 result_type: spirv::Word,
4138 offset: spirv::Word,
4139 p: spirv::Word,
4140 ) -> Result<spirv::Word, dr::Error> {
4141 self.cl_vload_half_id(result_type, None, offset, p)
4142 }
4143 #[allow(clippy::too_many_arguments)]
4144 pub fn cl_vload_half_id(
4145 &mut self,
4146 result_type: spirv::Word,
4147 result_id: Option<spirv::Word>,
4148 offset: spirv::Word,
4149 p: spirv::Word,
4150 ) -> Result<spirv::Word, dr::Error> {
4151 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
4152 #[allow(unused_mut)]
4153 let mut args = vec![dr::Operand::IdRef(offset), dr::Operand::IdRef(p)];
4154 self.ext_inst(
4155 result_type,
4156 result_id,
4157 extension_set,
4158 crate::spirv::CLOp::vload_half as spirv::Word,
4159 args,
4160 )
4161 }
4162 #[allow(clippy::too_many_arguments)]
4163 pub fn cl_vload_halfn(
4164 &mut self,
4165 result_type: spirv::Word,
4166 offset: spirv::Word,
4167 p: spirv::Word,
4168 n: u32,
4169 ) -> Result<spirv::Word, dr::Error> {
4170 self.cl_vload_halfn_id(result_type, None, offset, p, n)
4171 }
4172 #[allow(clippy::too_many_arguments)]
4173 pub fn cl_vload_halfn_id(
4174 &mut self,
4175 result_type: spirv::Word,
4176 result_id: Option<spirv::Word>,
4177 offset: spirv::Word,
4178 p: spirv::Word,
4179 n: u32,
4180 ) -> Result<spirv::Word, dr::Error> {
4181 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
4182 #[allow(unused_mut)]
4183 let mut args = vec![
4184 dr::Operand::IdRef(offset),
4185 dr::Operand::IdRef(p),
4186 dr::Operand::LiteralBit32(n),
4187 ];
4188 self.ext_inst(
4189 result_type,
4190 result_id,
4191 extension_set,
4192 crate::spirv::CLOp::vload_halfn as spirv::Word,
4193 args,
4194 )
4195 }
4196 #[allow(clippy::too_many_arguments)]
4197 pub fn cl_vstore_half(
4198 &mut self,
4199 result_type: spirv::Word,
4200 data: spirv::Word,
4201 offset: spirv::Word,
4202 p: spirv::Word,
4203 ) -> Result<spirv::Word, dr::Error> {
4204 self.cl_vstore_half_id(result_type, None, data, offset, p)
4205 }
4206 #[allow(clippy::too_many_arguments)]
4207 pub fn cl_vstore_half_id(
4208 &mut self,
4209 result_type: spirv::Word,
4210 result_id: Option<spirv::Word>,
4211 data: spirv::Word,
4212 offset: spirv::Word,
4213 p: spirv::Word,
4214 ) -> Result<spirv::Word, dr::Error> {
4215 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
4216 #[allow(unused_mut)]
4217 let mut args = vec![
4218 dr::Operand::IdRef(data),
4219 dr::Operand::IdRef(offset),
4220 dr::Operand::IdRef(p),
4221 ];
4222 self.ext_inst(
4223 result_type,
4224 result_id,
4225 extension_set,
4226 crate::spirv::CLOp::vstore_half as spirv::Word,
4227 args,
4228 )
4229 }
4230 #[allow(clippy::too_many_arguments)]
4231 pub fn cl_vstore_half_r(
4232 &mut self,
4233 result_type: spirv::Word,
4234 data: spirv::Word,
4235 offset: spirv::Word,
4236 p: spirv::Word,
4237 mode: spirv::FPRoundingMode,
4238 ) -> Result<spirv::Word, dr::Error> {
4239 self.cl_vstore_half_r_id(result_type, None, data, offset, p, mode)
4240 }
4241 #[allow(clippy::too_many_arguments)]
4242 pub fn cl_vstore_half_r_id(
4243 &mut self,
4244 result_type: spirv::Word,
4245 result_id: Option<spirv::Word>,
4246 data: spirv::Word,
4247 offset: spirv::Word,
4248 p: spirv::Word,
4249 mode: spirv::FPRoundingMode,
4250 ) -> Result<spirv::Word, dr::Error> {
4251 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
4252 #[allow(unused_mut)]
4253 let mut args = vec![
4254 dr::Operand::IdRef(data),
4255 dr::Operand::IdRef(offset),
4256 dr::Operand::IdRef(p),
4257 dr::Operand::FPRoundingMode(mode),
4258 ];
4259 self.ext_inst(
4260 result_type,
4261 result_id,
4262 extension_set,
4263 crate::spirv::CLOp::vstore_half_r as spirv::Word,
4264 args,
4265 )
4266 }
4267 #[allow(clippy::too_many_arguments)]
4268 pub fn cl_vstore_halfn(
4269 &mut self,
4270 result_type: spirv::Word,
4271 data: spirv::Word,
4272 offset: spirv::Word,
4273 p: spirv::Word,
4274 ) -> Result<spirv::Word, dr::Error> {
4275 self.cl_vstore_halfn_id(result_type, None, data, offset, p)
4276 }
4277 #[allow(clippy::too_many_arguments)]
4278 pub fn cl_vstore_halfn_id(
4279 &mut self,
4280 result_type: spirv::Word,
4281 result_id: Option<spirv::Word>,
4282 data: spirv::Word,
4283 offset: spirv::Word,
4284 p: spirv::Word,
4285 ) -> Result<spirv::Word, dr::Error> {
4286 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
4287 #[allow(unused_mut)]
4288 let mut args = vec![
4289 dr::Operand::IdRef(data),
4290 dr::Operand::IdRef(offset),
4291 dr::Operand::IdRef(p),
4292 ];
4293 self.ext_inst(
4294 result_type,
4295 result_id,
4296 extension_set,
4297 crate::spirv::CLOp::vstore_halfn as spirv::Word,
4298 args,
4299 )
4300 }
4301 #[allow(clippy::too_many_arguments)]
4302 pub fn cl_vstore_halfn_r(
4303 &mut self,
4304 result_type: spirv::Word,
4305 data: spirv::Word,
4306 offset: spirv::Word,
4307 p: spirv::Word,
4308 mode: spirv::FPRoundingMode,
4309 ) -> Result<spirv::Word, dr::Error> {
4310 self.cl_vstore_halfn_r_id(result_type, None, data, offset, p, mode)
4311 }
4312 #[allow(clippy::too_many_arguments)]
4313 pub fn cl_vstore_halfn_r_id(
4314 &mut self,
4315 result_type: spirv::Word,
4316 result_id: Option<spirv::Word>,
4317 data: spirv::Word,
4318 offset: spirv::Word,
4319 p: spirv::Word,
4320 mode: spirv::FPRoundingMode,
4321 ) -> Result<spirv::Word, dr::Error> {
4322 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
4323 #[allow(unused_mut)]
4324 let mut args = vec![
4325 dr::Operand::IdRef(data),
4326 dr::Operand::IdRef(offset),
4327 dr::Operand::IdRef(p),
4328 dr::Operand::FPRoundingMode(mode),
4329 ];
4330 self.ext_inst(
4331 result_type,
4332 result_id,
4333 extension_set,
4334 crate::spirv::CLOp::vstore_halfn_r as spirv::Word,
4335 args,
4336 )
4337 }
4338 #[allow(clippy::too_many_arguments)]
4339 pub fn cl_vloada_halfn(
4340 &mut self,
4341 result_type: spirv::Word,
4342 offset: spirv::Word,
4343 p: spirv::Word,
4344 n: u32,
4345 ) -> Result<spirv::Word, dr::Error> {
4346 self.cl_vloada_halfn_id(result_type, None, offset, p, n)
4347 }
4348 #[allow(clippy::too_many_arguments)]
4349 pub fn cl_vloada_halfn_id(
4350 &mut self,
4351 result_type: spirv::Word,
4352 result_id: Option<spirv::Word>,
4353 offset: spirv::Word,
4354 p: spirv::Word,
4355 n: u32,
4356 ) -> Result<spirv::Word, dr::Error> {
4357 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
4358 #[allow(unused_mut)]
4359 let mut args = vec![
4360 dr::Operand::IdRef(offset),
4361 dr::Operand::IdRef(p),
4362 dr::Operand::LiteralBit32(n),
4363 ];
4364 self.ext_inst(
4365 result_type,
4366 result_id,
4367 extension_set,
4368 crate::spirv::CLOp::vloada_halfn as spirv::Word,
4369 args,
4370 )
4371 }
4372 #[allow(clippy::too_many_arguments)]
4373 pub fn cl_vstorea_halfn(
4374 &mut self,
4375 result_type: spirv::Word,
4376 data: spirv::Word,
4377 offset: spirv::Word,
4378 p: spirv::Word,
4379 ) -> Result<spirv::Word, dr::Error> {
4380 self.cl_vstorea_halfn_id(result_type, None, data, offset, p)
4381 }
4382 #[allow(clippy::too_many_arguments)]
4383 pub fn cl_vstorea_halfn_id(
4384 &mut self,
4385 result_type: spirv::Word,
4386 result_id: Option<spirv::Word>,
4387 data: spirv::Word,
4388 offset: spirv::Word,
4389 p: spirv::Word,
4390 ) -> Result<spirv::Word, dr::Error> {
4391 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
4392 #[allow(unused_mut)]
4393 let mut args = vec![
4394 dr::Operand::IdRef(data),
4395 dr::Operand::IdRef(offset),
4396 dr::Operand::IdRef(p),
4397 ];
4398 self.ext_inst(
4399 result_type,
4400 result_id,
4401 extension_set,
4402 crate::spirv::CLOp::vstorea_halfn as spirv::Word,
4403 args,
4404 )
4405 }
4406 #[allow(clippy::too_many_arguments)]
4407 pub fn cl_vstorea_halfn_r(
4408 &mut self,
4409 result_type: spirv::Word,
4410 data: spirv::Word,
4411 offset: spirv::Word,
4412 p: spirv::Word,
4413 mode: spirv::FPRoundingMode,
4414 ) -> Result<spirv::Word, dr::Error> {
4415 self.cl_vstorea_halfn_r_id(result_type, None, data, offset, p, mode)
4416 }
4417 #[allow(clippy::too_many_arguments)]
4418 pub fn cl_vstorea_halfn_r_id(
4419 &mut self,
4420 result_type: spirv::Word,
4421 result_id: Option<spirv::Word>,
4422 data: spirv::Word,
4423 offset: spirv::Word,
4424 p: spirv::Word,
4425 mode: spirv::FPRoundingMode,
4426 ) -> Result<spirv::Word, dr::Error> {
4427 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
4428 #[allow(unused_mut)]
4429 let mut args = vec![
4430 dr::Operand::IdRef(data),
4431 dr::Operand::IdRef(offset),
4432 dr::Operand::IdRef(p),
4433 dr::Operand::FPRoundingMode(mode),
4434 ];
4435 self.ext_inst(
4436 result_type,
4437 result_id,
4438 extension_set,
4439 crate::spirv::CLOp::vstorea_halfn_r as spirv::Word,
4440 args,
4441 )
4442 }
4443 #[allow(clippy::too_many_arguments)]
4444 pub fn cl_shuffle(
4445 &mut self,
4446 result_type: spirv::Word,
4447 x: spirv::Word,
4448 shuffle_mask: spirv::Word,
4449 ) -> Result<spirv::Word, dr::Error> {
4450 self.cl_shuffle_id(result_type, None, x, shuffle_mask)
4451 }
4452 #[allow(clippy::too_many_arguments)]
4453 pub fn cl_shuffle_id(
4454 &mut self,
4455 result_type: spirv::Word,
4456 result_id: Option<spirv::Word>,
4457 x: spirv::Word,
4458 shuffle_mask: spirv::Word,
4459 ) -> Result<spirv::Word, dr::Error> {
4460 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
4461 #[allow(unused_mut)]
4462 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(shuffle_mask)];
4463 self.ext_inst(
4464 result_type,
4465 result_id,
4466 extension_set,
4467 crate::spirv::CLOp::shuffle as spirv::Word,
4468 args,
4469 )
4470 }
4471 #[allow(clippy::too_many_arguments)]
4472 pub fn cl_shuffle2(
4473 &mut self,
4474 result_type: spirv::Word,
4475 x: spirv::Word,
4476 y: spirv::Word,
4477 shuffle_mask: spirv::Word,
4478 ) -> Result<spirv::Word, dr::Error> {
4479 self.cl_shuffle2_id(result_type, None, x, y, shuffle_mask)
4480 }
4481 #[allow(clippy::too_many_arguments)]
4482 pub fn cl_shuffle2_id(
4483 &mut self,
4484 result_type: spirv::Word,
4485 result_id: Option<spirv::Word>,
4486 x: spirv::Word,
4487 y: spirv::Word,
4488 shuffle_mask: spirv::Word,
4489 ) -> Result<spirv::Word, dr::Error> {
4490 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
4491 #[allow(unused_mut)]
4492 let mut args = vec![
4493 dr::Operand::IdRef(x),
4494 dr::Operand::IdRef(y),
4495 dr::Operand::IdRef(shuffle_mask),
4496 ];
4497 self.ext_inst(
4498 result_type,
4499 result_id,
4500 extension_set,
4501 crate::spirv::CLOp::shuffle2 as spirv::Word,
4502 args,
4503 )
4504 }
4505 #[allow(clippy::too_many_arguments)]
4506 pub fn cl_printf(
4507 &mut self,
4508 result_type: spirv::Word,
4509 format: spirv::Word,
4510 additional_arguments: impl IntoIterator<Item = spirv::Word>,
4511 ) -> Result<spirv::Word, dr::Error> {
4512 self.cl_printf_id(result_type, None, format, additional_arguments)
4513 }
4514 #[allow(clippy::too_many_arguments)]
4515 pub fn cl_printf_id(
4516 &mut self,
4517 result_type: spirv::Word,
4518 result_id: Option<spirv::Word>,
4519 format: spirv::Word,
4520 additional_arguments: impl IntoIterator<Item = spirv::Word>,
4521 ) -> Result<spirv::Word, dr::Error> {
4522 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
4523 #[allow(unused_mut)]
4524 let mut args = vec![dr::Operand::IdRef(format)];
4525 args.extend(additional_arguments.into_iter().map(dr::Operand::IdRef));
4526 self.ext_inst(
4527 result_type,
4528 result_id,
4529 extension_set,
4530 crate::spirv::CLOp::printf as spirv::Word,
4531 args,
4532 )
4533 }
4534 #[allow(clippy::too_many_arguments)]
4535 pub fn cl_prefetch(
4536 &mut self,
4537 result_type: spirv::Word,
4538 ptr: spirv::Word,
4539 num_elements: spirv::Word,
4540 ) -> Result<spirv::Word, dr::Error> {
4541 self.cl_prefetch_id(result_type, None, ptr, num_elements)
4542 }
4543 #[allow(clippy::too_many_arguments)]
4544 pub fn cl_prefetch_id(
4545 &mut self,
4546 result_type: spirv::Word,
4547 result_id: Option<spirv::Word>,
4548 ptr: spirv::Word,
4549 num_elements: spirv::Word,
4550 ) -> Result<spirv::Word, dr::Error> {
4551 let extension_set = super::ext_inst_import(self, "OpenCL.std.100");
4552 #[allow(unused_mut)]
4553 let mut args = vec![dr::Operand::IdRef(ptr), dr::Operand::IdRef(num_elements)];
4554 self.ext_inst(
4555 result_type,
4556 result_id,
4557 extension_set,
4558 crate::spirv::CLOp::prefetch as spirv::Word,
4559 args,
4560 )
4561 }
4562}