3 # Copyright (C) 2014 Connor Abbott
5 # Permission is hereby granted, free of charge, to any person obtaining a
6 # copy of this software and associated documentation files (the "Software"),
7 # to deal in the Software without restriction, including without limitation
8 # the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 # and/or sell copies of the Software, and to permit persons to whom the
10 # Software is furnished to do so, subject to the following conditions:
12 # The above copyright notice and this permission notice (including the next
13 # paragraph) shall be included in all copies or substantial portions of the
16 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
25 # Connor Abbott (cwabbott0@gmail.com)
28 # Class that represents all the information we have about the opcode
29 # NOTE: this must be kept in sync with nir_op_info
32 """Class that represents all the information we have about the opcode
33 NOTE: this must be kept in sync with nir_op_info
35 def __init__(self
, name
, output_size
, output_type
, input_sizes
,
36 input_types
, algebraic_properties
, const_expr
):
39 - name is the name of the opcode (prepend nir_op_ for the enum name)
40 - all types are strings that get nir_type_ prepended to them
41 - input_types is a list of types
42 - algebraic_properties is a space-seperated string, where nir_op_is_ is
43 prepended before each entry
44 - const_expr is an expression or series of statements that computes the
45 constant value of the opcode given the constant values of its inputs.
47 Constant expressions are formed from the variables src0, src1, ...,
48 src(N-1), where N is the number of arguments. The output of the
49 expression should be stored in the dst variable. Per-component input
50 and output variables will be scalars and non-per-component input and
51 output variables will be a struct with fields named x, y, z, and w
52 all of the correct type. Input and output variables can be assumed
53 to already be of the correct type and need no conversion. In
54 particular, the conversion from the C bool type to/from NIR_TRUE and
55 NIR_FALSE happens automatically.
57 For per-component instructions, the entire expression will be
58 executed once for each component. For non-per-component
59 instructions, the expression is expected to store the correct values
60 in dst.x, dst.y, etc. If "dst" does not exist anywhere in the
61 constant expression, an assignment to dst will happen automatically
62 and the result will be equivalent to "dst = <expression>" for
63 per-component instructions and "dst.x = dst.y = ... = <expression>"
64 for non-per-component instructions.
66 assert isinstance(name
, str)
67 assert isinstance(output_size
, int)
68 assert isinstance(output_type
, str)
69 assert isinstance(input_sizes
, list)
70 assert isinstance(input_sizes
[0], int)
71 assert isinstance(input_types
, list)
72 assert isinstance(input_types
[0], str)
73 assert isinstance(algebraic_properties
, str)
74 assert isinstance(const_expr
, str)
75 assert len(input_sizes
) == len(input_types
)
76 assert 0 <= output_size
<= 4
77 for size
in input_sizes
:
82 self
.num_inputs
= len(input_sizes
)
83 self
.output_size
= output_size
84 self
.output_type
= output_type
85 self
.input_sizes
= input_sizes
86 self
.input_types
= input_types
87 self
.algebraic_properties
= algebraic_properties
88 self
.const_expr
= const_expr
90 # helper variables for strings
94 tunsigned
= "unsigned"
96 commutative
= "commutative "
97 associative
= "associative "
99 # global dictionary of opcodes
102 def opcode(name
, output_size
, output_type
, input_sizes
, input_types
,
103 algebraic_properties
, const_expr
):
104 assert name
not in opcodes
105 opcodes
[name
] = Opcode(name
, output_size
, output_type
, input_sizes
,
106 input_types
, algebraic_properties
, const_expr
)
108 def unop_convert(name
, in_type
, out_type
, const_expr
):
109 opcode(name
, 0, out_type
, [0], [in_type
], "", const_expr
)
111 def unop(name
, ty
, const_expr
):
112 opcode(name
, 0, ty
, [0], [ty
], "", const_expr
)
114 def unop_horiz(name
, output_size
, output_type
, input_size
, input_type
,
116 opcode(name
, output_size
, output_type
, [input_size
], [input_type
], "",
119 def unop_reduce(name
, output_size
, output_type
, input_type
, prereduce_expr
,
120 reduce_expr
, final_expr
):
122 return "(" + prereduce_expr
.format(src
=src
) + ")"
124 return final_expr
.format(src
="(" + src
+ ")")
125 def reduce_(src0
, src1
):
126 return reduce_expr
.format(src0
=src0
, src1
=src1
)
127 src0
= prereduce("src0.x")
128 src1
= prereduce("src0.y")
129 src2
= prereduce("src0.z")
130 src3
= prereduce("src0.w")
131 unop_horiz(name
+ "2", output_size
, output_type
, 2, input_type
,
132 final(reduce_(src0
, src1
)))
133 unop_horiz(name
+ "3", output_size
, output_type
, 3, input_type
,
134 final(reduce_(reduce_(src0
, src1
), src2
)))
135 unop_horiz(name
+ "4", output_size
, output_type
, 4, input_type
,
136 final(reduce_(reduce_(src0
, src1
), reduce_(src2
, src3
))))
139 # These two move instructions differ in what modifiers they support and what
140 # the negate modifier means. Otherwise, they are identical.
141 unop("fmov", tfloat
, "src0")
142 unop("imov", tint
, "src0")
144 unop("ineg", tint
, "-src0")
145 unop("fneg", tfloat
, "-src0")
146 unop("inot", tint
, "~src0") # invert every bit of the integer
147 unop("fnot", tfloat
, "(src0 == 0.0f) ? 1.0f : 0.0f")
148 unop("fsign", tfloat
, "(src0 == 0.0f) ? 0.0f : ((src0 > 0.0f) ? 1.0f : -1.0f)")
149 unop("isign", tint
, "(src0 == 0) ? 0 : ((src0 > 0) ? 1 : -1)")
150 unop("iabs", tint
, "(src0 < 0) ? -src0 : src0")
151 unop("fabs", tfloat
, "fabsf(src0)")
152 unop("fsat", tfloat
, "(src0 > 1.0f) ? 1.0f : ((src0 <= 0.0f) ? 0.0f : src0)")
153 unop("frcp", tfloat
, "1.0f / src0")
154 unop("frsq", tfloat
, "1.0f / sqrtf(src0)")
155 unop("fsqrt", tfloat
, "sqrtf(src0)")
156 unop("fexp", tfloat
, "expf(src0)") # < e^x
157 unop("flog", tfloat
, "logf(src0)") # log base e
158 unop("fexp2", tfloat
, "exp2f(src0)")
159 unop("flog2", tfloat
, "log2f(src0)")
160 unop_convert("f2i", tfloat
, tint
, "src0") # Float-to-integer conversion.
161 unop_convert("f2u", tfloat
, tunsigned
, "src0") # Float-to-unsigned conversion
162 unop_convert("i2f", tint
, tfloat
, "src0") # Integer-to-float conversion.
163 # Float-to-boolean conversion
164 unop_convert("f2b", tfloat
, tbool
, "src0 != 0.0f")
165 # Boolean-to-float conversion
166 unop_convert("b2f", tbool
, tfloat
, "src0 ? 1.0f : 0.0f")
167 # Int-to-boolean conversion
168 unop_convert("i2b", tint
, tbool
, "src0 != 0")
169 unop_convert("b2i", tbool
, tint
, "src0 ? 1 : 0") # Boolean-to-int conversion
170 unop_convert("u2f", tunsigned
, tfloat
, "src0") #Unsigned-to-float conversion.
172 unop_reduce("bany", 1, tbool
, tbool
, "{src}", "{src0} || {src1}", "{src}")
173 unop_reduce("ball", 1, tbool
, tbool
, "{src}", "{src0} && {src1}", "{src}")
174 unop_reduce("fany", 1, tfloat
, tfloat
, "{src} != 0.0f", "{src0} || {src1}",
175 "{src} ? 1.0f : 0.0f")
176 unop_reduce("fall", 1, tfloat
, tfloat
, "{src} != 0.0f", "{src0} && {src1}",
177 "{src} ? 1.0f : 0.0f")
179 # Unary floating-point rounding operations.
182 unop("ftrunc", tfloat
, "truncf(src0)")
183 unop("fceil", tfloat
, "ceilf(src0)")
184 unop("ffloor", tfloat
, "floorf(src0)")
185 unop("ffract", tfloat
, "src0 - floorf(src0)")
186 unop("fround_even", tfloat
, "_mesa_roundevenf(src0)")
189 # Trigonometric operations.
192 unop("fsin", tfloat
, "sinf(src0)")
193 unop("fcos", tfloat
, "cosf(src0)")
196 # Partial derivatives.
199 unop("fddx", tfloat
, "0.0f") # the derivative of a constant is 0.
200 unop("fddy", tfloat
, "0.0f")
201 unop("fddx_fine", tfloat
, "0.0f")
202 unop("fddy_fine", tfloat
, "0.0f")
203 unop("fddx_coarse", tfloat
, "0.0f")
204 unop("fddy_coarse", tfloat
, "0.0f")
207 # Floating point pack and unpack operations.
210 unop_horiz("pack_" + fmt
+ "_2x16", 1, tunsigned
, 2, tfloat
, """
211 dst.x = (uint32_t) pack_fmt_1x16(src0.x);
212 dst.x |= ((uint32_t) pack_fmt_1x16(src0.y)) << 16;
213 """.replace("fmt", fmt
))
216 unop_horiz("pack_" + fmt
+ "_4x8", 1, tunsigned
, 4, tfloat
, """
217 dst.x = (uint32_t) pack_fmt_1x8(src0.x);
218 dst.x |= ((uint32_t) pack_fmt_1x8(src0.y)) << 8;
219 dst.x |= ((uint32_t) pack_fmt_1x8(src0.z)) << 16;
220 dst.x |= ((uint32_t) pack_fmt_1x8(src0.w)) << 24;
221 """.replace("fmt", fmt
))
223 def unpack_2x16(fmt
):
224 unop_horiz("unpack_" + fmt
+ "_2x16", 2, tfloat
, 1, tunsigned
, """
225 dst.x = unpack_fmt_1x16((uint16_t)(src0.x & 0xffff));
226 dst.y = unpack_fmt_1x16((uint16_t)(src0.x << 16));
227 """.replace("fmt", fmt
))
230 unop_horiz("unpack_" + fmt
+ "_4x8", 4, tfloat
, 1, tunsigned
, """
231 dst.x = unpack_fmt_1x8((uint8_t)(src0.x & 0xff));
232 dst.y = unpack_fmt_1x8((uint8_t)((src0.x >> 8) & 0xff));
233 dst.z = unpack_fmt_1x8((uint8_t)((src0.x >> 16) & 0xff));
234 dst.w = unpack_fmt_1x8((uint8_t)(src0.x >> 24));
235 """.replace("fmt", fmt
))
250 # Lowered floating point unpacking operations.
253 unop_horiz("unpack_half_2x16_split_x", 1, tfloat
, 1, tunsigned
,
254 "unpack_half_1x16((uint16_t)(src0.x & 0xffff))")
255 unop_horiz("unpack_half_2x16_split_y", 1, tfloat
, 1, tunsigned
,
256 "unpack_half_1x16((uint16_t)(src0.x >> 16))")
259 # Bit operations, part of ARB_gpu_shader5.
262 unop("bitfield_reverse", tunsigned
, """
263 /* we're not winning any awards for speed here, but that's ok */
265 for (unsigned bit = 0; bit < 32; bit++)
266 dst |= ((src0 >> bit) & 1) << (31 - bit);
268 unop("bit_count", tunsigned
, """
270 for (unsigned bit = 0; bit < 32; bit++) {
271 if ((src0 >> bit) & 1)
276 unop_convert("ufind_msb", tunsigned
, tint
, """
278 for (int bit = 31; bit > 0; bit--) {
279 if ((src0 >> bit) & 1) {
286 unop("ifind_msb", tint
, """
288 for (int bit = 31; bit >= 0; bit--) {
289 /* If src0 < 0, we're looking for the first 0 bit.
290 * if src0 >= 0, we're looking for the first 1 bit.
292 if ((((src0 >> bit) & 1) && (src0 >= 0)) ||
293 (!((src0 >> bit) & 1) && (src0 < 0))) {
300 unop("find_lsb", tint
, """
302 for (unsigned bit = 0; bit < 32; bit++) {
303 if ((src0 >> bit) & 1) {
311 for i
in xrange(1, 5):
312 for j
in xrange(1, 5):
313 unop_horiz("fnoise{0}_{1}".format(i
, j
), i
, tfloat
, j
, tfloat
, "0.0f")
315 def binop_convert(name
, out_type
, in_type
, alg_props
, const_expr
):
316 opcode(name
, 0, out_type
, [0, 0], [in_type
, in_type
], alg_props
, const_expr
)
318 def binop(name
, ty
, alg_props
, const_expr
):
319 binop_convert(name
, ty
, ty
, alg_props
, const_expr
)
321 def binop_compare(name
, ty
, alg_props
, const_expr
):
322 binop_convert(name
, tbool
, ty
, alg_props
, const_expr
)
324 def binop_horiz(name
, out_size
, out_type
, src1_size
, src1_type
, src2_size
,
325 src2_type
, const_expr
):
326 opcode(name
, out_size
, out_type
, [src1_size
, src2_size
], [src1_type
, src2_type
],
329 def binop_reduce(name
, output_size
, output_type
, src_type
, prereduce_expr
,
330 reduce_expr
, final_expr
):
332 return final_expr
.format(src
= "(" + src
+ ")")
333 def reduce_(src0
, src1
):
334 return reduce_expr
.format(src0
=src0
, src1
=src1
)
335 def prereduce(src0
, src1
):
336 return "(" + prereduce_expr
.format(src0
=src0
, src1
=src1
) + ")"
337 src0
= prereduce("src0.x", "src1.x")
338 src1
= prereduce("src0.y", "src1.y")
339 src2
= prereduce("src0.z", "src1.z")
340 src3
= prereduce("src0.w", "src1.w")
341 opcode(name
+ "2", output_size
, output_type
,
342 [2, 2], [src_type
, src_type
], commutative
,
343 final(reduce_(src0
, src1
)))
344 opcode(name
+ "3", output_size
, output_type
,
345 [3, 3], [src_type
, src_type
], commutative
,
346 final(reduce_(reduce_(src0
, src1
), src2
)))
347 opcode(name
+ "4", output_size
, output_type
,
348 [4, 4], [src_type
, src_type
], commutative
,
349 final(reduce_(reduce_(src0
, src1
), reduce_(src2
, src3
))))
351 binop("fadd", tfloat
, commutative
+ associative
, "src0 + src1")
352 binop("iadd", tint
, commutative
+ associative
, "src0 + src1")
353 binop("fsub", tfloat
, "", "src0 - src1")
354 binop("isub", tint
, "", "src0 - src1")
356 binop("fmul", tfloat
, commutative
+ associative
, "src0 * src1")
357 # low 32-bits of signed/unsigned integer multiply
358 binop("imul", tint
, commutative
+ associative
, "src0 * src1")
359 # high 32-bits of signed integer multiply
360 binop("imul_high", tint
, commutative
,
361 "(int32_t)(((int64_t) src0 * (int64_t) src1) >> 32)")
362 # high 32-bits of unsigned integer multiply
363 binop("umul_high", tunsigned
, commutative
,
364 "(uint32_t)(((uint64_t) src0 * (uint64_t) src1) >> 32)")
366 binop("fdiv", tfloat
, "", "src0 / src1")
367 binop("idiv", tint
, "", "src0 / src1")
368 binop("udiv", tunsigned
, "", "src0 / src1")
370 # returns a boolean representing the carry resulting from the addition of
371 # the two unsigned arguments.
373 binop_convert("uadd_carry", tbool
, tunsigned
, commutative
, "src0 + src1 < src0")
375 # returns a boolean representing the borrow resulting from the subtraction
376 # of the two unsigned arguments.
378 binop_convert("usub_borrow", tbool
, tunsigned
, "", "src1 < src0")
380 binop("fmod", tfloat
, "", "src0 - src1 * floorf(src0 / src1)")
381 binop("umod", tunsigned
, "", "src1 == 0 ? 0 : src0 % src1")
388 # these integer-aware comparisons return a boolean (0 or ~0)
390 binop_compare("flt", tfloat
, "", "src0 < src1")
391 binop_compare("fge", tfloat
, "", "src0 >= src1")
392 binop_compare("feq", tfloat
, commutative
, "src0 == src1")
393 binop_compare("fne", tfloat
, commutative
, "src0 != src1")
394 binop_compare("ilt", tint
, "", "src0 < src1")
395 binop_compare("ige", tint
, "", "src0 >= src1")
396 binop_compare("ieq", tint
, commutative
, "src0 == src1")
397 binop_compare("ine", tint
, commutative
, "src0 != src1")
398 binop_compare("ult", tunsigned
, "", "src0 < src1")
399 binop_compare("uge", tunsigned
, "", "src0 >= src1")
401 # integer-aware GLSL-style comparisons that compare floats and ints
403 binop_reduce("ball_fequal", 1, tbool
, tfloat
, "{src0} == {src1}",
404 "{src0} && {src1}", "{src}")
405 binop_reduce("bany_fnequal", 1, tbool
, tfloat
, "{src0} != {src1}",
406 "{src0} || {src1}", "{src}")
407 binop_reduce("ball_iequal", 1, tbool
, tint
, "{src0} == {src1}",
408 "{src0} && {src1}", "{src}")
409 binop_reduce("bany_inequal", 1, tbool
, tint
, "{src0} != {src1}",
410 "{src0} || {src1}", "{src}")
412 # non-integer-aware GLSL-style comparisons that return 0.0 or 1.0
414 binop_reduce("fall_equal", 1, tfloat
, tfloat
, "{src0} == {src1}",
415 "{src0} && {src1}", "{src} ? 1.0f : 0.0f")
416 binop_reduce("fany_nequal", 1, tfloat
, tfloat
, "{src0} != {src1}",
417 "{src0} || {src1}", "{src} ? 1.0f : 0.0f")
419 # These comparisons for integer-less hardware return 1.0 and 0.0 for true
420 # and false respectively
422 binop("slt", tfloat
, "", "(src0 < src1) ? 1.0f : 0.0f") # Set on Less Than
423 binop("sge", tfloat
, "", "(src0 >= src1) ? 1.0f : 0.0f") # Set on Greater or Equal
424 binop("seq", tfloat
, commutative
, "(src0 == src1) ? 1.0f : 0.0f") # Set on Equal
425 binop("sne", tfloat
, commutative
, "(src0 != src1) ? 1.0f : 0.0f") # Set on Not Equal
428 binop("ishl", tint
, "", "src0 << src1")
429 binop("ishr", tint
, "", "src0 >> src1")
430 binop("ushr", tunsigned
, "", "src0 >> src1")
432 # bitwise logic operators
434 # These are also used as boolean and, or, xor for hardware supporting
438 binop("iand", tunsigned
, commutative
+ associative
, "src0 & src1")
439 binop("ior", tunsigned
, commutative
+ associative
, "src0 | src1")
440 binop("ixor", tunsigned
, commutative
+ associative
, "src0 ^ src1")
443 # floating point logic operators
445 # These use (src != 0.0) for testing the truth of the input, and output 1.0
446 # for true and 0.0 for false
448 binop("fand", tfloat
, commutative
,
449 "((src0 != 0.0f) && (src1 != 0.0f)) ? 1.0f : 0.0f")
450 binop("for", tfloat
, commutative
,
451 "((src0 != 0.0f) || (src1 != 0.0f)) ? 1.0f : 0.0f")
452 binop("fxor", tfloat
, commutative
,
453 "(src0 != 0.0f && src1 == 0.0f) || (src0 == 0.0f && src1 != 0.0f) ? 1.0f : 0.0f")
455 binop_reduce("fdot", 1, tfloat
, tfloat
, "{src0} * {src1}", "{src0} + {src1}",
458 binop("fmin", tfloat
, "", "fminf(src0, src1)")
459 binop("imin", tint
, commutative
+ associative
, "src1 > src0 ? src0 : src1")
460 binop("umin", tunsigned
, commutative
+ associative
, "src1 > src0 ? src0 : src1")
461 binop("fmax", tfloat
, "", "fmaxf(src0, src1)")
462 binop("imax", tint
, commutative
+ associative
, "src1 > src0 ? src1 : src0")
463 binop("umax", tunsigned
, commutative
+ associative
, "src1 > src0 ? src1 : src0")
465 binop("fpow", tfloat
, "", "powf(src0, src1)")
467 binop_horiz("pack_half_2x16_split", 1, tunsigned
, 1, tfloat
, 1, tfloat
,
468 "pack_half_1x16(src0.x) | (pack_half_1x16(src1.x) << 16)")
470 binop_convert("bfm", tunsigned
, tint
, "", """
471 int offset = src0, bits = src1;
472 if (offset < 0 || bits < 0 || offset + bits > 32)
473 dst = 0; /* undefined per the spec */
475 dst = ((1 << bits)- 1) << offset;
478 opcode("ldexp", 0, tfloat
, [0, 0], [tfloat
, tint
], "", """
479 dst = ldexp(src0, src1);
480 /* flush denormals to zero. */
482 dst = copysign(0.0f, src0);
485 # Combines the first component of each input to make a 2-component vector.
487 binop_horiz("vec2", 2, tunsigned
, 1, tunsigned
, 1, tunsigned
, """
492 def triop(name
, ty
, const_expr
):
493 opcode(name
, 0, ty
, [0, 0, 0], [ty
, ty
, ty
], "", const_expr
)
494 def triop_horiz(name
, output_size
, src1_size
, src2_size
, src3_size
, const_expr
):
495 opcode(name
, output_size
, tunsigned
,
496 [src1_size
, src2_size
, src3_size
],
497 [tunsigned
, tunsigned
, tunsigned
], "", const_expr
)
499 triop("ffma", tfloat
, "src0 * src1 + src2")
501 triop("flrp", tfloat
, "src0 * (1 - src2) + src1 * src2")
505 # A vector conditional select instruction (like ?:, but operating per-
506 # component on vectors). There are two versions, one for floating point
507 # bools (0.0 vs 1.0) and one for integer bools (0 vs ~0).
510 triop("fcsel", tfloat
, "(src0 != 0.0f) ? src1 : src2")
511 opcode("bcsel", 0, tunsigned
, [0, 0, 0],
512 [tbool
, tunsigned
, tunsigned
], "", "src0 ? src1 : src2")
514 triop("bfi", tunsigned
, """
515 unsigned mask = src0, insert = src1 & mask, base = src2;
524 dst = (base & ~mask) | insert;
528 opcode("ubitfield_extract", 0, tunsigned
,
529 [0, 1, 1], [tunsigned
, tint
, tint
], "", """
530 unsigned base = src0;
531 int offset = src1.x, bits = src2.x;
534 } else if (bits < 0 || offset < 0 || offset + bits > 32) {
535 dst = 0; /* undefined per the spec */
537 dst = (base >> offset) & ((1 << bits) - 1);
540 opcode("ibitfield_extract", 0, tint
,
541 [0, 1, 1], [tint
, tint
, tint
], "", """
543 int offset = src1.x, bits = src2.x;
546 } else if (offset < 0 || bits < 0 || offset + bits > 32) {
549 dst = (base << (32 - offset - bits)) >> offset; /* use sign-extending shift */
553 # Combines the first component of each input to make a 3-component vector.
555 triop_horiz("vec3", 3, 1, 1, 1, """
561 def quadop_horiz(name
, output_size
, src1_size
, src2_size
, src3_size
,
562 src4_size
, const_expr
):
563 opcode(name
, output_size
, tunsigned
,
564 [src1_size
, src2_size
, src3_size
, src4_size
],
565 [tunsigned
, tunsigned
, tunsigned
, tunsigned
],
568 opcode("bitfield_insert", 0, tunsigned
, [0, 0, 1, 1],
569 [tunsigned
, tunsigned
, tint
, tint
], "", """
570 unsigned base = src0, insert = src1;
571 int offset = src2.x, bits = src3.x;
574 } else if (offset < 0 || bits < 0 || bits + offset > 32) {
577 unsigned mask = ((1 << bits) - 1) << offset;
578 dst = (base & ~mask) | ((insert << bits) & mask);
582 quadop_horiz("vec4", 4, 1, 1, 1, 1, """