From b10cf64c486d8730fcfeb53a333814915b3b5fbe Mon Sep 17 00:00:00 2001
From: ReinUsesLisp <reinuseslisp@airmail.cc>
Date: Wed, 5 May 2021 02:19:08 -0300
Subject: glasm: Add GLASM backend infrastructure

---
 src/shader_recompiler/backend/glasm/reg_alloc.h | 46 +++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 src/shader_recompiler/backend/glasm/reg_alloc.h

(limited to 'src/shader_recompiler/backend/glasm/reg_alloc.h')

diff --git a/src/shader_recompiler/backend/glasm/reg_alloc.h b/src/shader_recompiler/backend/glasm/reg_alloc.h
new file mode 100644
index 000000000..46018b0c2
--- /dev/null
+++ b/src/shader_recompiler/backend/glasm/reg_alloc.h
@@ -0,0 +1,46 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <bitset>
+
+#include "common/common_types.h"
+
+namespace Shader::IR {
+class Inst;
+class Value;
+} // namespace Shader::IR
+
+namespace Shader::Backend::GLASM {
+
+struct Id {
+    u32 base_element : 2;
+    u32 num_elements_minus_one : 2;
+    u32 index : 26;
+    u32 is_spill : 1;
+    u32 is_condition_code : 1;
+};
+
+class RegAlloc {
+public:
+    std::string Define(IR::Inst& inst, u32 num_elements = 1, u32 alignment = 1);
+
+    std::string Consume(const IR::Value& value);
+
+private:
+    static constexpr size_t NUM_REGS = 4096;
+    static constexpr size_t NUM_ELEMENTS = 4;
+
+    std::string Consume(IR::Inst& inst);
+
+    Id Alloc(u32 num_elements, u32 alignment);
+
+    void Free(Id id);
+
+    size_t num_used_registers{};
+    std::bitset<NUM_REGS> register_use{};
+};
+
+} // namespace Shader::Backend::GLASM
-- 
cgit v1.2.3


From c1ba685d9c9b9ca9e8c479c52097adf943e804eb Mon Sep 17 00:00:00 2001
From: ReinUsesLisp <reinuseslisp@airmail.cc>
Date: Fri, 7 May 2021 06:31:30 -0300
Subject: glasm: Changes to GLASM register allocator and emit context

---
 src/shader_recompiler/backend/glasm/reg_alloc.h | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

(limited to 'src/shader_recompiler/backend/glasm/reg_alloc.h')

diff --git a/src/shader_recompiler/backend/glasm/reg_alloc.h b/src/shader_recompiler/backend/glasm/reg_alloc.h
index 46018b0c2..83d728d20 100644
--- a/src/shader_recompiler/backend/glasm/reg_alloc.h
+++ b/src/shader_recompiler/backend/glasm/reg_alloc.h
@@ -15,27 +15,35 @@ class Value;
 
 namespace Shader::Backend::GLASM {
 
+class EmitContext;
+
 struct Id {
-    u32 base_element : 2;
-    u32 num_elements_minus_one : 2;
-    u32 index : 26;
+    u32 index : 30;
     u32 is_spill : 1;
     u32 is_condition_code : 1;
 };
 
 class RegAlloc {
 public:
-    std::string Define(IR::Inst& inst, u32 num_elements = 1, u32 alignment = 1);
+    RegAlloc(EmitContext& ctx_) : ctx{ctx_} {}
+
+    std::string Define(IR::Inst& inst);
 
     std::string Consume(const IR::Value& value);
 
+    [[nodiscard]] size_t NumUsedRegisters() const noexcept {
+        return num_used_registers;
+    }
+
 private:
     static constexpr size_t NUM_REGS = 4096;
     static constexpr size_t NUM_ELEMENTS = 4;
 
+    EmitContext& ctx;
+
     std::string Consume(IR::Inst& inst);
 
-    Id Alloc(u32 num_elements, u32 alignment);
+    Id Alloc();
 
     void Free(Id id);
 
-- 
cgit v1.2.3


From 3e841f6441903c6e97307dd49a2543ce82654044 Mon Sep 17 00:00:00 2001
From: ReinUsesLisp <reinuseslisp@airmail.cc>
Date: Sat, 8 May 2021 16:46:32 -0300
Subject: glasm: Use BitField instead of C bitfields

---
 src/shader_recompiler/backend/glasm/reg_alloc.h | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

(limited to 'src/shader_recompiler/backend/glasm/reg_alloc.h')

diff --git a/src/shader_recompiler/backend/glasm/reg_alloc.h b/src/shader_recompiler/backend/glasm/reg_alloc.h
index 83d728d20..f73aa3348 100644
--- a/src/shader_recompiler/backend/glasm/reg_alloc.h
+++ b/src/shader_recompiler/backend/glasm/reg_alloc.h
@@ -6,6 +6,7 @@
 
 #include <bitset>
 
+#include "common/bit_field.h"
 #include "common/common_types.h"
 
 namespace Shader::IR {
@@ -18,9 +19,12 @@ namespace Shader::Backend::GLASM {
 class EmitContext;
 
 struct Id {
-    u32 index : 30;
-    u32 is_spill : 1;
-    u32 is_condition_code : 1;
+    union {
+        u32 raw;
+        BitField<0, 30, u32> index;
+        BitField<30, 1, u32> is_spill;
+        BitField<31, 1, u32> is_condition_code;
+    };
 };
 
 class RegAlloc {
-- 
cgit v1.2.3


From 1c9307969c4e3f6206947f1360acae33f95a4a86 Mon Sep 17 00:00:00 2001
From: ReinUsesLisp <reinuseslisp@airmail.cc>
Date: Sun, 9 May 2021 03:11:34 -0300
Subject: glasm: Make GLASM aware of types

---
 src/shader_recompiler/backend/glasm/reg_alloc.h | 184 +++++++++++++++++++++++-
 1 file changed, 179 insertions(+), 5 deletions(-)

(limited to 'src/shader_recompiler/backend/glasm/reg_alloc.h')

diff --git a/src/shader_recompiler/backend/glasm/reg_alloc.h b/src/shader_recompiler/backend/glasm/reg_alloc.h
index f73aa3348..ef0b6697f 100644
--- a/src/shader_recompiler/backend/glasm/reg_alloc.h
+++ b/src/shader_recompiler/backend/glasm/reg_alloc.h
@@ -6,8 +6,12 @@
 
 #include <bitset>
 
+#include <fmt/format.h>
+
+#include "common/bit_cast.h"
 #include "common/bit_field.h"
 #include "common/common_types.h"
+#include "shader_recompiler/exception.h"
 
 namespace Shader::IR {
 class Inst;
@@ -18,6 +22,13 @@ namespace Shader::Backend::GLASM {
 
 class EmitContext;
 
+enum class Type : u32 {
+    Register,
+    U32,
+    S32,
+    F32,
+};
+
 struct Id {
     union {
         u32 raw;
@@ -25,15 +36,62 @@ struct Id {
         BitField<30, 1, u32> is_spill;
         BitField<31, 1, u32> is_condition_code;
     };
+
+    bool operator==(Id rhs) const noexcept {
+        return raw == rhs.raw;
+    }
+    bool operator!=(Id rhs) const noexcept {
+        return !operator==(rhs);
+    }
 };
+static_assert(sizeof(Id) == sizeof(u32));
+
+struct Value {
+    Type type;
+    union {
+        Id id;
+        u32 imm_u32;
+        s32 imm_s32;
+        f32 imm_f32;
+    };
+
+    bool operator==(const Value& rhs) const noexcept {
+        if (type != rhs.type) {
+            return false;
+        }
+        switch (type) {
+        case Type::Register:
+            return id == rhs.id;
+        case Type::U32:
+            return imm_u32 == rhs.imm_u32;
+        case Type::S32:
+            return imm_s32 == rhs.imm_s32;
+        case Type::F32:
+            return Common::BitCast<u32>(imm_f32) == Common::BitCast<u32>(rhs.imm_f32);
+        }
+        return false;
+    }
+    bool operator!=(const Value& rhs) const noexcept {
+        return !operator==(rhs);
+    }
+};
+struct Register : Value {};
+struct ScalarRegister : Value {};
+struct ScalarU32 : Value {};
+struct ScalarS32 : Value {};
+struct ScalarF32 : Value {};
 
 class RegAlloc {
 public:
     RegAlloc(EmitContext& ctx_) : ctx{ctx_} {}
 
-    std::string Define(IR::Inst& inst);
+    Register Define(IR::Inst& inst);
+
+    Value Consume(const IR::Value& value);
+
+    Register AllocReg();
 
-    std::string Consume(const IR::Value& value);
+    void FreeReg(Register reg);
 
     [[nodiscard]] size_t NumUsedRegisters() const noexcept {
         return num_used_registers;
@@ -43,16 +101,132 @@ private:
     static constexpr size_t NUM_REGS = 4096;
     static constexpr size_t NUM_ELEMENTS = 4;
 
-    EmitContext& ctx;
-
-    std::string Consume(IR::Inst& inst);
+    Value Consume(IR::Inst& inst);
 
     Id Alloc();
 
     void Free(Id id);
 
+    EmitContext& ctx;
     size_t num_used_registers{};
     std::bitset<NUM_REGS> register_use{};
 };
 
+template <bool scalar, typename FormatContext>
+auto FormatTo(FormatContext& ctx, Id id) {
+    if (id.is_condition_code != 0) {
+        throw NotImplementedException("Condition code emission");
+    }
+    if (id.is_spill != 0) {
+        throw NotImplementedException("Spill emission");
+    }
+    if constexpr (scalar) {
+        return fmt::format_to(ctx.out(), "R{}.x", id.index.Value());
+    } else {
+        return fmt::format_to(ctx.out(), "R{}", id.index.Value());
+    }
+}
+
 } // namespace Shader::Backend::GLASM
+
+template <>
+struct fmt::formatter<Shader::Backend::GLASM::Id> {
+    constexpr auto parse(format_parse_context& ctx) {
+        return ctx.begin();
+    }
+    template <typename FormatContext>
+    auto format(Shader::Backend::GLASM::Id id, FormatContext& ctx) {
+        return FormatTo<true>(ctx, id);
+    }
+};
+
+template <>
+struct fmt::formatter<Shader::Backend::GLASM::Register> {
+    constexpr auto parse(format_parse_context& ctx) {
+        return ctx.begin();
+    }
+    template <typename FormatContext>
+    auto format(const Shader::Backend::GLASM::Register& value, FormatContext& ctx) {
+        if (value.type != Shader::Backend::GLASM::Type::Register) {
+            throw Shader::InvalidArgument("Register value type is not register");
+        }
+        return FormatTo<false>(ctx, value.id);
+    }
+};
+
+template <>
+struct fmt::formatter<Shader::Backend::GLASM::ScalarRegister> {
+    constexpr auto parse(format_parse_context& ctx) {
+        return ctx.begin();
+    }
+    template <typename FormatContext>
+    auto format(const Shader::Backend::GLASM::ScalarRegister& value, FormatContext& ctx) {
+        if (value.type != Shader::Backend::GLASM::Type::Register) {
+            throw Shader::InvalidArgument("Register value type is not register");
+        }
+        return FormatTo<true>(ctx, value.id);
+    }
+};
+
+template <>
+struct fmt::formatter<Shader::Backend::GLASM::ScalarU32> {
+    constexpr auto parse(format_parse_context& ctx) {
+        return ctx.begin();
+    }
+    template <typename FormatContext>
+    auto format(const Shader::Backend::GLASM::ScalarU32& value, FormatContext& ctx) {
+        switch (value.type) {
+        case Shader::Backend::GLASM::Type::Register:
+            return FormatTo<true>(ctx, value.id);
+        case Shader::Backend::GLASM::Type::U32:
+            return fmt::format_to(ctx.out(), "{}", value.imm_u32);
+        case Shader::Backend::GLASM::Type::S32:
+            return fmt::format_to(ctx.out(), "{}", static_cast<u32>(value.imm_s32));
+        case Shader::Backend::GLASM::Type::F32:
+            return fmt::format_to(ctx.out(), "{}", Common::BitCast<u32>(value.imm_f32));
+        }
+        throw Shader::InvalidArgument("Invalid value type {}", value.type);
+    }
+};
+
+template <>
+struct fmt::formatter<Shader::Backend::GLASM::ScalarS32> {
+    constexpr auto parse(format_parse_context& ctx) {
+        return ctx.begin();
+    }
+    template <typename FormatContext>
+    auto format(const Shader::Backend::GLASM::ScalarS32& value, FormatContext& ctx) {
+        switch (value.type) {
+        case Shader::Backend::GLASM::Type::Register:
+            return FormatTo<true>(ctx, value.id);
+        case Shader::Backend::GLASM::Type::U32:
+            return fmt::format_to(ctx.out(), "{}", static_cast<s32>(value.imm_u32));
+        case Shader::Backend::GLASM::Type::S32:
+            return fmt::format_to(ctx.out(), "{}", value.imm_s32);
+        case Shader::Backend::GLASM::Type::F32:
+            return fmt::format_to(ctx.out(), "{}", Common::BitCast<s32>(value.imm_f32));
+        }
+        throw Shader::InvalidArgument("Invalid value type {}", value.type);
+    }
+};
+
+template <>
+struct fmt::formatter<Shader::Backend::GLASM::ScalarF32> {
+    constexpr auto parse(format_parse_context& ctx) {
+        return ctx.begin();
+    }
+    template <typename FormatContext>
+    auto format(const Shader::Backend::GLASM::ScalarF32& value, FormatContext& ctx) {
+        switch (value.type) {
+        case Shader::Backend::GLASM::Type::Register:
+            return FormatTo<true>(ctx, value.id);
+        case Shader::Backend::GLASM::Type::U32:
+            return fmt::format_to(ctx.out(), "{}", Common::BitCast<u32>(value.imm_u32));
+        case Shader::Backend::GLASM::Type::S32:
+            return fmt::format_to(ctx.out(), "{}", Common::BitCast<s32>(value.imm_s32));
+        case Shader::Backend::GLASM::Type::F32:
+            return fmt::format_to(ctx.out(), "{}", value.imm_f32);
+        }
+        throw Shader::InvalidArgument("Invalid value type {}", value.type);
+    }
+};
-- 
cgit v1.2.3


From 6358b0d0c1968e6491d39d36f08055f834e0030f Mon Sep 17 00:00:00 2001
From: ReinUsesLisp <reinuseslisp@airmail.cc>
Date: Sun, 9 May 2021 04:08:19 -0300
Subject: glasm: Specify namespace when using FormatTo

---
 src/shader_recompiler/backend/glasm/reg_alloc.h | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'src/shader_recompiler/backend/glasm/reg_alloc.h')

diff --git a/src/shader_recompiler/backend/glasm/reg_alloc.h b/src/shader_recompiler/backend/glasm/reg_alloc.h
index ef0b6697f..6a238afa9 100644
--- a/src/shader_recompiler/backend/glasm/reg_alloc.h
+++ b/src/shader_recompiler/backend/glasm/reg_alloc.h
@@ -136,7 +136,7 @@ struct fmt::formatter<Shader::Backend::GLASM::Id> {
     }
     template <typename FormatContext>
     auto format(Shader::Backend::GLASM::Id id, FormatContext& ctx) {
-        return FormatTo<true>(ctx, id);
+        return Shader::Backend::GLASM::FormatTo<true>(ctx, id);
     }
 };
 
@@ -150,7 +150,7 @@ struct fmt::formatter<Shader::Backend::GLASM::Register> {
         if (value.type != Shader::Backend::GLASM::Type::Register) {
             throw Shader::InvalidArgument("Register value type is not register");
         }
-        return FormatTo<false>(ctx, value.id);
+        return Shader::Backend::GLASM::FormatTo<false>(ctx, value.id);
     }
 };
 
@@ -164,7 +164,7 @@ struct fmt::formatter<Shader::Backend::GLASM::ScalarRegister> {
         if (value.type != Shader::Backend::GLASM::Type::Register) {
             throw Shader::InvalidArgument("Register value type is not register");
         }
-        return FormatTo<true>(ctx, value.id);
+        return Shader::Backend::GLASM::FormatTo<true>(ctx, value.id);
     }
 };
 
@@ -177,7 +177,7 @@ struct fmt::formatter<Shader::Backend::GLASM::ScalarU32> {
     auto format(const Shader::Backend::GLASM::ScalarU32& value, FormatContext& ctx) {
         switch (value.type) {
         case Shader::Backend::GLASM::Type::Register:
-            return FormatTo<true>(ctx, value.id);
+            return Shader::Backend::GLASM::FormatTo<true>(ctx, value.id);
         case Shader::Backend::GLASM::Type::U32:
             return fmt::format_to(ctx.out(), "{}", value.imm_u32);
         case Shader::Backend::GLASM::Type::S32:
@@ -198,7 +198,7 @@ struct fmt::formatter<Shader::Backend::GLASM::ScalarS32> {
     auto format(const Shader::Backend::GLASM::ScalarS32& value, FormatContext& ctx) {
         switch (value.type) {
         case Shader::Backend::GLASM::Type::Register:
-            return FormatTo<true>(ctx, value.id);
+            return Shader::Backend::GLASM::FormatTo<true>(ctx, value.id);
         case Shader::Backend::GLASM::Type::U32:
             return fmt::format_to(ctx.out(), "{}", static_cast<s32>(value.imm_u32));
         case Shader::Backend::GLASM::Type::S32:
@@ -219,7 +219,7 @@ struct fmt::formatter<Shader::Backend::GLASM::ScalarF32> {
     auto format(const Shader::Backend::GLASM::ScalarF32& value, FormatContext& ctx) {
         switch (value.type) {
         case Shader::Backend::GLASM::Type::Register:
-            return FormatTo<true>(ctx, value.id);
+            return Shader::Backend::GLASM::FormatTo<true>(ctx, value.id);
         case Shader::Backend::GLASM::Type::U32:
             return fmt::format_to(ctx.out(), "{}", Common::BitCast<u32>(value.imm_u32));
         case Shader::Backend::GLASM::Type::S32:
-- 
cgit v1.2.3


From 4502595bc2518eecf934110e9393b11bf0c2f75a Mon Sep 17 00:00:00 2001
From: ReinUsesLisp <reinuseslisp@airmail.cc>
Date: Sun, 9 May 2021 18:03:01 -0300
Subject: glasm: Initial GLASM fp64 support

---
 src/shader_recompiler/backend/glasm/reg_alloc.h | 63 +++++++++++++++++++++++--
 1 file changed, 58 insertions(+), 5 deletions(-)

(limited to 'src/shader_recompiler/backend/glasm/reg_alloc.h')

diff --git a/src/shader_recompiler/backend/glasm/reg_alloc.h b/src/shader_recompiler/backend/glasm/reg_alloc.h
index 6a238afa9..f1899eae1 100644
--- a/src/shader_recompiler/backend/glasm/reg_alloc.h
+++ b/src/shader_recompiler/backend/glasm/reg_alloc.h
@@ -27,12 +27,14 @@ enum class Type : u32 {
     U32,
     S32,
     F32,
+    F64,
 };
 
 struct Id {
     union {
         u32 raw;
-        BitField<0, 30, u32> index;
+        BitField<0, 29, u32> index;
+        BitField<29, 1, u32> is_long;
         BitField<30, 1, u32> is_spill;
         BitField<31, 1, u32> is_condition_code;
     };
@@ -53,6 +55,7 @@ struct Value {
         u32 imm_u32;
         s32 imm_s32;
         f32 imm_f32;
+        f64 imm_f64;
     };
 
     bool operator==(const Value& rhs) const noexcept {
@@ -68,6 +71,8 @@ struct Value {
             return imm_s32 == rhs.imm_s32;
         case Type::F32:
             return Common::BitCast<u32>(imm_f32) == Common::BitCast<u32>(rhs.imm_f32);
+        case Type::F64:
+            return Common::BitCast<u64>(imm_f64) == Common::BitCast<u64>(rhs.imm_f64);
         }
         return false;
     }
@@ -80,6 +85,7 @@ struct ScalarRegister : Value {};
 struct ScalarU32 : Value {};
 struct ScalarS32 : Value {};
 struct ScalarF32 : Value {};
+struct ScalarF64 : Value {};
 
 class RegAlloc {
 public:
@@ -87,9 +93,13 @@ public:
 
     Register Define(IR::Inst& inst);
 
+    Register LongDefine(IR::Inst& inst);
+
     Value Consume(const IR::Value& value);
 
-    Register AllocReg();
+    [[nodiscard]] Register AllocReg();
+
+    [[nodiscard]] Register AllocLongReg();
 
     void FreeReg(Register reg);
 
@@ -97,19 +107,27 @@ public:
         return num_used_registers;
     }
 
+    [[nodiscard]] size_t NumUsedLongRegisters() const noexcept {
+        return num_used_long_registers;
+    }
+
 private:
     static constexpr size_t NUM_REGS = 4096;
     static constexpr size_t NUM_ELEMENTS = 4;
 
+    Register Define(IR::Inst& inst, bool is_long);
+
     Value Consume(IR::Inst& inst);
 
-    Id Alloc();
+    Id Alloc(bool is_long);
 
     void Free(Id id);
 
     EmitContext& ctx;
     size_t num_used_registers{};
+    size_t num_used_long_registers{};
     std::bitset<NUM_REGS> register_use{};
+    std::bitset<NUM_REGS> long_register_use{};
 };
 
 template <bool scalar, typename FormatContext>
@@ -121,9 +139,17 @@ auto FormatTo(FormatContext& ctx, Id id) {
         throw NotImplementedException("Spill emission");
     }
     if constexpr (scalar) {
-        return fmt::format_to(ctx.out(), "R{}.x", id.index.Value());
+        if (id.is_long != 0) {
+            return fmt::format_to(ctx.out(), "D{}.x", id.index.Value());
+        } else {
+            return fmt::format_to(ctx.out(), "R{}.x", id.index.Value());
+        }
     } else {
-        return fmt::format_to(ctx.out(), "R{}", id.index.Value());
+        if (id.is_long != 0) {
+            return fmt::format_to(ctx.out(), "D{}", id.index.Value());
+        } else {
+            return fmt::format_to(ctx.out(), "R{}", id.index.Value());
+        }
     }
 }
 
@@ -184,6 +210,8 @@ struct fmt::formatter<Shader::Backend::GLASM::ScalarU32> {
             return fmt::format_to(ctx.out(), "{}", static_cast<u32>(value.imm_s32));
         case Shader::Backend::GLASM::Type::F32:
             return fmt::format_to(ctx.out(), "{}", Common::BitCast<u32>(value.imm_f32));
+        case Shader::Backend::GLASM::Type::F64:
+            break;
         }
         throw Shader::InvalidArgument("Invalid value type {}", value.type);
     }
@@ -205,6 +233,8 @@ struct fmt::formatter<Shader::Backend::GLASM::ScalarS32> {
             return fmt::format_to(ctx.out(), "{}", value.imm_s32);
         case Shader::Backend::GLASM::Type::F32:
             return fmt::format_to(ctx.out(), "{}", Common::BitCast<s32>(value.imm_f32));
+        case Shader::Backend::GLASM::Type::F64:
+            break;
         }
         throw Shader::InvalidArgument("Invalid value type {}", value.type);
     }
@@ -226,6 +256,29 @@ struct fmt::formatter<Shader::Backend::GLASM::ScalarF32> {
             return fmt::format_to(ctx.out(), "{}", Common::BitCast<s32>(value.imm_s32));
         case Shader::Backend::GLASM::Type::F32:
             return fmt::format_to(ctx.out(), "{}", value.imm_f32);
+        case Shader::Backend::GLASM::Type::F64:
+            break;
+        }
+        throw Shader::InvalidArgument("Invalid value type {}", value.type);
+    }
+};
+
+template <>
+struct fmt::formatter<Shader::Backend::GLASM::ScalarF64> {
+    constexpr auto parse(format_parse_context& ctx) {
+        return ctx.begin();
+    }
+    template <typename FormatContext>
+    auto format(const Shader::Backend::GLASM::ScalarF64& value, FormatContext& ctx) {
+        switch (value.type) {
+        case Shader::Backend::GLASM::Type::Register:
+            return Shader::Backend::GLASM::FormatTo<true>(ctx, value.id);
+        case Shader::Backend::GLASM::Type::U32:
+        case Shader::Backend::GLASM::Type::S32:
+        case Shader::Backend::GLASM::Type::F32:
+            break;
+        case Shader::Backend::GLASM::Type::F64:
+            return format_to(ctx.out(), "{}", value.imm_f64);
         }
         throw Shader::InvalidArgument("Invalid value type {}", value.type);
     }
-- 
cgit v1.2.3


From ad61b47f80b96436ef675abcf1123668d9c1180d Mon Sep 17 00:00:00 2001
From: ReinUsesLisp <reinuseslisp@airmail.cc>
Date: Sun, 9 May 2021 22:43:29 -0300
Subject: glasm: Add conversion instructions to GLASM

---
 src/shader_recompiler/backend/glasm/reg_alloc.h | 13 +++++++++++++
 1 file changed, 13 insertions(+)

(limited to 'src/shader_recompiler/backend/glasm/reg_alloc.h')

diff --git a/src/shader_recompiler/backend/glasm/reg_alloc.h b/src/shader_recompiler/backend/glasm/reg_alloc.h
index f1899eae1..200c51610 100644
--- a/src/shader_recompiler/backend/glasm/reg_alloc.h
+++ b/src/shader_recompiler/backend/glasm/reg_alloc.h
@@ -27,6 +27,7 @@ enum class Type : u32 {
     U32,
     S32,
     F32,
+    U64,
     F64,
 };
 
@@ -55,6 +56,7 @@ struct Value {
         u32 imm_u32;
         s32 imm_s32;
         f32 imm_f32;
+        u64 imm_u64;
         f64 imm_f64;
     };
 
@@ -71,6 +73,8 @@ struct Value {
             return imm_s32 == rhs.imm_s32;
         case Type::F32:
             return Common::BitCast<u32>(imm_f32) == Common::BitCast<u32>(rhs.imm_f32);
+        case Type::U64:
+            return imm_u64 == rhs.imm_u64;
         case Type::F64:
             return Common::BitCast<u64>(imm_f64) == Common::BitCast<u64>(rhs.imm_f64);
         }
@@ -103,6 +107,10 @@ public:
 
     void FreeReg(Register reg);
 
+    void InvalidateConditionCodes() {
+        // This does nothing for now
+    }
+
     [[nodiscard]] size_t NumUsedRegisters() const noexcept {
         return num_used_registers;
     }
@@ -210,6 +218,7 @@ struct fmt::formatter<Shader::Backend::GLASM::ScalarU32> {
             return fmt::format_to(ctx.out(), "{}", static_cast<u32>(value.imm_s32));
         case Shader::Backend::GLASM::Type::F32:
             return fmt::format_to(ctx.out(), "{}", Common::BitCast<u32>(value.imm_f32));
+        case Shader::Backend::GLASM::Type::U64:
         case Shader::Backend::GLASM::Type::F64:
             break;
         }
@@ -233,6 +242,7 @@ struct fmt::formatter<Shader::Backend::GLASM::ScalarS32> {
             return fmt::format_to(ctx.out(), "{}", value.imm_s32);
         case Shader::Backend::GLASM::Type::F32:
             return fmt::format_to(ctx.out(), "{}", Common::BitCast<s32>(value.imm_f32));
+        case Shader::Backend::GLASM::Type::U64:
         case Shader::Backend::GLASM::Type::F64:
             break;
         }
@@ -256,6 +266,7 @@ struct fmt::formatter<Shader::Backend::GLASM::ScalarF32> {
             return fmt::format_to(ctx.out(), "{}", Common::BitCast<s32>(value.imm_s32));
         case Shader::Backend::GLASM::Type::F32:
             return fmt::format_to(ctx.out(), "{}", value.imm_f32);
+        case Shader::Backend::GLASM::Type::U64:
         case Shader::Backend::GLASM::Type::F64:
             break;
         }
@@ -277,6 +288,8 @@ struct fmt::formatter<Shader::Backend::GLASM::ScalarF64> {
         case Shader::Backend::GLASM::Type::S32:
         case Shader::Backend::GLASM::Type::F32:
             break;
+        case Shader::Backend::GLASM::Type::U64:
+            return format_to(ctx.out(), "{}", Common::BitCast<f64>(value.imm_u64));
         case Shader::Backend::GLASM::Type::F64:
             return format_to(ctx.out(), "{}", value.imm_f64);
         }
-- 
cgit v1.2.3


From 8eb72ff0dc3eb428c28b578ffb3912c1bd1c42dd Mon Sep 17 00:00:00 2001
From: ReinUsesLisp <reinuseslisp@airmail.cc>
Date: Mon, 10 May 2021 01:33:24 -0300
Subject: glasm: Fix moving U64 immediates to registers in GLASM

---
 src/shader_recompiler/backend/glasm/reg_alloc.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/shader_recompiler/backend/glasm/reg_alloc.h')

diff --git a/src/shader_recompiler/backend/glasm/reg_alloc.h b/src/shader_recompiler/backend/glasm/reg_alloc.h
index 200c51610..8df73ca18 100644
--- a/src/shader_recompiler/backend/glasm/reg_alloc.h
+++ b/src/shader_recompiler/backend/glasm/reg_alloc.h
@@ -289,9 +289,9 @@ struct fmt::formatter<Shader::Backend::GLASM::ScalarF64> {
         case Shader::Backend::GLASM::Type::F32:
             break;
         case Shader::Backend::GLASM::Type::U64:
-            return format_to(ctx.out(), "{}", Common::BitCast<f64>(value.imm_u64));
+            return fmt::format_to(ctx.out(), "{}", Common::BitCast<f64>(value.imm_u64));
         case Shader::Backend::GLASM::Type::F64:
-            return format_to(ctx.out(), "{}", value.imm_f64);
+            return fmt::format_to(ctx.out(), "{}", value.imm_f64);
         }
         throw Shader::InvalidArgument("Invalid value type {}", value.type);
     }
-- 
cgit v1.2.3


From deda89372f78dc78b37e941bf86e3026708e3ea2 Mon Sep 17 00:00:00 2001
From: ReinUsesLisp <reinuseslisp@airmail.cc>
Date: Mon, 10 May 2021 03:47:31 -0300
Subject: glasm: Fix register allocation when moving immediate on GLASM

---
 src/shader_recompiler/backend/glasm/reg_alloc.h | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

(limited to 'src/shader_recompiler/backend/glasm/reg_alloc.h')

diff --git a/src/shader_recompiler/backend/glasm/reg_alloc.h b/src/shader_recompiler/backend/glasm/reg_alloc.h
index 8df73ca18..5742436cf 100644
--- a/src/shader_recompiler/backend/glasm/reg_alloc.h
+++ b/src/shader_recompiler/backend/glasm/reg_alloc.h
@@ -99,8 +99,12 @@ public:
 
     Register LongDefine(IR::Inst& inst);
 
+    [[nodiscard]] Value Peek(const IR::Value& value);
+
     Value Consume(const IR::Value& value);
 
+    void Unref(IR::Inst& inst);
+
     [[nodiscard]] Register AllocReg();
 
     [[nodiscard]] Register AllocLongReg();
@@ -123,9 +127,13 @@ private:
     static constexpr size_t NUM_REGS = 4096;
     static constexpr size_t NUM_ELEMENTS = 4;
 
+    Value MakeImm(const IR::Value& value);
+
     Register Define(IR::Inst& inst, bool is_long);
 
-    Value Consume(IR::Inst& inst);
+    Value PeekInst(IR::Inst& inst);
+
+    Value ConsumeInst(IR::Inst& inst);
 
     Id Alloc(bool is_long);
 
-- 
cgit v1.2.3


From 31d402ee74d7f7045aec7e748fdee489a434db6b Mon Sep 17 00:00:00 2001
From: ReinUsesLisp <reinuseslisp@airmail.cc>
Date: Sat, 15 May 2021 18:15:13 -0300
Subject: glasm: Add Void type to GLASM values

---
 src/shader_recompiler/backend/glasm/reg_alloc.h | 11 +++++++++++
 1 file changed, 11 insertions(+)

(limited to 'src/shader_recompiler/backend/glasm/reg_alloc.h')

diff --git a/src/shader_recompiler/backend/glasm/reg_alloc.h b/src/shader_recompiler/backend/glasm/reg_alloc.h
index 5742436cf..ede6edd1f 100644
--- a/src/shader_recompiler/backend/glasm/reg_alloc.h
+++ b/src/shader_recompiler/backend/glasm/reg_alloc.h
@@ -23,6 +23,7 @@ namespace Shader::Backend::GLASM {
 class EmitContext;
 
 enum class Type : u32 {
+    Void,
     Register,
     U32,
     S32,
@@ -65,6 +66,8 @@ struct Value {
             return false;
         }
         switch (type) {
+        case Type::Void:
+            return true;
         case Type::Register:
             return id == rhs.id;
         case Type::U32:
@@ -218,6 +221,8 @@ struct fmt::formatter<Shader::Backend::GLASM::ScalarU32> {
     template <typename FormatContext>
     auto format(const Shader::Backend::GLASM::ScalarU32& value, FormatContext& ctx) {
         switch (value.type) {
+        case Shader::Backend::GLASM::Type::Void:
+            break;
         case Shader::Backend::GLASM::Type::Register:
             return Shader::Backend::GLASM::FormatTo<true>(ctx, value.id);
         case Shader::Backend::GLASM::Type::U32:
@@ -242,6 +247,8 @@ struct fmt::formatter<Shader::Backend::GLASM::ScalarS32> {
     template <typename FormatContext>
     auto format(const Shader::Backend::GLASM::ScalarS32& value, FormatContext& ctx) {
         switch (value.type) {
+        case Shader::Backend::GLASM::Type::Void:
+            break;
         case Shader::Backend::GLASM::Type::Register:
             return Shader::Backend::GLASM::FormatTo<true>(ctx, value.id);
         case Shader::Backend::GLASM::Type::U32:
@@ -266,6 +273,8 @@ struct fmt::formatter<Shader::Backend::GLASM::ScalarF32> {
     template <typename FormatContext>
     auto format(const Shader::Backend::GLASM::ScalarF32& value, FormatContext& ctx) {
         switch (value.type) {
+        case Shader::Backend::GLASM::Type::Void:
+            break;
         case Shader::Backend::GLASM::Type::Register:
             return Shader::Backend::GLASM::FormatTo<true>(ctx, value.id);
         case Shader::Backend::GLASM::Type::U32:
@@ -290,6 +299,8 @@ struct fmt::formatter<Shader::Backend::GLASM::ScalarF64> {
     template <typename FormatContext>
     auto format(const Shader::Backend::GLASM::ScalarF64& value, FormatContext& ctx) {
         switch (value.type) {
+        case Shader::Backend::GLASM::Type::Void:
+            break;
         case Shader::Backend::GLASM::Type::Register:
             return Shader::Backend::GLASM::FormatTo<true>(ctx, value.id);
         case Shader::Backend::GLASM::Type::U32:
-- 
cgit v1.2.3


From fb3ba62b3a47ad645b007d5031ed9f8aaa7cb5c0 Mon Sep 17 00:00:00 2001
From: ReinUsesLisp <reinuseslisp@airmail.cc>
Date: Mon, 17 May 2021 19:24:09 -0300
Subject: glasm: Fix aliased bitcasts ref counting

---
 src/shader_recompiler/backend/glasm/reg_alloc.h | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'src/shader_recompiler/backend/glasm/reg_alloc.h')

diff --git a/src/shader_recompiler/backend/glasm/reg_alloc.h b/src/shader_recompiler/backend/glasm/reg_alloc.h
index ede6edd1f..41b7c92be 100644
--- a/src/shader_recompiler/backend/glasm/reg_alloc.h
+++ b/src/shader_recompiler/backend/glasm/reg_alloc.h
@@ -126,6 +126,12 @@ public:
         return num_used_long_registers;
     }
 
+    /// Returns true if the instruction is expected to be aliased to another
+    static bool IsAliased(const IR::Inst& inst);
+
+    /// Returns the underlying value out of an alias sequence
+    static IR::Inst& AliasInst(IR::Inst& inst);
+
 private:
     static constexpr size_t NUM_REGS = 4096;
     static constexpr size_t NUM_ELEMENTS = 4;
-- 
cgit v1.2.3


From ca05a13c62ad7693f8be924c168e400e8139b0d2 Mon Sep 17 00:00:00 2001
From: ReinUsesLisp <reinuseslisp@airmail.cc>
Date: Tue, 25 May 2021 02:22:21 -0300
Subject: glasm: Catch more register leaks

Add support for null registers. These are used when an instruction has
no usages.

This comes handy when an instruction is only used for its CC value, with
the caveat of having to invalidate all pseudo-instructions before
defining the instruction itself in the register allocator. This commits
changes this.

Workaround a bug on Nvidia's condition codes conditional execution using
branches.
---
 src/shader_recompiler/backend/glasm/reg_alloc.h | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

(limited to 'src/shader_recompiler/backend/glasm/reg_alloc.h')

diff --git a/src/shader_recompiler/backend/glasm/reg_alloc.h b/src/shader_recompiler/backend/glasm/reg_alloc.h
index 41b7c92be..b97c84146 100644
--- a/src/shader_recompiler/backend/glasm/reg_alloc.h
+++ b/src/shader_recompiler/backend/glasm/reg_alloc.h
@@ -35,10 +35,12 @@ enum class Type : u32 {
 struct Id {
     union {
         u32 raw;
-        BitField<0, 29, u32> index;
-        BitField<29, 1, u32> is_long;
-        BitField<30, 1, u32> is_spill;
-        BitField<31, 1, u32> is_condition_code;
+        BitField<0, 1, u32> is_valid;
+        BitField<1, 1, u32> is_long;
+        BitField<2, 1, u32> is_spill;
+        BitField<3, 1, u32> is_condition_code;
+        BitField<4, 1, u32> is_null;
+        BitField<5, 27, u32> index;
     };
 
     bool operator==(Id rhs) const noexcept {
@@ -164,12 +166,18 @@ auto FormatTo(FormatContext& ctx, Id id) {
         throw NotImplementedException("Spill emission");
     }
     if constexpr (scalar) {
+        if (id.is_null != 0) {
+            return fmt::format_to(ctx.out(), "{}", id.is_long != 0 ? "DC.x" : "RC.x");
+        }
         if (id.is_long != 0) {
             return fmt::format_to(ctx.out(), "D{}.x", id.index.Value());
         } else {
             return fmt::format_to(ctx.out(), "R{}.x", id.index.Value());
         }
     } else {
+        if (id.is_null != 0) {
+            return fmt::format_to(ctx.out(), "{}", id.is_long != 0 ? "DC" : "RC");
+        }
         if (id.is_long != 0) {
             return fmt::format_to(ctx.out(), "D{}", id.index.Value());
         } else {
-- 
cgit v1.2.3


From 379b305b4bc09799d53981fa6e5d9cbe6be99561 Mon Sep 17 00:00:00 2001
From: ReinUsesLisp <reinuseslisp@airmail.cc>
Date: Tue, 25 May 2021 02:34:08 -0300
Subject: glasm: Throw when there are register leaks

---
 src/shader_recompiler/backend/glasm/reg_alloc.h | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'src/shader_recompiler/backend/glasm/reg_alloc.h')

diff --git a/src/shader_recompiler/backend/glasm/reg_alloc.h b/src/shader_recompiler/backend/glasm/reg_alloc.h
index b97c84146..019e1bc0f 100644
--- a/src/shader_recompiler/backend/glasm/reg_alloc.h
+++ b/src/shader_recompiler/backend/glasm/reg_alloc.h
@@ -128,6 +128,10 @@ public:
         return num_used_long_registers;
     }
 
+    [[nodiscard]] bool IsEmpty() const noexcept {
+        return register_use.none() && long_register_use.none();
+    }
+
     /// Returns true if the instruction is expected to be aliased to another
     static bool IsAliased(const IR::Inst& inst);
 
-- 
cgit v1.2.3


From 75fd0079db9ac2f3bc6bcf182ed080a58538ed06 Mon Sep 17 00:00:00 2001
From: ReinUsesLisp <reinuseslisp@airmail.cc>
Date: Tue, 25 May 2021 02:46:51 -0300
Subject: glasm: Remove unnecessary value types

---
 src/shader_recompiler/backend/glasm/reg_alloc.h | 33 +------------------------
 1 file changed, 1 insertion(+), 32 deletions(-)

(limited to 'src/shader_recompiler/backend/glasm/reg_alloc.h')

diff --git a/src/shader_recompiler/backend/glasm/reg_alloc.h b/src/shader_recompiler/backend/glasm/reg_alloc.h
index 019e1bc0f..5a703daf2 100644
--- a/src/shader_recompiler/backend/glasm/reg_alloc.h
+++ b/src/shader_recompiler/backend/glasm/reg_alloc.h
@@ -26,10 +26,7 @@ enum class Type : u32 {
     Void,
     Register,
     U32,
-    S32,
-    F32,
     U64,
-    F64,
 };
 
 struct Id {
@@ -57,10 +54,7 @@ struct Value {
     union {
         Id id;
         u32 imm_u32;
-        s32 imm_s32;
-        f32 imm_f32;
         u64 imm_u64;
-        f64 imm_f64;
     };
 
     bool operator==(const Value& rhs) const noexcept {
@@ -74,14 +68,8 @@ struct Value {
             return id == rhs.id;
         case Type::U32:
             return imm_u32 == rhs.imm_u32;
-        case Type::S32:
-            return imm_s32 == rhs.imm_s32;
-        case Type::F32:
-            return Common::BitCast<u32>(imm_f32) == Common::BitCast<u32>(rhs.imm_f32);
         case Type::U64:
             return imm_u64 == rhs.imm_u64;
-        case Type::F64:
-            return Common::BitCast<u64>(imm_f64) == Common::BitCast<u64>(rhs.imm_f64);
         }
         return false;
     }
@@ -245,12 +233,7 @@ struct fmt::formatter<Shader::Backend::GLASM::ScalarU32> {
             return Shader::Backend::GLASM::FormatTo<true>(ctx, value.id);
         case Shader::Backend::GLASM::Type::U32:
             return fmt::format_to(ctx.out(), "{}", value.imm_u32);
-        case Shader::Backend::GLASM::Type::S32:
-            return fmt::format_to(ctx.out(), "{}", static_cast<u32>(value.imm_s32));
-        case Shader::Backend::GLASM::Type::F32:
-            return fmt::format_to(ctx.out(), "{}", Common::BitCast<u32>(value.imm_f32));
         case Shader::Backend::GLASM::Type::U64:
-        case Shader::Backend::GLASM::Type::F64:
             break;
         }
         throw Shader::InvalidArgument("Invalid value type {}", value.type);
@@ -271,12 +254,7 @@ struct fmt::formatter<Shader::Backend::GLASM::ScalarS32> {
             return Shader::Backend::GLASM::FormatTo<true>(ctx, value.id);
         case Shader::Backend::GLASM::Type::U32:
             return fmt::format_to(ctx.out(), "{}", static_cast<s32>(value.imm_u32));
-        case Shader::Backend::GLASM::Type::S32:
-            return fmt::format_to(ctx.out(), "{}", value.imm_s32);
-        case Shader::Backend::GLASM::Type::F32:
-            return fmt::format_to(ctx.out(), "{}", Common::BitCast<s32>(value.imm_f32));
         case Shader::Backend::GLASM::Type::U64:
-        case Shader::Backend::GLASM::Type::F64:
             break;
         }
         throw Shader::InvalidArgument("Invalid value type {}", value.type);
@@ -296,13 +274,8 @@ struct fmt::formatter<Shader::Backend::GLASM::ScalarF32> {
         case Shader::Backend::GLASM::Type::Register:
             return Shader::Backend::GLASM::FormatTo<true>(ctx, value.id);
         case Shader::Backend::GLASM::Type::U32:
-            return fmt::format_to(ctx.out(), "{}", Common::BitCast<u32>(value.imm_u32));
-        case Shader::Backend::GLASM::Type::S32:
-            return fmt::format_to(ctx.out(), "{}", Common::BitCast<s32>(value.imm_s32));
-        case Shader::Backend::GLASM::Type::F32:
-            return fmt::format_to(ctx.out(), "{}", value.imm_f32);
+            return fmt::format_to(ctx.out(), "{}", Common::BitCast<f32>(value.imm_u32));
         case Shader::Backend::GLASM::Type::U64:
-        case Shader::Backend::GLASM::Type::F64:
             break;
         }
         throw Shader::InvalidArgument("Invalid value type {}", value.type);
@@ -322,13 +295,9 @@ struct fmt::formatter<Shader::Backend::GLASM::ScalarF64> {
         case Shader::Backend::GLASM::Type::Register:
             return Shader::Backend::GLASM::FormatTo<true>(ctx, value.id);
         case Shader::Backend::GLASM::Type::U32:
-        case Shader::Backend::GLASM::Type::S32:
-        case Shader::Backend::GLASM::Type::F32:
             break;
         case Shader::Backend::GLASM::Type::U64:
             return fmt::format_to(ctx.out(), "{}", Common::BitCast<f64>(value.imm_u64));
-        case Shader::Backend::GLASM::Type::F64:
-            return fmt::format_to(ctx.out(), "{}", value.imm_f64);
         }
         throw Shader::InvalidArgument("Invalid value type {}", value.type);
     }
-- 
cgit v1.2.3


From 49946cf780c317b4c5ccabb52ec433eba01c1970 Mon Sep 17 00:00:00 2001
From: lat9nq <22451773+lat9nq@users.noreply.github.com>
Date: Sun, 11 Jul 2021 22:10:38 -0400
Subject: shader_recompiler, video_core: Resolve clang errors

Silences the following warnings-turned-errors:
-Wsign-conversion
-Wunused-private-field
-Wbraced-scalar-init
-Wunused-variable

And some other errors
---
 src/shader_recompiler/backend/glasm/reg_alloc.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'src/shader_recompiler/backend/glasm/reg_alloc.h')

diff --git a/src/shader_recompiler/backend/glasm/reg_alloc.h b/src/shader_recompiler/backend/glasm/reg_alloc.h
index 5a703daf2..82aec66c6 100644
--- a/src/shader_recompiler/backend/glasm/reg_alloc.h
+++ b/src/shader_recompiler/backend/glasm/reg_alloc.h
@@ -86,7 +86,7 @@ struct ScalarF64 : Value {};
 
 class RegAlloc {
 public:
-    RegAlloc(EmitContext& ctx_) : ctx{ctx_} {}
+    RegAlloc() = default;
 
     Register Define(IR::Inst& inst);
 
@@ -142,7 +142,6 @@ private:
 
     void Free(Id id);
 
-    EmitContext& ctx;
     size_t num_used_registers{};
     size_t num_used_long_registers{};
     std::bitset<NUM_REGS> register_use{};
-- 
cgit v1.2.3