nir: Rework conversion opcodes

The NIR story on conversion opcodes is a mess.  We've had way too many
of them, naming is inconsistent, and which ones have explicit sizes was
sort-of random.  This commit re-organizes things and makes them all
consistent:

 - All non-bool conversion opcodes now have the explicit size in the
   destination and are named <src_type>2<dst_type><size>.

 - Integer <-> integer conversion opcodes now only come in i2i and u2u
   forms (i2u and u2i have been removed) since the only difference
   between the different integer conversions is whether or not they
   sign-extend when up-converting.

 - Boolean conversion opcodes all have the explicit size on the bool and
   are named <src_type>2<dst_type>.

Making things consistent also allows nir_type_conversion_op to be moved
to nir_opcodes.c and auto-generated using mako.  This will make adding
int8, int16, and float16 versions much easier when the time comes.

Reviewed-by: Eric Anholt <eric@anholt.net>

1 files changed, 0 insertions, 122 deletions

diff --git a/src/compiler/nir/nir.c b/src/compiler/nir/nir.c
index 37fd9cb5c5..937b630062 100644
--- a/src/compiler/nir/nir.c
+++ b/src/compiler/nir/nir.c
@@ -1958,125 +1958,3 @@ nir_system_value_from_intrinsic(nir_intrinsic_op intrin)
       unreachable("intrinsic doesn't produce a system value");
    }
 }
-
-nir_op
-nir_type_conversion_op(nir_alu_type src, nir_alu_type dst)
-{
-   nir_alu_type src_base_type = (nir_alu_type) nir_alu_type_get_base_type(src);
-   nir_alu_type dst_base_type = (nir_alu_type) nir_alu_type_get_base_type(dst);
-   unsigned src_bitsize = nir_alu_type_get_type_size(src);
-   unsigned dst_bitsize = nir_alu_type_get_type_size(dst);
-
-   if (src_bitsize == dst_bitsize) {
-      switch (src_base_type) {
-      case nir_type_int:
-      case nir_type_uint:
-         if (dst_base_type == nir_type_uint || dst_base_type == nir_type_int)
-            return nir_op_imov;
-         break;
-      case nir_type_float:
-         if (dst_base_type == nir_type_float)
-            return nir_op_fmov;
-         break;
-      case nir_type_bool:
-         if (dst_base_type == nir_type_bool)
-            return nir_op_imov;
-         break;
-      default:
-         unreachable("Invalid conversion");
-      }
-   }
-
-   switch (src_base_type) {
-   case nir_type_int:
-      switch (dst_base_type) {
-      case nir_type_int:
-         assert(src_bitsize != dst_bitsize);
-         return (dst_bitsize == 32) ? nir_op_i2i32 : nir_op_i2i64;
-      case nir_type_uint:
-         assert(src_bitsize != dst_bitsize);
-         return (dst_bitsize == 32) ? nir_op_i2u32 : nir_op_i2u64;
-      case nir_type_float:
-         switch (src_bitsize) {
-         case 32:
-            return (dst_bitsize == 32) ? nir_op_i2f : nir_op_i2d;
-         case 64:
-            return (dst_bitsize == 32) ? nir_op_i642f : nir_op_i642d;
-         default:
-            unreachable("Invalid conversion");
-         }
-      case nir_type_bool:
-         return (src_bitsize == 32) ? nir_op_i2b : nir_op_i642b;
-      default:
-         unreachable("Invalid conversion");
-      }
-
-   case nir_type_uint:
-      switch (dst_base_type) {
-      case nir_type_int:
-         assert(src_bitsize != dst_bitsize);
-         return (dst_bitsize == 32) ? nir_op_u2i32 : nir_op_u2i64;
-      case nir_type_uint:
-         assert(src_bitsize != dst_bitsize);
-         return (dst_bitsize == 32) ? nir_op_u2u32 : nir_op_u2u64;
-      case nir_type_float:
-         switch (src_bitsize) {
-         case 32:
-            return (dst_bitsize == 32) ? nir_op_u2f : nir_op_u2d;
-         case 64:
-            return (dst_bitsize == 32) ? nir_op_u642f : nir_op_u642d;
-         default:
-            unreachable("Invalid conversion");
-         }
-      case nir_type_bool:
-         return (src_bitsize == 32) ? nir_op_i2b : nir_op_i642b;
-      default:
-         unreachable("Invalid conversion");
-      }
-
-   case nir_type_float:
-      switch (dst_base_type) {
-      case nir_type_int:
-         switch (src_bitsize) {
-         case 32:
-            return (dst_bitsize == 32) ? nir_op_f2i : nir_op_f2i64;
-         case 64:
-            return (dst_bitsize == 32) ? nir_op_d2i : nir_op_f2i64;
-         default:
-            unreachable("Invalid conversion");
-         }
-      case nir_type_uint:
-         switch (src_bitsize) {
-         case 32:
-            return (dst_bitsize == 32) ? nir_op_f2u : nir_op_f2u64;
-         case 64:
-            return (dst_bitsize == 32) ? nir_op_d2u : nir_op_f2u64;
-         default:
-            unreachable("Invalid conversion");
-         }
-      case nir_type_float:
-         assert(src_bitsize != dst_bitsize);
-         return (dst_bitsize == 32) ? nir_op_d2f : nir_op_f2d;
-      case nir_type_bool:
-         return (src_bitsize == 32) ? nir_op_f2b : nir_op_d2b;
-      default:
-         unreachable("Invalid conversion");
-      }
-
-   case nir_type_bool:
-      switch (dst_base_type) {
-      case nir_type_int:
-      case nir_type_uint:
-         return (dst_bitsize == 32) ? nir_op_b2i : nir_op_b2i64;
-      case nir_type_float:
-         /* GLSL just emits f2d(b2f(x)) for b2d */
-         assert(dst_bitsize == 32);
-         return nir_op_b2f;
-      default:
-         unreachable("Invalid conversion");
-      }
-
-   default:
-      unreachable("Invalid conversion");
-   }
-}