nir_opcodes.py 31.5 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#
# Copyright (C) 2014 Connor Abbott
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice (including the next
# paragraph) shall be included in all copies or substantial portions of the
# Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
#
# Authors:
#    Connor Abbott (cwabbott0@gmail.com)

26
import re
27

28
29
30
31
32
33
34
35
# Class that represents all the information we have about the opcode
# NOTE: this must be kept in sync with nir_op_info

class Opcode(object):
   """Class that represents all the information we have about the opcode
   NOTE: this must be kept in sync with nir_op_info
   """
   def __init__(self, name, output_size, output_type, input_sizes,
36
                input_types, algebraic_properties, const_expr):
37
38
39
40
41
42
43
      """Parameters:

      - name is the name of the opcode (prepend nir_op_ for the enum name)
      - all types are strings that get nir_type_ prepended to them
      - input_types is a list of types
      - algebraic_properties is a space-seperated string, where nir_op_is_ is
        prepended before each entry
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
      - const_expr is an expression or series of statements that computes the
        constant value of the opcode given the constant values of its inputs.

      Constant expressions are formed from the variables src0, src1, ...,
      src(N-1), where N is the number of arguments.  The output of the
      expression should be stored in the dst variable.  Per-component input
      and output variables will be scalars and non-per-component input and
      output variables will be a struct with fields named x, y, z, and w
      all of the correct type.  Input and output variables can be assumed
      to already be of the correct type and need no conversion.  In
      particular, the conversion from the C bool type to/from  NIR_TRUE and
      NIR_FALSE happens automatically.

      For per-component instructions, the entire expression will be
      executed once for each component.  For non-per-component
      instructions, the expression is expected to store the correct values
      in dst.x, dst.y, etc.  If "dst" does not exist anywhere in the
      constant expression, an assignment to dst will happen automatically
      and the result will be equivalent to "dst = <expression>" for
      per-component instructions and "dst.x = dst.y = ... = <expression>"
      for non-per-component instructions.
65
66
67
68
69
70
71
72
73
      """
      assert isinstance(name, str)
      assert isinstance(output_size, int)
      assert isinstance(output_type, str)
      assert isinstance(input_sizes, list)
      assert isinstance(input_sizes[0], int)
      assert isinstance(input_types, list)
      assert isinstance(input_types[0], str)
      assert isinstance(algebraic_properties, str)
74
      assert isinstance(const_expr, str)
75
76
77
78
79
80
81
82
83
84
85
86
87
      assert len(input_sizes) == len(input_types)
      assert 0 <= output_size <= 4
      for size in input_sizes:
         assert 0 <= size <= 4
         if output_size != 0:
            assert size != 0
      self.name = name
      self.num_inputs = len(input_sizes)
      self.output_size = output_size
      self.output_type = output_type
      self.input_sizes = input_sizes
      self.input_types = input_types
      self.algebraic_properties = algebraic_properties
88
      self.const_expr = const_expr
89
90
91
92

# helper variables for strings
tfloat = "float"
tint = "int"
93
tbool = "bool"
94
tbool1 = "bool1"
95
tbool32 = "bool32"
96
tuint = "uint"
97
tuint16 = "uint16"
98
99
100
tfloat32 = "float32"
tint32 = "int32"
tuint32 = "uint32"
101
tint64 = "int64"
102
tuint64 = "uint64"
103
tfloat64 = "float64"
104

105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
_TYPE_SPLIT_RE = re.compile(r'(?P<type>int|uint|float|bool)(?P<bits>\d+)?')

def type_has_size(type_):
    m = _TYPE_SPLIT_RE.match(type_)
    assert m is not None, 'Invalid NIR type string: "{}"'.format(type_)
    return m.group('bits') is not None

def type_size(type_):
    m = _TYPE_SPLIT_RE.match(type_)
    assert m is not None, 'Invalid NIR type string: "{}"'.format(type_)
    assert m.group('bits') is not None, \
           'NIR type string has no bit size: "{}"'.format(type_)
    return int(m.group('bits'))

def type_sizes(type_):
    if type_has_size(type_):
        return [type_size(type_)]
122
    elif type_ == 'bool':
123
        return [1, 32]
124
125
126
    elif type_ == 'float':
        return [16, 32, 64]
    else:
127
        return [1, 8, 16, 32, 64]
128
129
130
131
132
133

def type_base_type(type_):
    m = _TYPE_SPLIT_RE.match(type_)
    assert m is not None, 'Invalid NIR type string: "{}"'.format(type_)
    return m.group('type')

134
135
136
137
138
139
140
commutative = "commutative "
associative = "associative "

# global dictionary of opcodes
opcodes = {}

def opcode(name, output_size, output_type, input_sizes, input_types,
141
           algebraic_properties, const_expr):
142
143
   assert name not in opcodes
   opcodes[name] = Opcode(name, output_size, output_type, input_sizes,
144
145
                          input_types, algebraic_properties, const_expr)

146
def unop_convert(name, out_type, in_type, const_expr):
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
   opcode(name, 0, out_type, [0], [in_type], "", const_expr)

def unop(name, ty, const_expr):
   opcode(name, 0, ty, [0], [ty], "", const_expr)

def unop_horiz(name, output_size, output_type, input_size, input_type,
               const_expr):
   opcode(name, output_size, output_type, [input_size], [input_type], "",
          const_expr)

def unop_reduce(name, output_size, output_type, input_type, prereduce_expr,
                reduce_expr, final_expr):
   def prereduce(src):
      return "(" + prereduce_expr.format(src=src) + ")"
   def final(src):
      return final_expr.format(src="(" + src + ")")
   def reduce_(src0, src1):
      return reduce_expr.format(src0=src0, src1=src1)
   src0 = prereduce("src0.x")
   src1 = prereduce("src0.y")
   src2 = prereduce("src0.z")
   src3 = prereduce("src0.w")
   unop_horiz(name + "2", output_size, output_type, 2, input_type,
              final(reduce_(src0, src1)))
   unop_horiz(name + "3", output_size, output_type, 3, input_type,
              final(reduce_(reduce_(src0, src1), src2)))
   unop_horiz(name + "4", output_size, output_type, 4, input_type,
              final(reduce_(reduce_(src0, src1), reduce_(src2, src3))))
175
176
177
178


# These two move instructions differ in what modifiers they support and what
# the negate modifier means. Otherwise, they are identical.
179
180
181
182
183
184
unop("fmov", tfloat, "src0")
unop("imov", tint, "src0")

unop("ineg", tint, "-src0")
unop("fneg", tfloat, "-src0")
unop("inot", tint, "~src0") # invert every bit of the integer
185
186
187
188
189
unop("fnot", tfloat, ("bit_size == 64 ? ((src0 == 0.0) ? 1.0 : 0.0f) : " +
                      "((src0 == 0.0f) ? 1.0f : 0.0f)"))
unop("fsign", tfloat, ("bit_size == 64 ? " +
                       "((src0 == 0.0) ? 0.0 : ((src0 > 0.0) ? 1.0 : -1.0)) : " +
                       "((src0 == 0.0f) ? 0.0f : ((src0 > 0.0f) ? 1.0f : -1.0f))"))
190
unop("isign", tint, "(src0 == 0) ? 0 : ((src0 > 0) ? 1 : -1)")
191
unop("iabs", tint, "(src0 < 0) ? -src0 : src0")
192
unop("fabs", tfloat, "fabs(src0)")
193
194
195
196
unop("fsat", tfloat, ("bit_size == 64 ? " +
                      "((src0 > 1.0) ? 1.0 : ((src0 <= 0.0) ? 0.0 : src0)) : " +
                      "((src0 > 1.0f) ? 1.0f : ((src0 <= 0.0f) ? 0.0f : src0))"))
unop("frcp", tfloat, "bit_size == 64 ? 1.0 / src0 : 1.0f / src0")
197
198
unop("frsq", tfloat, "bit_size == 64 ? 1.0 / sqrt(src0) : 1.0f / sqrtf(src0)")
unop("fsqrt", tfloat, "bit_size == 64 ? sqrt(src0) : sqrtf(src0)")
199
200
unop("fexp2", tfloat, "exp2f(src0)")
unop("flog2", tfloat, "log2f(src0)")
201
202

# Generate all of the numeric conversion opcodes
203
204
205
206
207
208
209
for src_t in [tint, tuint, tfloat, tbool]:
   if src_t == tbool:
      dst_types = [tfloat, tint]
   elif src_t == tint:
      dst_types = [tfloat, tint, tbool]
   elif src_t == tuint:
      dst_types = [tfloat, tuint]
210
   elif src_t == tfloat:
211
      dst_types = [tint, tuint, tfloat, tbool]
212
213

   for dst_t in dst_types:
214
      for bit_size in type_sizes(dst_t):
215
          if bit_size == 16 and dst_t == tfloat and src_t == tfloat:
216
              rnd_modes = ['_rtne', '_rtz', '']
217
              for rnd_mode in rnd_modes:
218
                  unop_convert("{0}2{1}{2}{3}".format(src_t[0], dst_t[0],
219
220
221
                                                       bit_size, rnd_mode),
                               dst_t + str(bit_size), src_t, "src0")
          else:
222
              conv_expr = "src0 != 0" if dst_t == tbool else "src0"
223
              unop_convert("{0}2{1}{2}".format(src_t[0], dst_t[0], bit_size),
224
                           dst_t + str(bit_size), src_t, conv_expr)
225

226

227
228
229
# Unary floating-point rounding operations.


230
231
232
233
234
unop("ftrunc", tfloat, "bit_size == 64 ? trunc(src0) : truncf(src0)")
unop("fceil", tfloat, "bit_size == 64 ? ceil(src0) : ceilf(src0)")
unop("ffloor", tfloat, "bit_size == 64 ? floor(src0) : floorf(src0)")
unop("ffract", tfloat, "src0 - (bit_size == 64 ? floor(src0) : floorf(src0))")
unop("fround_even", tfloat, "bit_size == 64 ? _mesa_roundeven(src0) : _mesa_roundevenf(src0)")
235

236
unop("fquantize2f16", tfloat, "(fabs(src0) < ldexpf(1.0, -14)) ? copysignf(0.0f, src0) : _mesa_half_to_float(_mesa_float_to_half(src0))")
237
238
239
240

# Trigonometric operations.


241
242
unop("fsin", tfloat, "bit_size == 64 ? sin(src0) : sinf(src0)")
unop("fcos", tfloat, "bit_size == 64 ? cos(src0) : cosf(src0)")
243

244
245
246
# dfrexp
unop_convert("frexp_exp", tint32, tfloat64, "frexp(src0, &dst);")
unop_convert("frexp_sig", tfloat64, tfloat64, "int n; dst = frexp(src0, &n);")
247
248
249
250

# Partial derivatives.


251
252
253
254
255
256
unop("fddx", tfloat, "0.0") # the derivative of a constant is 0.
unop("fddy", tfloat, "0.0")
unop("fddx_fine", tfloat, "0.0")
unop("fddy_fine", tfloat, "0.0")
unop("fddx_coarse", tfloat, "0.0")
unop("fddy_coarse", tfloat, "0.0")
257
258
259
260


# Floating point pack and unpack operations.

261
def pack_2x16(fmt):
262
   unop_horiz("pack_" + fmt + "_2x16", 1, tuint32, 2, tfloat32, """
263
264
265
266
267
dst.x = (uint32_t) pack_fmt_1x16(src0.x);
dst.x |= ((uint32_t) pack_fmt_1x16(src0.y)) << 16;
""".replace("fmt", fmt))

def pack_4x8(fmt):
268
   unop_horiz("pack_" + fmt + "_4x8", 1, tuint32, 4, tfloat32, """
269
270
271
272
273
274
275
dst.x = (uint32_t) pack_fmt_1x8(src0.x);
dst.x |= ((uint32_t) pack_fmt_1x8(src0.y)) << 8;
dst.x |= ((uint32_t) pack_fmt_1x8(src0.z)) << 16;
dst.x |= ((uint32_t) pack_fmt_1x8(src0.w)) << 24;
""".replace("fmt", fmt))

def unpack_2x16(fmt):
276
   unop_horiz("unpack_" + fmt + "_2x16", 2, tfloat32, 1, tuint32, """
277
278
279
280
281
dst.x = unpack_fmt_1x16((uint16_t)(src0.x & 0xffff));
dst.y = unpack_fmt_1x16((uint16_t)(src0.x << 16));
""".replace("fmt", fmt))

def unpack_4x8(fmt):
282
   unop_horiz("unpack_" + fmt + "_4x8", 4, tfloat32, 1, tuint32, """
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
dst.x = unpack_fmt_1x8((uint8_t)(src0.x & 0xff));
dst.y = unpack_fmt_1x8((uint8_t)((src0.x >> 8) & 0xff));
dst.z = unpack_fmt_1x8((uint8_t)((src0.x >> 16) & 0xff));
dst.w = unpack_fmt_1x8((uint8_t)(src0.x >> 24));
""".replace("fmt", fmt))


pack_2x16("snorm")
pack_4x8("snorm")
pack_2x16("unorm")
pack_4x8("unorm")
pack_2x16("half")
unpack_2x16("snorm")
unpack_4x8("snorm")
unpack_2x16("unorm")
unpack_4x8("unorm")
unpack_2x16("half")
300

301
unop_horiz("pack_uvec2_to_uint", 1, tuint32, 2, tuint32, """
302
dst.x = (src0.x & 0xffff) | (src0.y << 16);
303
304
""")

305
unop_horiz("pack_uvec4_to_uint", 1, tuint32, 4, tuint32, """
306
307
308
309
310
dst.x = (src0.x <<  0) |
        (src0.y <<  8) |
        (src0.z << 16) |
        (src0.w << 24);
""")
311

312
313
314
unop_horiz("pack_32_2x16", 1, tuint32, 2, tuint16,
           "dst.x = src0.x | ((uint32_t)src0.y << 16);")

315
unop_horiz("pack_64_2x32", 1, tuint64, 2, tuint32,
316
           "dst.x = src0.x | ((uint64_t)src0.y << 32);")
317

318
319
320
unop_horiz("pack_64_4x16", 1, tuint64, 4, tuint16,
           "dst.x = src0.x | ((uint64_t)src0.y << 16) | ((uint64_t)src0.z << 32) | ((uint64_t)src0.w << 48);")

321
unop_horiz("unpack_64_2x32", 2, tuint32, 1, tuint64,
322
323
           "dst.x = src0.x; dst.y = src0.x >> 32;")

324
325
326
327
328
329
unop_horiz("unpack_64_4x16", 4, tuint16, 1, tuint64,
           "dst.x = src0.x; dst.y = src0.x >> 16; dst.z = src0.x >> 32; dst.w = src0.w >> 48;")

unop_horiz("unpack_32_2x16", 2, tuint16, 1, tuint32,
           "dst.x = src0.x; dst.y = src0.x >> 16;")

330
331
332
# Lowered floating point unpacking operations.


333
334
335
336
unop_convert("unpack_half_2x16_split_x", tfloat32, tuint32,
             "unpack_half_1x16((uint16_t)(src0 & 0xffff))")
unop_convert("unpack_half_2x16_split_y", tfloat32, tuint32,
             "unpack_half_1x16((uint16_t)(src0 >> 16))")
337

338
339
340
unop_convert("unpack_32_2x16_split_x", tuint16, tuint32, "src0")
unop_convert("unpack_32_2x16_split_y", tuint16, tuint32, "src0 >> 16")

341
342
unop_convert("unpack_64_2x32_split_x", tuint32, tuint64, "src0")
unop_convert("unpack_64_2x32_split_y", tuint32, tuint64, "src0 >> 32")
343
344
345
346

# Bit operations, part of ARB_gpu_shader5.


347
unop("bitfield_reverse", tuint32, """
348
349
350
351
352
/* we're not winning any awards for speed here, but that's ok */
dst = 0;
for (unsigned bit = 0; bit < 32; bit++)
   dst |= ((src0 >> bit) & 1) << (31 - bit);
""")
353
unop_convert("bit_count", tuint32, tuint, """
354
dst = 0;
355
for (unsigned bit = 0; bit < bit_size; bit++) {
356
357
358
359
360
   if ((src0 >> bit) & 1)
      dst++;
}
""")

361
unop_convert("ufind_msb", tint32, tuint, """
362
dst = -1;
363
for (int bit = bit_size - 1; bit >= 0; bit--) {
364
365
366
367
368
369
370
   if ((src0 >> bit) & 1) {
      dst = bit;
      break;
   }
}
""")

371
unop("ifind_msb", tint32, """
372
373
374
375
376
377
378
379
380
381
382
383
384
dst = -1;
for (int bit = 31; bit >= 0; bit--) {
   /* If src0 < 0, we're looking for the first 0 bit.
    * if src0 >= 0, we're looking for the first 1 bit.
    */
   if ((((src0 >> bit) & 1) && (src0 >= 0)) ||
      (!((src0 >> bit) & 1) && (src0 < 0))) {
      dst = bit;
      break;
   }
}
""")

385
unop_convert("find_lsb", tint32, tint, """
386
dst = -1;
387
for (unsigned bit = 0; bit < bit_size; bit++) {
388
389
390
391
392
393
   if ((src0 >> bit) & 1) {
      dst = bit;
      break;
   }
}
""")
394
395


396
397
for i in range(1, 5):
   for j in range(1, 5):
398
      unop_horiz("fnoise{0}_{1}".format(i, j), i, tfloat, j, tfloat, "0.0f")
399

400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427

# AMD_gcn_shader extended instructions
unop_horiz("cube_face_coord", 2, tfloat32, 3, tfloat32, """
dst.x = dst.y = 0.0;
float absX = fabs(src0.x);
float absY = fabs(src0.y);
float absZ = fabs(src0.z);
if (src0.x >= 0 && absX >= absY && absX >= absZ) { dst.x = -src0.y; dst.y = -src0.z; }
if (src0.x < 0 && absX >= absY && absX >= absZ) { dst.x = -src0.y; dst.y = src0.z; }
if (src0.y >= 0 && absY >= absX && absY >= absZ) { dst.x = src0.z; dst.y = src0.x; }
if (src0.y < 0 && absY >= absX && absY >= absZ) { dst.x = -src0.z; dst.y = src0.x; }
if (src0.z >= 0 && absZ >= absX && absZ >= absY) { dst.x = -src0.y; dst.y = src0.x; }
if (src0.z < 0 && absZ >= absX && absZ >= absY) { dst.x = -src0.y; dst.y = -src0.x; }
""")

unop_horiz("cube_face_index", 1, tfloat32, 3, tfloat32, """
float absX = fabs(src0.x);
float absY = fabs(src0.y);
float absZ = fabs(src0.z);
if (src0.x >= 0 && absX >= absY && absX >= absZ) dst.x = 0;
if (src0.x < 0 && absX >= absY && absX >= absZ) dst.x = 1;
if (src0.y >= 0 && absY >= absX && absY >= absZ) dst.x = 2;
if (src0.y < 0 && absY >= absX && absY >= absZ) dst.x = 3;
if (src0.z >= 0 && absZ >= absX && absZ >= absY) dst.x = 4;
if (src0.z < 0 && absZ >= absX && absZ >= absY) dst.x = 5;
""")


428
429
def binop_convert(name, out_type, in_type, alg_props, const_expr):
   opcode(name, 0, out_type, [0, 0], [in_type, in_type], alg_props, const_expr)
430

431
432
def binop(name, ty, alg_props, const_expr):
   binop_convert(name, ty, ty, alg_props, const_expr)
433

434
435
436
def binop_compare(name, ty, alg_props, const_expr):
   binop_convert(name, tbool1, ty, alg_props, const_expr)

437
def binop_compare32(name, ty, alg_props, const_expr):
438
   binop_convert(name, tbool32, ty, alg_props, const_expr)
439
440

def binop_horiz(name, out_size, out_type, src1_size, src1_type, src2_size,
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
                src2_type, const_expr):
   opcode(name, out_size, out_type, [src1_size, src2_size], [src1_type, src2_type],
          "", const_expr)

def binop_reduce(name, output_size, output_type, src_type, prereduce_expr,
                 reduce_expr, final_expr):
   def final(src):
      return final_expr.format(src= "(" + src + ")")
   def reduce_(src0, src1):
      return reduce_expr.format(src0=src0, src1=src1)
   def prereduce(src0, src1):
      return "(" + prereduce_expr.format(src0=src0, src1=src1) + ")"
   src0 = prereduce("src0.x", "src1.x")
   src1 = prereduce("src0.y", "src1.y")
   src2 = prereduce("src0.z", "src1.z")
   src3 = prereduce("src0.w", "src1.w")
   opcode(name + "2", output_size, output_type,
          [2, 2], [src_type, src_type], commutative,
          final(reduce_(src0, src1)))
460
   opcode(name + "3", output_size, output_type,
461
462
          [3, 3], [src_type, src_type], commutative,
          final(reduce_(reduce_(src0, src1), src2)))
463
   opcode(name + "4", output_size, output_type,
464
465
          [4, 4], [src_type, src_type], commutative,
          final(reduce_(reduce_(src0, src1), reduce_(src2, src3))))
466

467
468
binop("fadd", tfloat, commutative + associative, "src0 + src1")
binop("iadd", tint, commutative + associative, "src0 + src1")
469
470
binop("uadd_sat", tuint, commutative,
      "(src0 + src1) < src0 ? UINT64_MAX : (src0 + src1)")
471
472
binop("fsub", tfloat, "", "src0 - src1")
binop("isub", tint, "", "src0 - src1")
473

474
binop("fmul", tfloat, commutative + associative, "src0 * src1")
475
# low 32-bits of signed/unsigned integer multiply
476
binop("imul", tint, commutative + associative, "src0 * src1")
477

478
# high 32-bits of signed integer multiply
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
binop("imul_high", tint, commutative, """
if (bit_size == 64) {
   /* We need to do a full 128-bit x 128-bit multiply in order for the sign
    * extension to work properly.  The casts are kind-of annoying but needed
    * to prevent compiler warnings.
    */
   uint32_t src0_u32[4] = {
      src0,
      (int64_t)src0 >> 32,
      (int64_t)src0 >> 63,
      (int64_t)src0 >> 63,
   };
   uint32_t src1_u32[4] = {
      src1,
      (int64_t)src1 >> 32,
      (int64_t)src1 >> 63,
      (int64_t)src1 >> 63,
   };
   uint32_t prod_u32[4];
   ubm_mul_u32arr(prod_u32, src0_u32, src1_u32);
   dst = (uint64_t)prod_u32[2] | ((uint64_t)prod_u32[3] << 32);
} else {
   dst = ((int64_t)src0 * (int64_t)src1) >> bit_size;
}
""")

505
# high 32-bits of unsigned integer multiply
506
507
508
509
510
511
512
513
514
515
516
517
binop("umul_high", tuint, commutative, """
if (bit_size == 64) {
   /* The casts are kind-of annoying but needed to prevent compiler warnings. */
   uint32_t src0_u32[2] = { src0, (uint64_t)src0 >> 32 };
   uint32_t src1_u32[2] = { src1, (uint64_t)src1 >> 32 };
   uint32_t prod_u32[4];
   ubm_mul_u32arr(prod_u32, src0_u32, src1_u32);
   dst = (uint64_t)prod_u32[2] | ((uint64_t)prod_u32[3] << 32);
} else {
   dst = ((uint64_t)src0 * (uint64_t)src1) >> bit_size;
}
""")
518

519
binop("fdiv", tfloat, "", "src0 / src1")
520
521
binop("idiv", tint, "", "src1 == 0 ? 0 : (src0 / src1)")
binop("udiv", tuint, "", "src1 == 0 ? 0 : (src0 / src1)")
522
523
524
525

# returns a boolean representing the carry resulting from the addition of
# the two unsigned arguments.

526
binop_convert("uadd_carry", tuint, tuint, commutative, "src0 + src1 < src0")
527
528
529
530

# returns a boolean representing the borrow resulting from the subtraction
# of the two unsigned arguments.

531
binop_convert("usub_borrow", tuint, tuint, "", "src0 < src1")
532

533
binop("umod", tuint, "", "src1 == 0 ? 0 : src0 % src1")
534

Jason Ekstrand's avatar
Jason Ekstrand committed
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
# For signed integers, there are several different possible definitions of
# "modulus" or "remainder".  We follow the conventions used by LLVM and
# SPIR-V.  The irem opcode implements the standard C/C++ signed "%"
# operation while the imod opcode implements the more mathematical
# "modulus" operation.  For details on the difference, see
#
# http://mathforum.org/library/drmath/view/52343.html

binop("irem", tint, "", "src1 == 0 ? 0 : src0 % src1")
binop("imod", tint, "",
      "src1 == 0 ? 0 : ((src0 % src1 == 0 || (src0 >= 0) == (src1 >= 0)) ?"
      "                 src0 % src1 : src0 % src1 + src1)")
binop("fmod", tfloat, "", "src0 - src1 * floorf(src0 / src1)")
binop("frem", tfloat, "", "src0 - src1 * truncf(src0 / src1)")

550
551
552
553
554
555
556
#
# Comparisons
#


# these integer-aware comparisons return a boolean (0 or ~0)

557
558
559
560
561
562
563
564
565
566
binop_compare("flt", tfloat, "", "src0 < src1")
binop_compare("fge", tfloat, "", "src0 >= src1")
binop_compare("feq", tfloat, commutative, "src0 == src1")
binop_compare("fne", tfloat, commutative, "src0 != src1")
binop_compare("ilt", tint, "", "src0 < src1")
binop_compare("ige", tint, "", "src0 >= src1")
binop_compare("ieq", tint, commutative, "src0 == src1")
binop_compare("ine", tint, commutative, "src0 != src1")
binop_compare("ult", tuint, "", "src0 < src1")
binop_compare("uge", tuint, "", "src0 >= src1")
567
568
569
570
571
572
573
574
575
576
binop_compare32("flt32", tfloat, "", "src0 < src1")
binop_compare32("fge32", tfloat, "", "src0 >= src1")
binop_compare32("feq32", tfloat, commutative, "src0 == src1")
binop_compare32("fne32", tfloat, commutative, "src0 != src1")
binop_compare32("ilt32", tint, "", "src0 < src1")
binop_compare32("ige32", tint, "", "src0 >= src1")
binop_compare32("ieq32", tint, commutative, "src0 == src1")
binop_compare32("ine32", tint, commutative, "src0 != src1")
binop_compare32("ult32", tuint, "", "src0 < src1")
binop_compare32("uge32", tuint, "", "src0 >= src1")
577
578
579

# integer-aware GLSL-style comparisons that compare floats and ints

580
581
582
583
584
585
586
587
588
binop_reduce("ball_fequal",  1, tbool1, tfloat, "{src0} == {src1}",
             "{src0} && {src1}", "{src}")
binop_reduce("bany_fnequal", 1, tbool1, tfloat, "{src0} != {src1}",
             "{src0} || {src1}", "{src}")
binop_reduce("ball_iequal",  1, tbool1, tint, "{src0} == {src1}",
             "{src0} && {src1}", "{src}")
binop_reduce("bany_inequal", 1, tbool1, tint, "{src0} != {src1}",
             "{src0} || {src1}", "{src}")

589
binop_reduce("b32all_fequal",  1, tbool32, tfloat, "{src0} == {src1}",
590
             "{src0} && {src1}", "{src}")
591
binop_reduce("b32any_fnequal", 1, tbool32, tfloat, "{src0} != {src1}",
592
             "{src0} || {src1}", "{src}")
593
binop_reduce("b32all_iequal",  1, tbool32, tint, "{src0} == {src1}",
594
             "{src0} && {src1}", "{src}")
595
binop_reduce("b32any_inequal", 1, tbool32, tint, "{src0} != {src1}",
596
             "{src0} || {src1}", "{src}")
597
598
599

# non-integer-aware GLSL-style comparisons that return 0.0 or 1.0

600
binop_reduce("fall_equal",  1, tfloat32, tfloat32, "{src0} == {src1}",
601
             "{src0} && {src1}", "{src} ? 1.0f : 0.0f")
602
binop_reduce("fany_nequal", 1, tfloat32, tfloat32, "{src0} != {src1}",
603
             "{src0} || {src1}", "{src} ? 1.0f : 0.0f")
604
605
606
607

# These comparisons for integer-less hardware return 1.0 and 0.0 for true
# and false respectively

608
binop("slt", tfloat32, "", "(src0 < src1) ? 1.0f : 0.0f") # Set on Less Than
609
binop("sge", tfloat, "", "(src0 >= src1) ? 1.0f : 0.0f") # Set on Greater or Equal
610
611
binop("seq", tfloat32, commutative, "(src0 == src1) ? 1.0f : 0.0f") # Set on Equal
binop("sne", tfloat32, commutative, "(src0 != src1) ? 1.0f : 0.0f") # Set on Not Equal
612

613
614
615
616
617
618
# SPIRV shifts are undefined for shift-operands >= bitsize,
# but SM5 shifts are defined to use the least significant bits, only
# The NIR definition is according to the SM5 specification.
opcode("ishl", 0, tint, [0, 0], [tint, tuint32], "", "src0 << (src1 & (sizeof(src0) * 8 - 1))")
opcode("ishr", 0, tint, [0, 0], [tint, tuint32], "", "src0 >> (src1 & (sizeof(src0) * 8 - 1))")
opcode("ushr", 0, tuint, [0, 0], [tuint, tuint32], "", "src0 >> (src1 & (sizeof(src0) * 8 - 1))")
619
620
621
622
623
624
625

# bitwise logic operators
#
# These are also used as boolean and, or, xor for hardware supporting
# integers.


626
627
628
binop("iand", tuint, commutative + associative, "src0 & src1")
binop("ior", tuint, commutative + associative, "src0 | src1")
binop("ixor", tuint, commutative + associative, "src0 ^ src1")
629
630
631
632
633
634
635


# floating point logic operators
#
# These use (src != 0.0) for testing the truth of the input, and output 1.0
# for true and 0.0 for false

636
binop("fand", tfloat32, commutative,
637
      "((src0 != 0.0f) && (src1 != 0.0f)) ? 1.0f : 0.0f")
638
binop("for", tfloat32, commutative,
639
      "((src0 != 0.0f) || (src1 != 0.0f)) ? 1.0f : 0.0f")
640
binop("fxor", tfloat32, commutative,
641
642
643
644
645
      "(src0 != 0.0f && src1 == 0.0f) || (src0 == 0.0f && src1 != 0.0f) ? 1.0f : 0.0f")

binop_reduce("fdot", 1, tfloat, tfloat, "{src0} * {src1}", "{src0} + {src1}",
             "{src}")

646
647
648
binop_reduce("fdot_replicated", 4, tfloat, tfloat,
             "{src0} * {src1}", "{src0} + {src1}", "{src}")

649
650
651
652
653
opcode("fdph", 1, tfloat, [3, 4], [tfloat, tfloat], "",
       "src0.x * src1.x + src0.y * src1.y + src0.z * src1.z + src1.w")
opcode("fdph_replicated", 4, tfloat, [3, 4], [tfloat, tfloat], "",
       "src0.x * src1.x + src0.y * src1.y + src0.z * src1.z + src1.w")

654
655
binop("fmin", tfloat, "", "fminf(src0, src1)")
binop("imin", tint, commutative + associative, "src1 > src0 ? src0 : src1")
656
binop("umin", tuint, commutative + associative, "src1 > src0 ? src0 : src1")
657
658
binop("fmax", tfloat, "", "fmaxf(src0, src1)")
binop("imax", tint, commutative + associative, "src1 > src0 ? src1 : src0")
659
binop("umax", tuint, commutative + associative, "src1 > src0 ? src1 : src0")
660

661
# Saturated vector add for 4 8bit ints.
662
binop("usadd_4x8", tint32, commutative + associative, """
663
664
665
666
667
668
669
dst = 0;
for (int i = 0; i < 32; i += 8) {
   dst |= MIN2(((src0 >> i) & 0xff) + ((src1 >> i) & 0xff), 0xff) << i;
}
""")

# Saturated vector subtract for 4 8bit ints.
670
binop("ussub_4x8", tint32, "", """
671
672
673
674
675
676
677
678
679
680
dst = 0;
for (int i = 0; i < 32; i += 8) {
   int src0_chan = (src0 >> i) & 0xff;
   int src1_chan = (src1 >> i) & 0xff;
   if (src0_chan > src1_chan)
      dst |= (src0_chan - src1_chan) << i;
}
""")

# vector min for 4 8bit ints.
681
binop("umin_4x8", tint32, commutative + associative, """
682
683
684
685
686
687
688
dst = 0;
for (int i = 0; i < 32; i += 8) {
   dst |= MIN2((src0 >> i) & 0xff, (src1 >> i) & 0xff) << i;
}
""")

# vector max for 4 8bit ints.
689
binop("umax_4x8", tint32, commutative + associative, """
690
691
692
693
694
695
696
dst = 0;
for (int i = 0; i < 32; i += 8) {
   dst |= MAX2((src0 >> i) & 0xff, (src1 >> i) & 0xff) << i;
}
""")

# unorm multiply: (a * b) / 255.
697
binop("umul_unorm_4x8", tint32, commutative + associative, """
698
699
700
701
702
703
704
705
dst = 0;
for (int i = 0; i < 32; i += 8) {
   int src0_chan = (src0 >> i) & 0xff;
   int src1_chan = (src1 >> i) & 0xff;
   dst |= ((src0_chan * src1_chan) / 255) << i;
}
""")

706
binop("fpow", tfloat, "", "bit_size == 64 ? powf(src0, src1) : pow(src0, src1)")
707

708
binop_horiz("pack_half_2x16_split", 1, tuint32, 1, tfloat32, 1, tfloat32,
709
710
            "pack_half_1x16(src0.x) | (pack_half_1x16(src1.x) << 16)")

711
binop_convert("pack_64_2x32_split", tuint64, tuint32, "",
712
713
              "src0 | ((uint64_t)src1 << 32)")

714
715
716
binop_convert("pack_32_2x16_split", tuint32, tuint16, "",
              "src0 | ((uint32_t)src1 << 16)")

717
718
719
# bfm implements the behavior of the first operation of the SM5 "bfi" assembly
# and that of the "bfi1" i965 instruction. That is, it has undefined behavior
# if either of its arguments are 32.
720
binop_convert("bfm", tuint32, tint32, "", """
721
int bits = src0, offset = src1;
722
723
if (offset < 0 || bits < 0 || offset > 31 || bits > 31 || offset + bits > 32)
   dst = 0; /* undefined */
724
else
725
   dst = ((1u << bits) - 1) << offset;
726
727
""")

728
opcode("ldexp", 0, tfloat, [0, 0], [tfloat, tint32], "", """
729
dst = (bit_size == 64) ? ldexp(src0, src1) : ldexpf(src0, src1);
730
/* flush denormals to zero. */
731
if (!isnormal(dst))
Matt Turner's avatar
Matt Turner committed
732
   dst = copysignf(0.0f, src0);
733
""")
734
735
736

# Combines the first component of each input to make a 2-component vector.

737
binop_horiz("vec2", 2, tuint, 1, tuint, 1, tuint, """
738
739
740
dst.x = src0.x;
dst.y = src1.x;
""")
741

742
743
744
745
746
747
748
749
750
# Byte extraction
binop("extract_u8", tuint, "", "(uint8_t)(src0 >> (src1 * 8))")
binop("extract_i8", tint, "", "(int8_t)(src0 >> (src1 * 8))")

# Word extraction
binop("extract_u16", tuint, "", "(uint16_t)(src0 >> (src1 * 16))")
binop("extract_i16", tint, "", "(int16_t)(src0 >> (src1 * 16))")


751
752
753
def triop(name, ty, const_expr):
   opcode(name, 0, ty, [0, 0, 0], [ty, ty, ty], "", const_expr)
def triop_horiz(name, output_size, src1_size, src2_size, src3_size, const_expr):
754
   opcode(name, output_size, tuint,
755
   [src1_size, src2_size, src3_size],
756
   [tuint, tuint, tuint], "", const_expr)
757

758
triop("ffma", tfloat, "src0 * src1 + src2")
759

760
triop("flrp", tfloat, "src0 * (1 - src2) + src1 * src2")
761
762
763
764
765
766
767
768

# Conditional Select
#
# A vector conditional select instruction (like ?:, but operating per-
# component on vectors). There are two versions, one for floating point
# bools (0.0 vs 1.0) and one for integer bools (0 vs ~0).


769
triop("fcsel", tfloat32, "(src0 != 0.0f) ? src1 : src2")
770
771
772
773
774
775
776
777
778
779
780
781
782
783

# 3 way min/max/med
triop("fmin3", tfloat, "fminf(src0, fminf(src1, src2))")
triop("imin3", tint, "MIN2(src0, MIN2(src1, src2))")
triop("umin3", tuint, "MIN2(src0, MIN2(src1, src2))")

triop("fmax3", tfloat, "fmaxf(src0, fmaxf(src1, src2))")
triop("imax3", tint, "MAX2(src0, MAX2(src1, src2))")
triop("umax3", tuint, "MAX2(src0, MAX2(src1, src2))")

triop("fmed3", tfloat, "fmaxf(fminf(fmaxf(src0, src1), src2), fminf(src0, src1))")
triop("imed3", tint, "MAX2(MIN2(MAX2(src0, src1), src2), MIN2(src0, src1))")
triop("umed3", tuint, "MAX2(MIN2(MAX2(src0, src1), src2), MIN2(src0, src1))")

784
785
opcode("bcsel", 0, tuint, [0, 0, 0],
      [tbool1, tuint, tuint], "", "src0 ? src1 : src2")
786
787
opcode("b32csel", 0, tuint, [0, 0, 0],
       [tbool32, tuint, tuint], "", "src0 ? src1 : src2")
788

789
# SM5 bfi assembly
790
triop("bfi", tuint32, """
791
unsigned mask = src0, insert = src1, base = src2;
792
793
794
795
796
797
798
799
if (mask == 0) {
   dst = base;
} else {
   unsigned tmp = mask;
   while (!(tmp & 1)) {
      tmp >>= 1;
      insert <<= 1;
   }
800
   dst = (base & ~mask) | (insert & mask);
801
802
803
}
""")

Matt Turner's avatar
Matt Turner committed
804
# SM5 ubfe/ibfe assembly
805
806
opcode("ubfe", 0, tuint32,
       [0, 0, 0], [tuint32, tint32, tint32], "", """
Matt Turner's avatar
Matt Turner committed
807
808
809
810
811
812
813
814
815
816
817
818
unsigned base = src0;
int offset = src1, bits = src2;
if (bits == 0) {
   dst = 0;
} else if (bits < 0 || offset < 0) {
   dst = 0; /* undefined */
} else if (offset + bits < 32) {
   dst = (base << (32 - bits - offset)) >> (32 - bits);
} else {
   dst = base >> offset;
}
""")
819
820
opcode("ibfe", 0, tint32,
       [0, 0, 0], [tint32, tint32, tint32], "", """
Matt Turner's avatar
Matt Turner committed
821
822
823
824
825
826
827
828
829
830
831
832
833
834
int base = src0;
int offset = src1, bits = src2;
if (bits == 0) {
   dst = 0;
} else if (bits < 0 || offset < 0) {
   dst = 0; /* undefined */
} else if (offset + bits < 32) {
   dst = (base << (32 - bits - offset)) >> (32 - bits);
} else {
   dst = base >> offset;
}
""")

# GLSL bitfieldExtract()
835
836
opcode("ubitfield_extract", 0, tuint32,
       [0, 0, 0], [tuint32, tint32, tint32], "", """
837
unsigned base = src0;
838
int offset = src1, bits = src2;
839
840
841
842
843
if (bits == 0) {
   dst = 0;
} else if (bits < 0 || offset < 0 || offset + bits > 32) {
   dst = 0; /* undefined per the spec */
} else {
Matt Turner's avatar
Matt Turner committed
844
   dst = (base >> offset) & ((1ull << bits) - 1);
845
846
}
""")
847
848
opcode("ibitfield_extract", 0, tint32,
       [0, 0, 0], [tint32, tint32, tint32], "", """
849
int base = src0;
850
int offset = src1, bits = src2;
851
852
853
854
855
856
857
858
if (bits == 0) {
   dst = 0;
} else if (offset < 0 || bits < 0 || offset + bits > 32) {
   dst = 0;
} else {
   dst = (base << (32 - offset - bits)) >> offset; /* use sign-extending shift */
}
""")
859
860
861

# Combines the first component of each input to make a 3-component vector.

862
863
864
865
866
triop_horiz("vec3", 3, 1, 1, 1, """
dst.x = src0.x;
dst.y = src1.x;
dst.z = src2.x;
""")
867

868
869
def quadop_horiz(name, output_size, src1_size, src2_size, src3_size,
                 src4_size, const_expr):
870
   opcode(name, output_size, tuint,
871
          [src1_size, src2_size, src3_size, src4_size],
872
          [tuint, tuint, tuint, tuint],
873
874
          "", const_expr)

875
876
opcode("bitfield_insert", 0, tuint32, [0, 0, 0, 0],
       [tuint32, tuint32, tint32, tint32], "", """
877
unsigned base = src0, insert = src1;
878
int offset = src2, bits = src3;
879
if (bits == 0) {
880
   dst = base;
881
882
883
} else if (offset < 0 || bits < 0 || bits + offset > 32) {
   dst = 0;
} else {
Matt Turner's avatar
Matt Turner committed
884
   unsigned mask = ((1ull << bits) - 1) << offset;
885
   dst = (base & ~mask) | ((insert << offset) & mask);
886
887
888
889
890
891
892
893
894
}
""")

quadop_horiz("vec4", 4, 1, 1, 1, 1, """
dst.x = src0.x;
dst.y = src1.x;
dst.z = src2.x;
dst.w = src3.x;
""")
895
896