Merge remote-tracking branch 'upstream/main'

src/shader_recompiler/frontend/translate/scalar_alu.cpp

@@ -132,6 +132,16 @@ void Translator::EmitSOPC(const GcnInst& inst) {
         return S_CMP(ConditionOp::LT, false, inst);
     case Opcode::S_CMP_LE_U32:
         return S_CMP(ConditionOp::LE, false, inst);
+
+    case Opcode::S_BITCMP0_B32:
+        return S_BITCMP(false, 32, inst);
+    case Opcode::S_BITCMP1_B32:
+        return S_BITCMP(true, 32, inst);
+    case Opcode::S_BITCMP0_B64:
+        return S_BITCMP(false, 64, inst);
+    case Opcode::S_BITCMP1_B64:
+        return S_BITCMP(true, 64, inst);
+
     default:
         LogMissingOpcode(inst);
     }
@@ -615,4 +625,33 @@ void Translator::S_CMP(ConditionOp cond, bool is_signed, const GcnInst& inst) {
     ir.SetScc(result);
 }
 
+void Translator::S_BITCMP(bool compare_mode, u32 bits, const GcnInst& inst) {
+    const IR::U1 result = [&] {
+        const IR::U32 src0 = GetSrc(inst.src[0]);
+        const IR::U32 src1 = GetSrc(inst.src[1]);
+
+        IR::U32 mask;
+        switch (bits) {
+        case 32:
+            mask = ir.Imm32(0x1f);
+            break;
+        case 64:
+            mask = ir.Imm32(0x3f);
+            break;
+        default:
+            UNREACHABLE();
+        }
+
+        const IR::U32 bitpos{ir.BitwiseAnd(src1, mask)};
+        const IR::U32 bittest{ir.BitwiseAnd(ir.ShiftRightLogical(src0, bitpos), ir.Imm32(1))};
+
+        if (!compare_mode) {
+            return ir.IEqual(bittest, ir.Imm32(0));
+        } else {
+            return ir.IEqual(bittest, ir.Imm32(1));
+        }
+    }();
+    ir.SetScc(result);
+}
+
 } // namespace Shader::Gcn

src/shader_recompiler/frontend/translate/translate.cpp

@@ -174,6 +174,13 @@ T Translator::GetSrc(const InstOperand& operand) {
             value = ir.GetM0();
         }
         break;
+    case OperandField::Scc:
+        if constexpr (is_float) {
+            UNREACHABLE();
+        } else {
+            value = ir.BitCast<IR::U32>(ir.GetScc());
+        }
+        break;
     default:
         UNREACHABLE();
     }

src/shader_recompiler/frontend/translate/translate.h

@@ -114,6 +114,7 @@ public:
 
     // SOPC
     void S_CMP(ConditionOp cond, bool is_signed, const GcnInst& inst);
+    void S_BITCMP(bool compare_mode, u32 bits, const GcnInst& inst);
 
     // SOPP
     void S_BARRIER();

src/shader_recompiler/ir/ir_emitter.cpp

@@ -59,6 +59,11 @@ F64 IREmitter::Imm64(f64 value) const {
     return F64{Value{value}};
 }
 
+template <>
+IR::U32 IREmitter::BitCast<IR::U32, IR::U1>(const IR::U1& value) {
+    return IR::U32{Select(value, Imm32(1), Imm32(0))};
+}
+
 template <>
 IR::U32 IREmitter::BitCast<IR::U32, IR::F32>(const IR::F32& value) {
     return Inst<IR::U32>(Opcode::BitCastU32F32, value);

src/video_core/amdgpu/resource.h

@@ -358,8 +358,8 @@ enum class MipFilter : u64 {
 };
 
 enum class BorderColor : u64 {
-    OpaqueBlack = 0,
-    TransparentBlack = 1,
+    TransparentBlack = 0,
+    OpaqueBlack = 1,
     White = 2,
     Custom = 3,
 };

src/video_core/renderer_vulkan/liverpool_to_vk.cpp

@@ -285,10 +285,10 @@ vk::SamplerMipmapMode MipFilter(AmdGpu::MipFilter filter) {
 
 vk::BorderColor BorderColor(AmdGpu::BorderColor color) {
     switch (color) {
-    case AmdGpu::BorderColor::OpaqueBlack:
-        return vk::BorderColor::eFloatOpaqueBlack;
     case AmdGpu::BorderColor::TransparentBlack:
         return vk::BorderColor::eFloatTransparentBlack;
+    case AmdGpu::BorderColor::OpaqueBlack:
+        return vk::BorderColor::eFloatOpaqueBlack;
     case AmdGpu::BorderColor::White:
         return vk::BorderColor::eFloatOpaqueWhite;
     case AmdGpu::BorderColor::Custom: