b = 'b'
c = 'c'
+algebraic = [
+ (('pack_unorm_4x8', a), ('pack_32_4x8', ('f2u8', ('fround_even', ('fmul', ('fsat', a), 255.0))))),
+
+ # Allows us to schedule as a multiply by 2
+ (('~fadd', ('fadd', a, b), a), ('fadd', ('fadd', a, a), b)),
+]
+
algebraic_late = [
# ineg must be lowered late, but only for integers; floats will try to
# have modifiers attached... hence why this has to be here rather than
(('ineg', a), ('isub', 0, a)),
+ # Likewise we want fsub lowered but not isub
+ (('fsub', a, b), ('fadd', a, ('fneg', b))),
+
# These two special-cases save space/an op than the actual csel op +
# scheduler flexibility
(('b32csel', a, 'b@32', 0), ('iand', a, b)),
(('b32csel', a, 0, 'b@32'), ('iand', ('inot', a), b)),
-]
+ # Fuse sat_signed. This should probably be shared with Bifrost
+ (('~fmin', ('fmax', a, -1.0), 1.0), ('fsat_signed', a)),
+ (('~fmax', ('fmin', a, 1.0), -1.0), ('fsat_signed', a)),
-# Midgard is able to type convert down by only one "step" per instruction; if
-# NIR wants more than one step, we need to break up into multiple instructions
+ # Fuse clamp_positive. This should probably be shared with Utgard/bifrost
+ (('fmax', a, 0.0), ('fclamp_pos', a)),
-converts = [
- (('i2i8', 'a@32'), ('i2i8', ('i2i16', a))),
- (('u2u8', 'a@32'), ('u2u8', ('u2u16', a))),
+ (('ishl', 'a@16', b), ('u2u16', ('ishl', ('u2u32', a), b))),
+ (('ishr', 'a@16', b), ('i2i16', ('ishr', ('i2i32', a), b))),
+ (('ushr', 'a@16', b), ('u2u16', ('ushr', ('u2u32', a), b))),
- (('i2i32', 'a@8'), ('i2i32', ('i2i16', a))),
- (('u2u32', 'a@8'), ('u2u32', ('u2u16', a))),
+ (('ishl', 'a@8', b), ('u2u8', ('u2u16', ('ishl', ('u2u32', ('u2u16', a)), b)))),
+ (('ishr', 'a@8', b), ('i2i8', ('i2i16', ('ishr', ('i2i32', ('i2i16', a)), b)))),
+ (('ushr', 'a@8', b), ('u2u8', ('u2u16', ('ushr', ('u2u32', ('u2u16', a)), b)))),
+
+ # Canonical form. The scheduler will convert back if it makes sense.
+ (('fmul', a, 2.0), ('fadd', a, a))
+]
- (('f2i32', 'a@16'), ('f2i32', ('f2f32', a))),
- (('f2u32', 'a@16'), ('f2u32', ('f2f32', a))),
- # Totally redundant
- (('~f2f16', ('f2f32', 'a@16')), a),
+# Midgard is able to type convert down by only one "step" per instruction; if
+# NIR wants more than one step, we need to break up into multiple instructions.
+# Nevertheless, we can do both a size step and a floating/int step at once.
+
+converts = []
+
+for op in ('u2u', 'i2i', 'f2f', 'i2f', 'u2f', 'f2i', 'f2u'):
+ srcsz_max = 64
+ dstsz_max = 64
+ # 8 bit float doesn't exist
+ srcsz_min = 8 if op[0] != 'f' else 16
+ dstsz_min = 8 if op[2] != 'f' else 16
+ dstsz = dstsz_min
+ # Iterate over all possible destination and source sizes
+ while dstsz <= dstsz_max:
+ srcsz = srcsz_min
+ while srcsz <= srcsz_max:
+ # Size converter lowering is only needed if src and dst sizes are
+ # spaced by a factor > 2.
+ if srcsz != dstsz and (srcsz * 2 != dstsz and srcsz != dstsz * 2):
+ cursz = srcsz
+ rule = a
+ # When converting down we first do the type conversion followed
+ # by one or more size conversions. When converting up, we do
+ # the type conversion at the end. This way we don't have to
+ # deal with the fact that f2f8 doesn't exists.
+ sizeconvop = op[0] + '2' + op[0] if srcsz < dstsz else op[2] + '2' + op[2]
+ if srcsz > dstsz and op[0] != op[2]:
+ rule = (op + str(int(cursz)), rule)
+ while cursz != dstsz:
+ cursz = cursz / 2 if dstsz < srcsz else cursz * 2
+ rule = (sizeconvop + str(int(cursz)), rule)
+ if srcsz < dstsz and op[0] != op[2]:
+ rule = (op + str(int(cursz)), rule)
+ converts += [((op + str(int(dstsz)), 'a@' + str(int(srcsz))), rule)]
+ srcsz *= 2
+ dstsz *= 2
+
+# Try to force constants to the right
+constant_switch = [
+ # fge gets flipped to fle, so we invert to keep the order
+ (('fge', 'a', '#b'), (('inot', ('flt', a, b)))),
+ (('fge32', 'a', '#b'), (('inot', ('flt32', a, b)))),
+ (('ige32', 'a', '#b'), (('inot', ('ilt32', a, b)))),
+ (('uge32', 'a', '#b'), (('inot', ('ult32', a, b)))),
+
+ # fge gets mapped to fle with a flip
+ (('flt32', '#a', 'b'), ('inot', ('fge32', a, b))),
+ (('ilt32', '#a', 'b'), ('inot', ('ige32', a, b))),
+ (('ult32', '#a', 'b'), ('inot', ('uge32', a, b)))
+]
- (('pack_half_2x16_split', 'a@32', 'b@32'), ('ior', ('ishl', ('i2i32', ('f2f16', b)), 16), ('i2i32', ('f2f16', a)))),
+# ..since the above switching happens after algebraic stuff is done
+cancel_inot = [
+ (('inot', ('inot', a)), a)
]
# Midgard scales fsin/fcos arguments by pi.
print('#include "midgard_nir.h"')
+ print(nir_algebraic.AlgebraicPass("midgard_nir_lower_algebraic_early",
+ algebraic).render())
+
print(nir_algebraic.AlgebraicPass("midgard_nir_lower_algebraic_late",
- algebraic_late + converts).render())
+ algebraic_late + converts + constant_switch).render())
print(nir_algebraic.AlgebraicPass("midgard_nir_scale_trig",
scale_trig).render())
+ print(nir_algebraic.AlgebraicPass("midgard_nir_cancel_inot",
+ cancel_inot).render())
+
if __name__ == '__main__':
main()
projects / mesa.git / blobdiff