nir/algebraic: Add missing 16-bit extract_[iu]8 patterns

[mesa.git] / src / compiler / nir / nir_opt_constant_folding.c

diff --git a/src/compiler/nir/nir_opt_constant_folding.c b/src/compiler/nir/nir_opt_constant_folding.c
index b10bb234fd33ceeea45baf3e3d511e01d2427f35..83be0d78dbd7d48b6dceab9c712cc4694e1115e7 100644 (file)
--- a/src/compiler/nir/nir_opt_constant_folding.c
+++ b/src/compiler/nir/nir_opt_constant_folding.c
@@ -41,7 +41,7 @@ struct constant_fold_state {
 static bool
 constant_fold_alu_instr(nir_alu_instr *instr, void *mem_ctx)
 {
-   nir_const_value src[4];
+   nir_const_value src[NIR_MAX_VEC_COMPONENTS];
 
    if (!instr->dest.dest.is_ssa)
       return false;
@@ -64,9 +64,8 @@ constant_fold_alu_instr(nir_alu_instr *instr, void *mem_ctx)
          return false;
 
       if (bit_size == 0 &&
-          !nir_alu_type_get_type_size(nir_op_infos[instr->op].input_sizes[i])) {
+          !nir_alu_type_get_type_size(nir_op_infos[instr->op].input_types[i]))
          bit_size = instr->src[i].src.ssa->bit_size;
-      }
 
       nir_instr *src_instr = instr->src[i].src.ssa->parent_instr;
 
@@ -76,10 +75,25 @@ constant_fold_alu_instr(nir_alu_instr *instr, void *mem_ctx)
 
       for (unsigned j = 0; j < nir_ssa_alu_instr_src_components(instr, i);
            j++) {
-         if (load_const->def.bit_size == 64)
+         switch(load_const->def.bit_size) {
+         case 64:
             src[i].u64[j] = load_const->value.u64[instr->src[i].swizzle[j]];
-         else
+            break;
+         case 32:
             src[i].u32[j] = load_const->value.u32[instr->src[i].swizzle[j]];
+            break;
+         case 16:
+            src[i].u16[j] = load_const->value.u16[instr->src[i].swizzle[j]];
+            break;
+         case 8:
+            src[i].u8[j] = load_const->value.u8[instr->src[i].swizzle[j]];
+            break;
+         case 1:
+            src[i].b[j] = load_const->value.b[instr->src[i].swizzle[j]];
+            break;
+         default:
+            unreachable("Invalid bit size");
+         }
       }
 
       /* We shouldn't have any source modifiers in the optimization loop. */
@@ -115,29 +129,30 @@ constant_fold_alu_instr(nir_alu_instr *instr, void *mem_ctx)
 }
 
 static bool
-constant_fold_deref(nir_instr *instr, nir_deref_var *deref)
+constant_fold_intrinsic_instr(nir_intrinsic_instr *instr)
 {
    bool progress = false;
 
-   for (nir_deref *tail = deref->deref.child; tail; tail = tail->child) {
-      if (tail->deref_type != nir_deref_type_array)
-         continue;
-
-      nir_deref_array *arr = nir_deref_as_array(tail);
-
-      if (arr->deref_array_type == nir_deref_array_type_indirect &&
-          arr->indirect.is_ssa &&
-          arr->indirect.ssa->parent_instr->type == nir_instr_type_load_const) {
-         nir_load_const_instr *indirect =
-            nir_instr_as_load_const(arr->indirect.ssa->parent_instr);
-
-         arr->base_offset += indirect->value.u32[0];
-
-         /* Clear out the source */
-         nir_instr_rewrite_src(instr, &arr->indirect, nir_src_for_ssa(NULL));
-
-         arr->deref_array_type = nir_deref_array_type_direct;
-
+   if (instr->intrinsic == nir_intrinsic_discard_if &&
+       nir_src_is_const(instr->src[0])) {
+      if (nir_src_as_bool(instr->src[0])) {
+         /* This method of getting a nir_shader * from a nir_instr is
+          * admittedly gross, but given the rarity of hitting this case I think
+          * it's preferable to plumbing an otherwise unused nir_shader *
+          * parameter through four functions to get here.
+          */
+         nir_cf_node *cf_node = &instr->instr.block->cf_node;
+         nir_function_impl *impl = nir_cf_node_get_function(cf_node);
+         nir_shader *shader = impl->function->shader;
+
+         nir_intrinsic_instr *discard =
+            nir_intrinsic_instr_create(shader, nir_intrinsic_discard);
+         nir_instr_insert_before(&instr->instr, &discard->instr);
+         nir_instr_remove(&instr->instr);
+         progress = true;
+      } else {
+         /* We're not discarding, just delete the instruction */
+         nir_instr_remove(&instr->instr);
          progress = true;
       }
    }
@@ -145,33 +160,6 @@ constant_fold_deref(nir_instr *instr, nir_deref_var *deref)
    return progress;
 }
 
-static bool
-constant_fold_intrinsic_instr(nir_intrinsic_instr *instr)
-{
-   bool progress = false;
-
-   unsigned num_vars = nir_intrinsic_infos[instr->intrinsic].num_variables;
-   for (unsigned i = 0; i < num_vars; i++) {
-      progress |= constant_fold_deref(&instr->instr, instr->variables[i]);
-   }
-
-   return progress;
-}
-
-static bool
-constant_fold_tex_instr(nir_tex_instr *instr)
-{
-   bool progress = false;
-
-   if (instr->texture)
-      progress |= constant_fold_deref(&instr->instr, instr->texture);
-
-   if (instr->sampler)
-      progress |= constant_fold_deref(&instr->instr, instr->sampler);
-
-   return progress;
-}
-
 static bool
 constant_fold_block(nir_block *block, void *mem_ctx)
 {
@@ -186,9 +174,6 @@ constant_fold_block(nir_block *block, void *mem_ctx)
          progress |=
             constant_fold_intrinsic_instr(nir_instr_as_intrinsic(instr));
          break;
-      case nir_instr_type_tex:
-         progress |= constant_fold_tex_instr(nir_instr_as_tex(instr));
-         break;
       default:
          /* Don't know how to constant fold */
          break;
@@ -208,9 +193,14 @@ nir_opt_constant_folding_impl(nir_function_impl *impl)
       progress |= constant_fold_block(block, mem_ctx);
    }
 
-   if (progress)
+   if (progress) {
       nir_metadata_preserve(impl, nir_metadata_block_index |
                                   nir_metadata_dominance);
+   } else {
+#ifndef NDEBUG
+      impl->valid_metadata &= ~nir_metadata_not_properly_reset;
+#endif
+   }
 
    return progress;
 }
@@ -220,7 +210,7 @@ nir_opt_constant_folding(nir_shader *shader)
 {
    bool progress = false;
 
-   nir_foreach_function(shader, function) {
+   nir_foreach_function(function, shader) {
       if (function->impl)
          progress |= nir_opt_constant_folding_impl(function->impl);
    }