diff --git a/src/intel/compiler/brw_compile_fs.cpp b/src/intel/compiler/brw_compile_fs.cpp
index 65939b69316..8afb1c7f57b 100644
--- a/src/intel/compiler/brw_compile_fs.cpp
+++ b/src/intel/compiler/brw_compile_fs.cpp
@@ -1621,141 +1621,144 @@ brw_compile_fs(const struct brw_compiler *compiler,
                                " pixel shading.\n");
    }
 
-   if ((!has_spilled && (!v8 || v8->max_dispatch_width >= 16) &&
-        INTEL_SIMD(FS, 16)) ||
-       reqd_dispatch_width == SUBGROUP_SIZE_REQUIRE_16) {
-      /* Try a SIMD16 compile */
-      v16 = std::make_unique<fs_visitor>(compiler, &params->base, key,
-                                         prog_data, nir, 16, 1,
-                                         params->base.stats != NULL,
-                                         debug_enabled);
-      if (v8)
-         v16->import_uniforms(v8.get());
-      if (!run_fs(*v16, allow_spilling, params->use_rep_send)) {
-         brw_shader_perf_log(compiler, params->base.log_data,
-                             "SIMD16 shader failed to compile: %s\n",
-                             v16->fail_msg);
-      } else {
-         simd16_cfg = v16->cfg;
-
-         assert(v16->payload().num_regs % reg_unit(devinfo) == 0);
-         prog_data->dispatch_grf_start_reg_16 = v16->payload().num_regs / reg_unit(devinfo);
-
-         const performance &perf = v16->performance_analysis.require();
-         throughput = MAX2(throughput, perf.throughput);
-         has_spilled = v16->spilled_any_registers;
-         allow_spilling = false;
-      }
-   }
-
-   const bool simd16_failed = v16 && !simd16_cfg;
-
-   /* Currently, the compiler only supports SIMD32 on SNB+ */
-   if (!has_spilled &&
-       (!v8 || v8->max_dispatch_width >= 32) &&
-       (!v16 || v16->max_dispatch_width >= 32) &&
-       reqd_dispatch_width == SUBGROUP_SIZE_VARYING &&
-       !simd16_failed && INTEL_SIMD(FS, 32)) {
-      /* Try a SIMD32 compile */
-      v32 = std::make_unique<fs_visitor>(compiler, &params->base, key,
-                                         prog_data, nir, 32, 1,
-                                         params->base.stats != NULL,
-                                         debug_enabled);
-      if (v8)
-         v32->import_uniforms(v8.get());
-      else if (v16)
-         v32->import_uniforms(v16.get());
-
-      if (!run_fs(*v32, allow_spilling, false)) {
-         brw_shader_perf_log(compiler, params->base.log_data,
-                             "SIMD32 shader failed to compile: %s\n",
-                             v32->fail_msg);
-      } else {
-         const performance &perf = v32->performance_analysis.require();
-
-         if (!INTEL_DEBUG(DEBUG_DO32) && throughput >= perf.throughput) {
+   if (devinfo->ver >= 30) {
+   } else {
+      if ((!has_spilled && (!v8 || v8->max_dispatch_width >= 16) &&
+           INTEL_SIMD(FS, 16)) ||
+          reqd_dispatch_width == SUBGROUP_SIZE_REQUIRE_16) {
+         /* Try a SIMD16 compile */
+         v16 = std::make_unique<fs_visitor>(compiler, &params->base, key,
+                                            prog_data, nir, 16, 1,
+                                            params->base.stats != NULL,
+                                            debug_enabled);
+         if (v8)
+            v16->import_uniforms(v8.get());
+         if (!run_fs(*v16, allow_spilling, params->use_rep_send)) {
             brw_shader_perf_log(compiler, params->base.log_data,
-                                "SIMD32 shader inefficient\n");
+                                "SIMD16 shader failed to compile: %s\n",
+                                v16->fail_msg);
          } else {
-            simd32_cfg = v32->cfg;
+            simd16_cfg = v16->cfg;
 
-            assert(v32->payload().num_regs % reg_unit(devinfo) == 0);
-            prog_data->dispatch_grf_start_reg_32 = v32->payload().num_regs / reg_unit(devinfo);
+            assert(v16->payload().num_regs % reg_unit(devinfo) == 0);
+            prog_data->dispatch_grf_start_reg_16 = v16->payload().num_regs / reg_unit(devinfo);
 
+            const performance &perf = v16->performance_analysis.require();
             throughput = MAX2(throughput, perf.throughput);
+            has_spilled = v16->spilled_any_registers;
+            allow_spilling = false;
+         }
+      }
+
+      const bool simd16_failed = v16 && !simd16_cfg;
+
+      /* Currently, the compiler only supports SIMD32 on SNB+ */
+      if (!has_spilled &&
+          (!v8 || v8->max_dispatch_width >= 32) &&
+          (!v16 || v16->max_dispatch_width >= 32) &&
+          reqd_dispatch_width == SUBGROUP_SIZE_VARYING &&
+          !simd16_failed && INTEL_SIMD(FS, 32)) {
+         /* Try a SIMD32 compile */
+         v32 = std::make_unique<fs_visitor>(compiler, &params->base, key,
+                                            prog_data, nir, 32, 1,
+                                            params->base.stats != NULL,
+                                            debug_enabled);
+         if (v8)
+            v32->import_uniforms(v8.get());
+         else if (v16)
+            v32->import_uniforms(v16.get());
+
+         if (!run_fs(*v32, allow_spilling, false)) {
+            brw_shader_perf_log(compiler, params->base.log_data,
+                                "SIMD32 shader failed to compile: %s\n",
+                                v32->fail_msg);
+         } else {
+            const performance &perf = v32->performance_analysis.require();
+
+            if (!INTEL_DEBUG(DEBUG_DO32) && throughput >= perf.throughput) {
+               brw_shader_perf_log(compiler, params->base.log_data,
+                                   "SIMD32 shader inefficient\n");
+            } else {
+               simd32_cfg = v32->cfg;
+
+               assert(v32->payload().num_regs % reg_unit(devinfo) == 0);
+               prog_data->dispatch_grf_start_reg_32 = v32->payload().num_regs / reg_unit(devinfo);
+
+               throughput = MAX2(throughput, perf.throughput);
+            }
+         }
+      }
+
+      if (devinfo->ver >= 12 && !has_spilled &&
+          params->max_polygons >= 2 && !key->coarse_pixel &&
+          reqd_dispatch_width == SUBGROUP_SIZE_VARYING) {
+         fs_visitor *vbase = v8 ? v8.get() : v16 ? v16.get() : v32.get();
+         assert(vbase);
+
+         if (devinfo->ver >= 20 &&
+             params->max_polygons >= 4 &&
+             vbase->max_dispatch_width >= 32 &&
+             4 * prog_data->num_varying_inputs <= MAX_VARYING &&
+             INTEL_SIMD(FS, 4X8)) {
+            /* Try a quad-SIMD8 compile */
+            vmulti = std::make_unique<fs_visitor>(compiler, &params->base, key,
+                                                  prog_data, nir, 32, 4,
+                                                  params->base.stats != NULL,
+                                                  debug_enabled);
+            vmulti->import_uniforms(vbase);
+            if (!run_fs(*vmulti, false, params->use_rep_send)) {
+               brw_shader_perf_log(compiler, params->base.log_data,
+                                   "Quad-SIMD8 shader failed to compile: %s\n",
+                                   vmulti->fail_msg);
+            } else {
+               multi_cfg = vmulti->cfg;
+               assert(!vmulti->spilled_any_registers);
+            }
+         }
+
+         if (!multi_cfg && devinfo->ver >= 20 &&
+             vbase->max_dispatch_width >= 32 &&
+             2 * prog_data->num_varying_inputs <= MAX_VARYING &&
+             INTEL_SIMD(FS, 2X16)) {
+            /* Try a dual-SIMD16 compile */
+            vmulti = std::make_unique<fs_visitor>(compiler, &params->base, key,
+                                                  prog_data, nir, 32, 2,
+                                                  params->base.stats != NULL,
+                                                  debug_enabled);
+            vmulti->import_uniforms(vbase);
+            if (!run_fs(*vmulti, false, params->use_rep_send)) {
+               brw_shader_perf_log(compiler, params->base.log_data,
+                                   "Dual-SIMD16 shader failed to compile: %s\n",
+                                   vmulti->fail_msg);
+            } else {
+               multi_cfg = vmulti->cfg;
+               assert(!vmulti->spilled_any_registers);
+            }
+         }
+
+         if (!multi_cfg && vbase->max_dispatch_width >= 16 &&
+             2 * prog_data->num_varying_inputs <= MAX_VARYING &&
+             INTEL_SIMD(FS, 2X8)) {
+            /* Try a dual-SIMD8 compile */
+            vmulti = std::make_unique<fs_visitor>(compiler, &params->base, key,
+                                                  prog_data, nir, 16, 2,
+                                                  params->base.stats != NULL,
+                                                  debug_enabled);
+            vmulti->import_uniforms(vbase);
+            if (!run_fs(*vmulti, allow_spilling, params->use_rep_send)) {
+               brw_shader_perf_log(compiler, params->base.log_data,
+                                   "Dual-SIMD8 shader failed to compile: %s\n",
+                                   vmulti->fail_msg);
+            } else {
+               multi_cfg = vmulti->cfg;
+            }
          }
       }
    }
 
-   if (devinfo->ver >= 12 && !has_spilled &&
-       params->max_polygons >= 2 && !key->coarse_pixel &&
-       reqd_dispatch_width == SUBGROUP_SIZE_VARYING) {
-      fs_visitor *vbase = v8 ? v8.get() : v16 ? v16.get() : v32.get();
-      assert(vbase);
-
-      if (devinfo->ver >= 20 &&
-          params->max_polygons >= 4 &&
-          vbase->max_dispatch_width >= 32 &&
-          4 * prog_data->num_varying_inputs <= MAX_VARYING &&
-          INTEL_SIMD(FS, 4X8)) {
-         /* Try a quad-SIMD8 compile */
-         vmulti = std::make_unique<fs_visitor>(compiler, &params->base, key,
-                                               prog_data, nir, 32, 4,
-                                               params->base.stats != NULL,
-                                               debug_enabled);
-         vmulti->import_uniforms(vbase);
-         if (!run_fs(*vmulti, false, params->use_rep_send)) {
-            brw_shader_perf_log(compiler, params->base.log_data,
-                                "Quad-SIMD8 shader failed to compile: %s\n",
-                                vmulti->fail_msg);
-         } else {
-            multi_cfg = vmulti->cfg;
-            assert(!vmulti->spilled_any_registers);
-         }
-      }
-
-      if (!multi_cfg && devinfo->ver >= 20 &&
-          vbase->max_dispatch_width >= 32 &&
-          2 * prog_data->num_varying_inputs <= MAX_VARYING &&
-          INTEL_SIMD(FS, 2X16)) {
-         /* Try a dual-SIMD16 compile */
-         vmulti = std::make_unique<fs_visitor>(compiler, &params->base, key,
-                                               prog_data, nir, 32, 2,
-                                               params->base.stats != NULL,
-                                               debug_enabled);
-         vmulti->import_uniforms(vbase);
-         if (!run_fs(*vmulti, false, params->use_rep_send)) {
-            brw_shader_perf_log(compiler, params->base.log_data,
-                                "Dual-SIMD16 shader failed to compile: %s\n",
-                                vmulti->fail_msg);
-         } else {
-            multi_cfg = vmulti->cfg;
-            assert(!vmulti->spilled_any_registers);
-         }
-      }
-
-      if (!multi_cfg && vbase->max_dispatch_width >= 16 &&
-          2 * prog_data->num_varying_inputs <= MAX_VARYING &&
-          INTEL_SIMD(FS, 2X8)) {
-         /* Try a dual-SIMD8 compile */
-         vmulti = std::make_unique<fs_visitor>(compiler, &params->base, key,
-                                               prog_data, nir, 16, 2,
-                                               params->base.stats != NULL,
-                                               debug_enabled);
-         vmulti->import_uniforms(vbase);
-         if (!run_fs(*vmulti, allow_spilling, params->use_rep_send)) {
-            brw_shader_perf_log(compiler, params->base.log_data,
-                                "Dual-SIMD8 shader failed to compile: %s\n",
-                                vmulti->fail_msg);
-         } else {
-            multi_cfg = vmulti->cfg;
-         }
-      }
-
-      if (multi_cfg) {
-         assert(vmulti->payload().num_regs % reg_unit(devinfo) == 0);
-         prog_data->base.dispatch_grf_start_reg = vmulti->payload().num_regs / reg_unit(devinfo);
-      }
+   if (multi_cfg) {
+      assert(vmulti->payload().num_regs % reg_unit(devinfo) == 0);
+      prog_data->base.dispatch_grf_start_reg = vmulti->payload().num_regs / reg_unit(devinfo);
    }
 
    /* When the caller compiles a repclear or fast clear shader, they