Compute value

src/shader_recompiler/ir/compute_value/compute.cpp

@@ -23,7 +23,8 @@ static void CartesianInvokeImpl(Func func, OutputIt out_it,
         const auto& arglist = std::get<Level>(arglists_tuple);
         for (auto it = arglist.begin(); it != arglist.end(); ++it) {
             std::get<Level>(arglists_its) = it;
-            CartesianInvokeImpl<Func, OutputIt, N, Level + 1, ArgLists...>(func, out_it, arglists_its, arglists_tuple);
+            CartesianInvokeImpl<Func, OutputIt, N, Level + 1, ArgLists...>(
+                func, out_it, arglists_its, arglists_tuple);
         }
     }
 }
@@ -34,7 +35,8 @@ static void CartesianInvoke(Func func, OutputIt out_it, const ArgLists&... arg_l
     const std::tuple<const ArgLists&...> arglists_tuple = std::forward_as_tuple(arg_lists...);
 
     std::tuple<typename ArgLists::const_iterator...> arglists_it;
-    CartesianInvokeImpl<Func, OutputIt, N, 0, ArgLists...>(func, out_it, arglists_it, arglists_tuple);
+    CartesianInvokeImpl<Func, OutputIt, N, 0, ArgLists...>(func, out_it, arglists_it,
+                                                           arglists_tuple);
 }
 
 static void SetSigned(ImmValueList& values, bool is_signed) {
@@ -47,35 +49,31 @@ static void OperationAbs(Inst* inst, ImmValueList& inst_values, ComputeImmValues
     ImmValueList args;
     ComputeImmValues(inst->Arg(0), args, cache);
 
-    const auto op = [](const ImmValue& a) {
+    const auto op = [](const ImmValue& a) { return a.abs(); };
-        return a.abs();
-    };
 
     std::transform(args.begin(), args.end(), std::inserter(inst_values, inst_values.begin()), op);
 }
 
-static void OperationAdd(Inst* inst, bool is_signed, ImmValueList& inst_values, ComputeImmValuesCache& cache) {
+static void OperationAdd(Inst* inst, bool is_signed, ImmValueList& inst_values,
+                         ComputeImmValuesCache& cache) {
     ImmValueList args0, args1;
     ComputeImmValues(inst->Arg(0), args0, cache);
     ComputeImmValues(inst->Arg(1), args1, cache);
 
-    const auto op = [](const ImmValue& a, const ImmValue& b) {
+    const auto op = [](const ImmValue& a, const ImmValue& b) { return a + b; };
-        return a + b;
-    };
 
     SetSigned(args0, is_signed);
     SetSigned(args1, is_signed);
     CartesianInvoke(op, std::inserter(inst_values, inst_values.begin()), args0, args1);
 }
 
-static void OperationSub(Inst* inst, bool is_signed, ImmValueList& inst_values, ComputeImmValuesCache& cache) {
+static void OperationSub(Inst* inst, bool is_signed, ImmValueList& inst_values,
+                         ComputeImmValuesCache& cache) {
     ImmValueList args0, args1;
     ComputeImmValues(inst->Arg(0), args0, cache);
     ComputeImmValues(inst->Arg(1), args1, cache);
 
-    const auto op = [](const ImmValue& a, const ImmValue& b) {
+    const auto op = [](const ImmValue& a, const ImmValue& b) { return a - b; };
-        return a - b;
-    };
 
     SetSigned(args0, is_signed);
     SetSigned(args1, is_signed);
@@ -95,7 +93,8 @@ static void OperationFma(Inst* inst, ImmValueList& inst_values, ComputeImmValues
     CartesianInvoke(op, std::inserter(inst_values, inst_values.begin()), args0, args1, args2);
 }
 
-static void OperationMin(Inst* inst, bool is_signed, ImmValueList& inst_values, ComputeImmValuesCache& cache) {
+static void OperationMin(Inst* inst, bool is_signed, ImmValueList& inst_values,
+                         ComputeImmValuesCache& cache) {
     ImmValueList args0, args1, is_legacy_args;
     ComputeImmValues(inst->Arg(0), args0, cache);
     ComputeImmValues(inst->Arg(1), args1, cache);
@@ -107,18 +106,22 @@ static void OperationMin(Inst* inst, bool is_signed, ImmValueList& inst_values,
 
     const auto op = [](const ImmValue& a, const ImmValue& b, const ImmValue& is_legacy) {
         if (is_legacy.U1()) {
-            if (a.isnan()) return b;
+            if (a.isnan())
-            if (b.isnan()) return a;
+                return b;
+            if (b.isnan())
+                return a;
         }
         return std::min(a, b);
     };
 
     SetSigned(args0, is_signed);
     SetSigned(args1, is_signed);
-    CartesianInvoke(op, std::inserter(inst_values, inst_values.begin()), args0, args1, is_legacy_args);
+    CartesianInvoke(op, std::inserter(inst_values, inst_values.begin()), args0, args1,
+                    is_legacy_args);
 }
 
-static void OperationMax(Inst* inst, bool is_signed, ImmValueList& inst_values, ComputeImmValuesCache& cache) {
+static void OperationMax(Inst* inst, bool is_signed, ImmValueList& inst_values,
+                         ComputeImmValuesCache& cache) {
     ImmValueList args0, args1, is_legacy_args;
     ComputeImmValues(inst->Arg(0), args0, cache);
     ComputeImmValues(inst->Arg(1), args1, cache);
@@ -130,39 +133,53 @@ static void OperationMax(Inst* inst, bool is_signed, ImmValueList& inst_values,
 
     const auto op = [](const ImmValue& a, const ImmValue& b, const ImmValue& is_legacy) {
         if (is_legacy.U1()) {
-            if (a.isnan()) return b;
+            if (a.isnan())
-            if (b.isnan()) return a;
+                return b;
+            if (b.isnan())
+                return a;
         }
         return std::max(a, b);
     };
 
     SetSigned(args0, is_signed);
     SetSigned(args1, is_signed);
-    CartesianInvoke(op, std::inserter(inst_values, inst_values.begin()), args0, args1, is_legacy_args);
+    CartesianInvoke(op, std::inserter(inst_values, inst_values.begin()), args0, args1,
+                    is_legacy_args);
 }
 
-static void OperationMul(Inst* inst, bool is_signed, ImmValueList& inst_values, ComputeImmValuesCache& cache) {
+static void OperationMul(Inst* inst, bool is_signed, ImmValueList& inst_values,
+                         ComputeImmValuesCache& cache) {
     ImmValueList args0, args1;
     ComputeImmValues(inst->Arg(0), args0, cache);
     ComputeImmValues(inst->Arg(1), args1, cache);
 
-    const auto op = [](const ImmValue& a, const ImmValue& b) {
+    const auto op = [](const ImmValue& a, const ImmValue& b) { return a * b; };
-        return a * b;
-    };
 
     SetSigned(args0, is_signed);
     SetSigned(args1, is_signed);
     CartesianInvoke(op, std::inserter(inst_values, inst_values.begin()), args0, args1);
 }
 
-static void OperationDiv(Inst* inst, bool is_signed, ImmValueList& inst_values, ComputeImmValuesCache& cache) {
+static void OperationDiv(Inst* inst, bool is_signed, ImmValueList& inst_values,
+                         ComputeImmValuesCache& cache) {
     ImmValueList args0, args1;
     ComputeImmValues(inst->Arg(0), args0, cache);
     ComputeImmValues(inst->Arg(1), args1, cache);
 
-    const auto op = [](const ImmValue& a, const ImmValue& b) {
+    const auto op = [](const ImmValue& a, const ImmValue& b) { return a / b; };
-        return a / b;
+
-    };
+    SetSigned(args0, is_signed);
+    SetSigned(args1, is_signed);
+    CartesianInvoke(op, std::inserter(inst_values, inst_values.begin()), args0, args1);
+}
+
+static void OperationMod(Inst* inst, bool is_signed, ImmValueList& inst_values,
+                         ComputeImmValuesCache& cache) {
+    ImmValueList args0, args1;
+    ComputeImmValues(inst->Arg(0), args0, cache);
+    ComputeImmValues(inst->Arg(1), args1, cache);
+
+    const auto op = [](const ImmValue& a, const ImmValue& b) { return a % b; };
 
     SetSigned(args0, is_signed);
     SetSigned(args1, is_signed);
@@ -173,9 +190,7 @@ static void OperationNeg(Inst* inst, ImmValueList& inst_values, ComputeImmValues
     ImmValueList args;
     ComputeImmValues(inst->Arg(0), args, cache);
 
-    const auto op = [](const ImmValue& a) {
+    const auto op = [](const ImmValue& a) { return -a; };
-        return -a;
-    };
 
     SetSigned(args, true);
     std::transform(args.begin(), args.end(), std::inserter(inst_values, inst_values.begin()), op);
@@ -185,20 +200,17 @@ static void OperationRecip(Inst* inst, ImmValueList& inst_values, ComputeImmValu
     ImmValueList args;
     ComputeImmValues(inst->Arg(0), args, cache);
 
-    const auto op = [](const ImmValue& a) {
+    const auto op = [](const ImmValue& a) { return a.recip(); };
-        return a.recip();
-    };
 
     std::transform(args.begin(), args.end(), std::inserter(inst_values, inst_values.begin()), op);
 }
 
-static void OperationRecipSqrt(Inst* inst, ImmValueList& inst_values, ComputeImmValuesCache& cache) {
+static void OperationRecipSqrt(Inst* inst, ImmValueList& inst_values,
+                               ComputeImmValuesCache& cache) {
     ImmValueList args;
     ComputeImmValues(inst->Arg(0), args, cache);
 
-    const auto op = [](const ImmValue& a) {
+    const auto op = [](const ImmValue& a) { return a.rsqrt(); };
-        return a.rsqrt();
-    };
 
     std::transform(args.begin(), args.end(), std::inserter(inst_values, inst_values.begin()), op);
 }
@@ -207,9 +219,7 @@ static void OperationSqrt(Inst* inst, ImmValueList& inst_values, ComputeImmValue
     ImmValueList args;
     ComputeImmValues(inst->Arg(0), args, cache);
 
-    const auto op = [](const ImmValue& a) {
+    const auto op = [](const ImmValue& a) { return a.sqrt(); };
-        return a.sqrt();
-    };
 
     std::transform(args.begin(), args.end(), std::inserter(inst_values, inst_values.begin()), op);
 }
@@ -218,9 +228,7 @@ static void OperationSin(Inst* inst, ImmValueList& inst_values, ComputeImmValues
     ImmValueList args;
     ComputeImmValues(inst->Arg(0), args, cache);
 
-    const auto op = [](const ImmValue& a) {
+    const auto op = [](const ImmValue& a) { return a.sin(); };
-        return a.sin();
-    };
 
     std::transform(args.begin(), args.end(), std::inserter(inst_values, inst_values.begin()), op);
 }
@@ -229,9 +237,7 @@ static void OperationExp2(Inst* inst, ImmValueList& inst_values, ComputeImmValue
     ImmValueList args;
     ComputeImmValues(inst->Arg(0), args, cache);
 
-    const auto op = [](const ImmValue& a) {
+    const auto op = [](const ImmValue& a) { return a.exp2(); };
-        return a.exp2();
-    };
 
     std::transform(args.begin(), args.end(), std::inserter(inst_values, inst_values.begin()), op);
 }
@@ -241,9 +247,7 @@ static void OperationLdexp(Inst* inst, ImmValueList& inst_values, ComputeImmValu
     ComputeImmValues(inst->Arg(0), args0, cache);
     ComputeImmValues(inst->Arg(1), args1, cache);
 
-    const auto op = [](const ImmValue& a, const ImmValue& b) {
+    const auto op = [](const ImmValue& a, const ImmValue& b) { return a.ldexp(ImmU32(b)); };
-        return a.ldexp(ImmU32(b));
-    };
 
     CartesianInvoke(op, std::inserter(inst_values, inst_values.begin()), args0, args1);
 }
@@ -252,9 +256,7 @@ static void OperationCos(Inst* inst, ImmValueList& inst_values, ComputeImmValues
     ImmValueList args;
     ComputeImmValues(inst->Arg(0), args, cache);
 
-    const auto op = [](const ImmValue& a) {
+    const auto op = [](const ImmValue& a) { return a.cos(); };
-        return a.cos();
-    };
 
     std::transform(args.begin(), args.end(), std::inserter(inst_values, inst_values.begin()), op);
 }
@@ -263,14 +265,13 @@ static void OperationLog2(Inst* inst, ImmValueList& inst_values, ComputeImmValue
     ImmValueList args;
     ComputeImmValues(inst->Arg(0), args, cache);
 
-    const auto op = [](const ImmValue& a) {
+    const auto op = [](const ImmValue& a) { return a.log2(); };
-        return a.log2();
-    };
 
     std::transform(args.begin(), args.end(), std::inserter(inst_values, inst_values.begin()), op);
 }
 
-static void OperationClamp(Inst* inst, bool is_signed, ImmValueList& inst_values, ComputeImmValuesCache& cache) {
+static void OperationClamp(Inst* inst, bool is_signed, ImmValueList& inst_values,
+                           ComputeImmValuesCache& cache) {
     ImmValueList args0, args1, args2;
     ComputeImmValues(inst->Arg(0), args0, cache);
     ComputeImmValues(inst->Arg(1), args1, cache);
@@ -290,9 +291,7 @@ static void OperationRound(Inst* inst, ImmValueList& inst_values, ComputeImmValu
     ImmValueList args;
     ComputeImmValues(inst->Arg(0), args, cache);
 
-    const auto op = [](const ImmValue& a) {
+    const auto op = [](const ImmValue& a) { return a.round(); };
-        return a.round();
-    };
 
     std::transform(args.begin(), args.end(), std::inserter(inst_values, inst_values.begin()), op);
 }
@@ -301,9 +300,7 @@ static void OperationFloor(Inst* inst, ImmValueList& inst_values, ComputeImmValu
     ImmValueList args;
     ComputeImmValues(inst->Arg(0), args, cache);
 
-    const auto op = [](const ImmValue& a) {
+    const auto op = [](const ImmValue& a) { return a.floor(); };
-        return a.floor();
-    };
 
     std::transform(args.begin(), args.end(), std::inserter(inst_values, inst_values.begin()), op);
 }
@@ -312,9 +309,7 @@ static void OperationCeil(Inst* inst, ImmValueList& inst_values, ComputeImmValue
     ImmValueList args;
     ComputeImmValues(inst->Arg(0), args, cache);
 
-    const auto op = [](const ImmValue& a) {
+    const auto op = [](const ImmValue& a) { return a.ceil(); };
-        return a.ceil();
-    };
 
     std::transform(args.begin(), args.end(), std::inserter(inst_values, inst_values.begin()), op);
 }
@@ -323,9 +318,7 @@ static void OperationTrunc(Inst* inst, ImmValueList& inst_values, ComputeImmValu
     ImmValueList args;
     ComputeImmValues(inst->Arg(0), args, cache);
 
-    const auto op = [](const ImmValue& a) {
+    const auto op = [](const ImmValue& a) { return a.trunc(); };
-        return a.trunc();
-    };
 
     std::transform(args.begin(), args.end(), std::inserter(inst_values, inst_values.begin()), op);
 }
@@ -334,87 +327,80 @@ static void OperationFract(Inst* inst, ImmValueList& inst_values, ComputeImmValu
     ImmValueList args;
     ComputeImmValues(inst->Arg(0), args, cache);
 
-    const auto op = [](const ImmValue& a) {
+    const auto op = [](const ImmValue& a) { return a.fract(); };
-        return a.fract();
-    };
     std::transform(args.begin(), args.end(), std::inserter(inst_values, inst_values.begin()), op);
 }
 
-static void OperationShiftLeft(Inst* inst, ImmValueList& inst_values, ComputeImmValuesCache& cache) {
+static void OperationShiftLeft(Inst* inst, ImmValueList& inst_values,
+                               ComputeImmValuesCache& cache) {
     ImmValueList args0, args1;
     ComputeImmValues(inst->Arg(0), args0, cache);
     ComputeImmValues(inst->Arg(1), args1, cache);
 
-    const auto op = [](const ImmValue& a, const ImmValue& b) {
+    const auto op = [](const ImmValue& a, const ImmValue& b) { return a << ImmU32(b); };
-        return a << ImmU32(b);
-    };
 
     SetSigned(args1, false);
     CartesianInvoke(op, std::inserter(inst_values, inst_values.begin()), args0, args1);
 }
 
-static void OperationShiftRight(Inst* inst, bool is_signed, ImmValueList& inst_values, ComputeImmValuesCache& cache) {
+static void OperationShiftRight(Inst* inst, bool is_signed, ImmValueList& inst_values,
+                                ComputeImmValuesCache& cache) {
     ImmValueList args0, args1;
     ComputeImmValues(inst->Arg(0), args0, cache);
     ComputeImmValues(inst->Arg(1), args1, cache);
 
-    const auto op = [](const ImmValue& a, const ImmValue& b) {
+    const auto op = [](const ImmValue& a, const ImmValue& b) { return a >> ImmU32(b); };
-        return a >> ImmU32(b);
-    };
 
     SetSigned(args0, is_signed);
     SetSigned(args1, false);
     CartesianInvoke(op, std::inserter(inst_values, inst_values.begin()), args0, args1);
 }
 
-static void OperationBitwiseNot(Inst* inst, ImmValueList& inst_values, ComputeImmValuesCache& cache) {
+static void OperationBitwiseNot(Inst* inst, ImmValueList& inst_values,
+                                ComputeImmValuesCache& cache) {
     ImmValueList args;
     ComputeImmValues(inst->Arg(0), args, cache);
 
-    const auto op = [](const ImmValue& a) {
+    const auto op = [](const ImmValue& a) { return ~a; };
-        return ~a;
-    };
 
     std::transform(args.begin(), args.end(), std::inserter(inst_values, inst_values.begin()), op);
 }
 
-static void OperationBitwiseAnd(Inst* inst, ImmValueList& inst_values, ComputeImmValuesCache& cache) {
+static void OperationBitwiseAnd(Inst* inst, ImmValueList& inst_values,
+                                ComputeImmValuesCache& cache) {
     ImmValueList args0, args1;
     ComputeImmValues(inst->Arg(0), args0, cache);
     ComputeImmValues(inst->Arg(1), args1, cache);
 
-    const auto op = [](const ImmValue& a, const ImmValue& b) {
+    const auto op = [](const ImmValue& a, const ImmValue& b) { return a & b; };
-        return a & b;
-    };
 
     CartesianInvoke(op, std::inserter(inst_values, inst_values.begin()), args0, args1);
 }
 
-static void OperationBitwiseOr(Inst* inst, ImmValueList& inst_values, ComputeImmValuesCache& cache) {
+static void OperationBitwiseOr(Inst* inst, ImmValueList& inst_values,
+                               ComputeImmValuesCache& cache) {
     ImmValueList args0, args1;
     ComputeImmValues(inst->Arg(0), args0, cache);
     ComputeImmValues(inst->Arg(1), args1, cache);
 
-    const auto op = [](const ImmValue& a, const ImmValue& b) {
+    const auto op = [](const ImmValue& a, const ImmValue& b) { return a | b; };
-        return a | b;
-    };
 
     CartesianInvoke(op, std::inserter(inst_values, inst_values.begin()), args0, args1);
 }
 
-static void OperationBitwiseXor(Inst* inst, ImmValueList& inst_values, ComputeImmValuesCache& cache) {
+static void OperationBitwiseXor(Inst* inst, ImmValueList& inst_values,
+                                ComputeImmValuesCache& cache) {
     ImmValueList args0, args1;
     ComputeImmValues(inst->Arg(0), args0, cache);
     ComputeImmValues(inst->Arg(1), args1, cache);
 
-    const auto op = [](const ImmValue& a, const ImmValue& b) {
+    const auto op = [](const ImmValue& a, const ImmValue& b) { return a ^ b; };
-        return a ^ b;
-    };
 
     CartesianInvoke(op, std::inserter(inst_values, inst_values.begin()), args0, args1);
 }
 
-static void OperationConvert(Inst* inst, bool is_signed, Type new_type, bool new_signed, ImmValueList& inst_values, ComputeImmValuesCache& cache) {
+static void OperationConvert(Inst* inst, bool is_signed, Type new_type, bool new_signed,
+                             ImmValueList& inst_values, ComputeImmValuesCache& cache) {
     ImmValueList args;
     ComputeImmValues(inst->Arg(0), args, cache);
 
@@ -426,7 +412,8 @@ static void OperationConvert(Inst* inst, bool is_signed, Type new_type, bool new
     std::transform(args.begin(), args.end(), std::inserter(inst_values, inst_values.begin()), op);
 }
 
-static void OperationBitCast(Inst* inst, Type new_type, bool new_signed, ImmValueList& inst_values, ComputeImmValuesCache& cache) {
+static void OperationBitCast(Inst* inst, Type new_type, bool new_signed, ImmValueList& inst_values,
+                             ComputeImmValuesCache& cache) {
     ImmValueList args;
     ComputeImmValues(inst->Arg(0), args, cache);
 
@@ -437,16 +424,15 @@ static void OperationBitCast(Inst* inst, Type new_type, bool new_signed, ImmValu
     std::transform(args.begin(), args.end(), std::inserter(inst_values, inst_values.begin()), op);
 }
 
-template<size_t N>
+template <size_t N>
-static void OperationCompositeConstruct(Inst* inst, ImmValueList& inst_values, ComputeImmValuesCache& cache) {
+static void OperationCompositeConstruct(Inst* inst, ImmValueList& inst_values,
+                                        ComputeImmValuesCache& cache) {
     std::array<ImmValueList, N> args;
     for (size_t i = 0; i < N; ++i) {
         ComputeImmValues(inst->Arg(i), args[i], cache);
     }
 
-    const auto op = []<typename... Args>(const Args&... args) {
+    const auto op = []<typename... Args>(const Args&... args) { return ImmValue(args...); };
-        return ImmValue(args...);
-    };
 
     const auto call_cartesian = [&]<size_t... I>(std::index_sequence<I...>) {
         CartesianInvoke(op, std::inserter(inst_values, inst_values.begin()), args[I]...);
@@ -454,14 +440,13 @@ static void OperationCompositeConstruct(Inst* inst, ImmValueList& inst_values, C
     call_cartesian(std::make_index_sequence<N>{});
 }
 
-static void OperationCompositeExtract(Inst* inst, ImmValueList& inst_values, ComputeImmValuesCache& cache) {
+static void OperationCompositeExtract(Inst* inst, ImmValueList& inst_values,
+                                      ComputeImmValuesCache& cache) {
     ImmValueList args0, args1;
     ComputeImmValues(inst->Arg(0), args0, cache);
     ComputeImmValues(inst->Arg(1), args1, cache);
 
-    const auto op = [](const ImmValue& a, const ImmValue& b) {
+    const auto op = [](const ImmValue& a, const ImmValue& b) { return a.Extract(ImmU32(b)); };
-        return a.Extract(ImmU32(b));
-    };
 
     SetSigned(args1, false);
     CartesianInvoke(op, std::inserter(inst_values, inst_values.begin()), args0, args1);
@@ -481,7 +466,8 @@ static void OperationInsert(Inst* inst, ImmValueList& inst_values, ComputeImmVal
     CartesianInvoke(op, std::inserter(inst_values, inst_values.begin()), args0, args1, args2);
 }
 
-static void DoInstructionOperation(Inst* inst, ImmValueList& inst_values, ComputeImmValuesCache& cache) {
+static void DoInstructionOperation(Inst* inst, ImmValueList& inst_values,
+                                   ComputeImmValuesCache& cache) {
     switch (inst->GetOpcode()) {
     case Opcode::CompositeConstructU32x2:
     case Opcode::CompositeConstructU32x2x2:
@@ -551,33 +537,68 @@ static void DoInstructionOperation(Inst* inst, ImmValueList& inst_values, Comput
         break;
     case Opcode::FPAbs32:
     case Opcode::FPAbs64:
+    case Opcode::IAbs32:
         OperationAbs(inst, inst_values, cache);
         break;
     case Opcode::FPAdd32:
     case Opcode::FPAdd64:
+        OperationAdd(inst, true, inst_values, cache);
+        break;
+    case Opcode::IAdd32:
+    case Opcode::IAdd64:
         OperationAdd(inst, false, inst_values, cache);
         break;
     case Opcode::FPSub32:
+        OperationSub(inst, true, inst_values, cache);
+        break;
+    case Opcode::ISub32:
+    case Opcode::ISub64:
         OperationSub(inst, false, inst_values, cache);
         break;
     case Opcode::FPMul32:
     case Opcode::FPMul64:
+        OperationMul(inst, true, inst_values, cache);
+        break;
+    case Opcode::IMul32:
+    case Opcode::IMul64:
         OperationMul(inst, false, inst_values, cache);
         break;
     case Opcode::FPDiv32:
     case Opcode::FPDiv64:
+    case Opcode::SDiv32:
+        OperationDiv(inst, true, inst_values, cache);
+        break;
+    case Opcode::UDiv32:
         OperationDiv(inst, false, inst_values, cache);
         break;
+    case Opcode::SMod32:
+        OperationMod(inst, true, inst_values, cache);
+        break;
+    case Opcode::UMod32:
+        OperationMod(inst, false, inst_values, cache);
+        break;
+    case Opcode::INeg32:
+    case Opcode::INeg64:
+        OperationNeg(inst, inst_values, cache);
+        break;
     case Opcode::FPFma32:
     case Opcode::FPFma64:
         OperationFma(inst, inst_values, cache);
         break;
     case Opcode::FPMin32:
     case Opcode::FPMin64:
+    case Opcode::SMin32:
+        OperationMin(inst, true, inst_values, cache);
+        break;
+    case Opcode::UMin32:
         OperationMin(inst, false, inst_values, cache);
         break;
     case Opcode::FPMax32:
     case Opcode::FPMax64:
+    case Opcode::SMax32:
+        OperationMax(inst, true, inst_values, cache);
+        break;
+    case Opcode::UMax32:
         OperationMax(inst, false, inst_values, cache);
         break;
     case Opcode::FPNeg32:
@@ -612,6 +633,10 @@ static void DoInstructionOperation(Inst* inst, ImmValueList& inst_values, Comput
         break;
     case Opcode::FPClamp32:
     case Opcode::FPClamp64:
+    case Opcode::SClamp32:
+        OperationClamp(inst, true, inst_values, cache);
+        break;
+    case Opcode::UClamp32:
         OperationClamp(inst, false, inst_values, cache);
         break;
     case Opcode::FPRoundEven32:
@@ -634,6 +659,64 @@ static void DoInstructionOperation(Inst* inst, ImmValueList& inst_values, Comput
     case Opcode::FPFract64:
         OperationFract(inst, inst_values, cache);
         break;
+    case Opcode::ShiftLeftLogical32:
+    case Opcode::ShiftLeftLogical64:
+        OperationShiftLeft(inst, inst_values, cache);
+        break;
+    case Opcode::ShiftRightLogical32:
+    case Opcode::ShiftRightLogical64:
+        OperationShiftRight(inst, false, inst_values, cache);
+        break;
+    case Opcode::ShiftRightArithmetic32:
+    case Opcode::ShiftRightArithmetic64:
+        OperationShiftRight(inst, true, inst_values, cache);
+        break;
+    case Opcode::BitwiseAnd32:
+    case Opcode::BitwiseAnd64:
+    case Opcode::LogicalAnd:
+        OperationBitwiseAnd(inst, inst_values, cache);
+        break;
+    case Opcode::BitwiseOr32:
+    case Opcode::BitwiseOr64:
+    case Opcode::LogicalOr:
+        OperationBitwiseOr(inst, inst_values, cache);
+        break;
+    case Opcode::BitwiseXor32:
+    case Opcode::LogicalXor:
+        OperationBitwiseXor(inst, inst_values, cache);
+        break;
+    case Opcode::BitwiseNot32:
+    case Opcode::LogicalNot:
+        OperationBitwiseNot(inst, inst_values, cache);
+        break;
+    case Opcode::ConvertU16U32:
+        OperationConvert(inst, false, Type::U16, false, inst_values, cache);
+        break;
+    case Opcode::ConvertS32F32:
+    case Opcode::ConvertS32F64:
+        OperationConvert(inst, true, Type::U32, true, inst_values, cache);
+        break;
+    case Opcode::ConvertU32F32:
+        OperationConvert(inst, true, Type::U32, false, inst_values, cache);
+        break;
+    case Opcode::ConvertU32U16:
+        OperationConvert(inst, false, Type::U32, false, inst_values, cache);
+        break;
+    case Opcode::ConvertF32F16:
+    case Opcode::ConvertF32F64:
+    case Opcode::ConvertF32S32:
+        OperationConvert(inst, true, Type::F32, true, inst_values, cache);
+        break;
+    case Opcode::ConvertF32U32:
+        OperationConvert(inst, false, Type::F32, true, inst_values, cache);
+        break;
+    case Opcode::ConvertF64F32:
+    case Opcode::ConvertF64S32:
+        OperationConvert(inst, true, Type::F64, true, inst_values, cache);
+        break;
+    case Opcode::ConvertF64U32:
+        OperationConvert(inst, false, Type::F64, true, inst_values, cache);
+        break;
     default:
         break;
     }
@@ -674,7 +757,8 @@ void ComputeImmValues(const Value& value, ImmValueList& values, ComputeImmValues
         for (size_t i = 0; i < inst->NumArgs(); ++i) {
             ComputeImmValues(inst->Arg(i), inst_values, cache);
         }
-    } if (IsSelectInst(inst)) {
+    }
+    if (IsSelectInst(inst)) {
         ComputeImmValues(inst->Arg(1), inst_values, cache);
         ComputeImmValues(inst->Arg(2), inst_values, cache);
     } else {

src/shader_recompiler/ir/compute_value/compute.h

@@ -3,11 +3,15 @@
 
 #pragma once
 
-#include <boost/container/flat_set.hpp>
 #include <boost/container/flat_map.hpp>
+#include <boost/container/flat_set.hpp>
 #include "shader_recompiler/ir/compute_value/imm_value.h"
 #include "shader_recompiler/ir/value.h"
 
+// Given a value (inmediate or not), compute all the possible inmediate values
+// that can represent. If the value can't be computed statically, the list will
+// be empty.
+
 namespace Shader::IR {
 
 using ImmValueList = boost::container::flat_set<ImmValue>;

src/shader_recompiler/ir/compute_value/imm_value.cpp

@@ -180,17 +180,20 @@ ImmValue::ImmValue(const ImmValue& value1, const ImmValue& value2) noexcept
 
 ImmValue::ImmValue(const ImmValue& value1, const ImmValue& value2, const ImmValue& value3) noexcept
     : type{value1.type}, is_signed{value1.is_signed} {
-    ASSERT(value1.type == value2.type && value1.type == value3.type && value1.is_signed == value2.is_signed &&
+    ASSERT(value1.type == value2.type && value1.type == value3.type &&
-           value1.is_signed == value3.is_signed && value1.Dimensions() == 1);
+           value1.is_signed == value2.is_signed && value1.is_signed == value3.is_signed &&
+           value1.Dimensions() == 1);
     imm_values[0] = value1.imm_values[0];
     imm_values[1] = value2.imm_values[0];
     imm_values[2] = value3.imm_values[0];
 }
 
-ImmValue::ImmValue(const ImmValue& value1, const ImmValue& value2, const ImmValue& value3, const ImmValue& value4) noexcept
+ImmValue::ImmValue(const ImmValue& value1, const ImmValue& value2, const ImmValue& value3,
+                   const ImmValue& value4) noexcept
     : type{value1.type}, is_signed{value1.is_signed} {
-    ASSERT(value1.type == value2.type && value1.type == value3.type && value1.type == value4.type && value1.is_signed == value2.is_signed &&
+    ASSERT(value1.type == value2.type && value1.type == value3.type && value1.type == value4.type &&
-           value1.is_signed == value3.is_signed && value1.is_signed == value4.is_signed && value1.Dimensions() == 1);
+           value1.is_signed == value2.is_signed && value1.is_signed == value3.is_signed &&
+           value1.is_signed == value4.is_signed && value1.Dimensions() == 1);
     imm_values[0] = value1.imm_values[0];
     imm_values[1] = value2.imm_values[0];
     imm_values[2] = value3.imm_values[0];
@@ -884,20 +887,16 @@ ImmValue ImmValue::operator<<(const ImmU32& other) const noexcept {
     case Type::U1:
         return ImmValue(imm_values[0].imm_u1 << other.imm_values[0].imm_u1);
     case Type::U8:
-        return is_signed
+        return is_signed ? ImmValue(imm_values[0].imm_s8 << other.imm_values[0].imm_s8)
-                   ? ImmValue(imm_values[0].imm_s8 << other.imm_values[0].imm_s8)
                          : ImmValue(imm_values[0].imm_u8 << other.imm_values[0].imm_u8);
     case Type::U16:
-        return is_signed
+        return is_signed ? ImmValue(imm_values[0].imm_s16 << other.imm_values[0].imm_s16)
-                   ? ImmValue(imm_values[0].imm_s16 << other.imm_values[0].imm_s16)
                          : ImmValue(imm_values[0].imm_u16 << other.imm_values[0].imm_u16);
     case Type::U32:
-        return is_signed
+        return is_signed ? ImmValue(imm_values[0].imm_s32 << other.imm_values[0].imm_s32)
-                   ? ImmValue(imm_values[0].imm_s32 << other.imm_values[0].imm_s32)
                          : ImmValue(imm_values[0].imm_u32 << other.imm_values[0].imm_u32);
     case Type::U64:
-        return is_signed
+        return is_signed ? ImmValue(imm_values[0].imm_s64 << other.imm_values[0].imm_s64)
-                   ? ImmValue(imm_values[0].imm_s64 << other.imm_values[0].imm_s64)
                          : ImmValue(imm_values[0].imm_u64 << other.imm_values[0].imm_u64);
     default:
         UNREACHABLE_MSG("Invalid type {}", type);
@@ -909,20 +908,16 @@ ImmValue ImmValue::operator>>(const ImmU32& other) const noexcept {
     case Type::U1:
         return ImmValue(imm_values[0].imm_u1 >> other.imm_values[0].imm_u1);
     case Type::U8:
-        return is_signed
+        return is_signed ? ImmValue(imm_values[0].imm_s8 >> other.imm_values[0].imm_s8)
-                   ? ImmValue(imm_values[0].imm_s8 >> other.imm_values[0].imm_s8)
                          : ImmValue(imm_values[0].imm_u8 >> other.imm_values[0].imm_u8);
     case Type::U16:
-        return is_signed
+        return is_signed ? ImmValue(imm_values[0].imm_s16 >> other.imm_values[0].imm_s16)
-                   ? ImmValue(imm_values[0].imm_s16 >> other.imm_values[0].imm_s16)
                          : ImmValue(imm_values[0].imm_u16 >> other.imm_values[0].imm_u16);
     case Type::U32:
-        return is_signed
+        return is_signed ? ImmValue(imm_values[0].imm_s32 >> other.imm_values[0].imm_s32)
-                   ? ImmValue(imm_values[0].imm_s32 >> other.imm_values[0].imm_s32)
                          : ImmValue(imm_values[0].imm_u32 >> other.imm_values[0].imm_u32);
     case Type::U64:
-        return is_signed
+        return is_signed ? ImmValue(imm_values[0].imm_s64 >> other.imm_values[0].imm_s64)
-                   ? ImmValue(imm_values[0].imm_s64 >> other.imm_values[0].imm_s64)
                          : ImmValue(imm_values[0].imm_u64 >> other.imm_values[0].imm_u64);
     default:
         UNREACHABLE_MSG("Invalid type {}", type);

src/shader_recompiler/ir/compute_value/imm_value.h

@@ -98,7 +98,8 @@ public:
     ImmValue(f64 value1, f64 value2, f64 value3, f64 value4) noexcept;
     ImmValue(const ImmValue& value1, const ImmValue& value2) noexcept;
     ImmValue(const ImmValue& value1, const ImmValue& value2, const ImmValue& value3) noexcept;
-    ImmValue(const ImmValue& value1, const ImmValue& value2, const ImmValue& value3, const ImmValue& value4) noexcept;
+    ImmValue(const ImmValue& value1, const ImmValue& value2, const ImmValue& value3,
+             const ImmValue& value4) noexcept;
 
     [[nodiscard]] bool IsEmpty() const noexcept;
     [[nodiscard]] IR::Type Type() const noexcept;
@@ -197,9 +198,11 @@ public:
     [[nodiscard]] ImmValue fract() const noexcept;
     [[nodiscard]] bool isnan() const noexcept;
 
-    [[nodiscard]] static ImmValue fma(const ImmF32F64& a, const ImmF32F64& b, const ImmF32F64& c) noexcept;
+    [[nodiscard]] static ImmValue fma(const ImmF32F64& a, const ImmF32F64& b,
+                                      const ImmF32F64& c) noexcept;
 
     static bool IsSupportedValue(const IR::Value& value) noexcept;
+
 private:
     union Value {
         bool imm_u1;