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

---
 .../backend/glasm/emit_glasm_integer.cpp           | 216 +++++++++------------
 1 file changed, 93 insertions(+), 123 deletions(-)

(limited to 'src/shader_recompiler/backend/glasm/emit_glasm_integer.cpp')

diff --git a/src/shader_recompiler/backend/glasm/emit_glasm_integer.cpp b/src/shader_recompiler/backend/glasm/emit_glasm_integer.cpp
index 579806c383..7b88d6f029 100644
--- a/src/shader_recompiler/backend/glasm/emit_glasm_integer.cpp
+++ b/src/shader_recompiler/backend/glasm/emit_glasm_integer.cpp
@@ -2,239 +2,209 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <string_view>
-
 #include "shader_recompiler/backend/glasm/emit_context.h"
 #include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
 #include "shader_recompiler/frontend/ir/value.h"
 
 namespace Shader::Backend::GLASM {
 
-void EmitIAdd32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                [[maybe_unused]] std::string_view a, [[maybe_unused]] std::string_view b) {
-    ctx.Add("ADD.U {},{},{};", inst, a, b);
+void EmitIAdd32(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b) {
+    ctx.Add("ADD.S {}.x,{},{};", inst, a, b);
 }
 
-void EmitIAdd64([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                [[maybe_unused]] std::string_view a, [[maybe_unused]] std::string_view b) {
+void EmitIAdd64([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register a,
+                [[maybe_unused]] Register b) {
     throw NotImplementedException("GLASM instruction");
 }
 
-void EmitISub32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                [[maybe_unused]] std::string_view a, [[maybe_unused]] std::string_view b) {
-    ctx.Add("SUB.U {},{},{};", inst, a, b);
+void EmitISub32(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b) {
+    ctx.Add("SUB.S {}.x,{},{};", inst, a, b);
 }
 
-void EmitISub64([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                [[maybe_unused]] std::string_view a, [[maybe_unused]] std::string_view b) {
+void EmitISub64([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register a,
+                [[maybe_unused]] Register b) {
     throw NotImplementedException("GLASM instruction");
 }
 
-void EmitIMul32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                [[maybe_unused]] std::string_view a, [[maybe_unused]] std::string_view b) {
-    throw NotImplementedException("GLASM instruction");
+void EmitIMul32(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b) {
+    ctx.Add("MUL.S {}.x,{},{};", inst, a, b);
 }
 
-void EmitINeg32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                [[maybe_unused]] std::string_view value) {
+void EmitINeg32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarS32 value) {
     throw NotImplementedException("GLASM instruction");
 }
 
-void EmitINeg64([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                [[maybe_unused]] std::string_view value) {
+void EmitINeg64([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register value) {
     throw NotImplementedException("GLASM instruction");
 }
 
-void EmitIAbs32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                [[maybe_unused]] std::string_view value) {
+void EmitIAbs32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarS32 value) {
     throw NotImplementedException("GLASM instruction");
 }
 
-void EmitIAbs64([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                [[maybe_unused]] std::string_view value) {
+void EmitIAbs64([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register value) {
     throw NotImplementedException("GLASM instruction");
 }
 
-void EmitShiftLeftLogical32([[maybe_unused]] EmitContext& ctx,
-                            [[maybe_unused]] std::string_view base,
-                            [[maybe_unused]] std::string_view shift) {
-    throw NotImplementedException("GLASM instruction");
+void EmitShiftLeftLogical32(EmitContext& ctx, IR::Inst& inst, ScalarU32 base, ScalarU32 shift) {
+    ctx.Add("SHL.U {}.x,{},{};", inst, base, shift);
 }
 
-void EmitShiftLeftLogical64([[maybe_unused]] EmitContext& ctx,
-                            [[maybe_unused]] std::string_view base,
-                            [[maybe_unused]] std::string_view shift) {
+void EmitShiftLeftLogical64([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register base,
+                            [[maybe_unused]] Register shift) {
     throw NotImplementedException("GLASM instruction");
 }
 
-void EmitShiftRightLogical32([[maybe_unused]] EmitContext& ctx,
-                             [[maybe_unused]] std::string_view base,
-                             [[maybe_unused]] std::string_view shift) {
+void EmitShiftRightLogical32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarU32 base,
+                             [[maybe_unused]] ScalarU32 shift) {
     throw NotImplementedException("GLASM instruction");
 }
 
-void EmitShiftRightLogical64([[maybe_unused]] EmitContext& ctx,
-                             [[maybe_unused]] std::string_view base,
-                             [[maybe_unused]] std::string_view shift) {
+void EmitShiftRightLogical64([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register base,
+                             [[maybe_unused]] Register shift) {
     throw NotImplementedException("GLASM instruction");
 }
 
-void EmitShiftRightArithmetic32([[maybe_unused]] EmitContext& ctx,
-                                [[maybe_unused]] std::string_view base,
-                                [[maybe_unused]] std::string_view shift) {
+void EmitShiftRightArithmetic32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarS32 base,
+                                [[maybe_unused]] ScalarS32 shift) {
     throw NotImplementedException("GLASM instruction");
 }
 
-void EmitShiftRightArithmetic64([[maybe_unused]] EmitContext& ctx,
-                                [[maybe_unused]] std::string_view base,
-                                [[maybe_unused]] std::string_view shift) {
+void EmitShiftRightArithmetic64([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register base,
+                                [[maybe_unused]] Register shift) {
     throw NotImplementedException("GLASM instruction");
 }
 
-void EmitBitwiseAnd32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                      [[maybe_unused]] std::string_view a, [[maybe_unused]] std::string_view b) {
-    ctx.Add("AND {},{},{};", inst, a, b);
+void EmitBitwiseAnd32(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b) {
+    ctx.Add("AND.S {}.x,{},{};", inst, a, b);
 }
 
-void EmitBitwiseOr32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                     [[maybe_unused]] std::string_view a, [[maybe_unused]] std::string_view b) {
-    ctx.Add("OR {},{},{};", inst, a, b);
+void EmitBitwiseOr32(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b) {
+    ctx.Add("OR.S {}.x,{},{};", inst, a, b);
 }
 
-void EmitBitwiseXor32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                      [[maybe_unused]] std::string_view a, [[maybe_unused]] std::string_view b) {
-    ctx.Add("XOR {},{},{};", inst, a, b);
+void EmitBitwiseXor32(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b) {
+    ctx.Add("XOR.S {}.x,{},{};", inst, a, b);
 }
 
-void EmitBitFieldInsert(EmitContext& ctx, IR::Inst& inst, std::string_view base,
-                        std::string_view insert, std::string_view offset, std::string_view count) {
-    ctx.Add("MOV.U RC.x,{};MOV.U RC.y,{};", count, offset);
-    ctx.Add("BFI.U {},RC,{},{};", inst, insert, base);
+void EmitBitFieldInsert([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarS32 base,
+                        [[maybe_unused]] ScalarS32 insert, [[maybe_unused]] ScalarS32 offset,
+                        [[maybe_unused]] ScalarS32 count) {
+    throw NotImplementedException("GLASM instruction");
 }
 
-void EmitBitFieldSExtract(EmitContext& ctx, IR::Inst& inst, std::string_view base,
-                          std::string_view offset, std::string_view count) {
-    ctx.Add("MOV.U RC.x,{};MOV.U RC.y,{};", count, offset);
-    ctx.Add("BFE.S {},RC,{};", inst, base);
+void EmitBitFieldSExtract([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
+                          [[maybe_unused]] ScalarS32 base, [[maybe_unused]] ScalarS32 offset,
+                          [[maybe_unused]] ScalarS32 count) {
+    throw NotImplementedException("GLASM instruction");
 }
 
-void EmitBitFieldUExtract(EmitContext& ctx, IR::Inst& inst, std::string_view base,
-                          std::string_view offset, std::string_view count) {
-    ctx.Add("MOV.U RC.x,{};MOV.U RC.y,{};", count, offset);
-    ctx.Add("BFE.U {},RC,{};", inst, base);
+void EmitBitFieldUExtract([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
+                          [[maybe_unused]] ScalarU32 base, [[maybe_unused]] ScalarU32 offset,
+                          [[maybe_unused]] ScalarU32 count) {
+    throw NotImplementedException("GLASM instruction");
 }
 
-void EmitBitReverse32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                      [[maybe_unused]] std::string_view value) {
-    ctx.Add("BFR {},{};", inst, value);
+void EmitBitReverse32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarS32 value) {
+    throw NotImplementedException("GLASM instruction");
 }
 
-void EmitBitCount32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                    [[maybe_unused]] std::string_view value) {
+void EmitBitCount32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarS32 value) {
     throw NotImplementedException("GLASM instruction");
 }
 
-void EmitBitwiseNot32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                      [[maybe_unused]] std::string_view value) {
-    ctx.Add("NOT {},{};", inst, value);
+void EmitBitwiseNot32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarS32 value) {
+    throw NotImplementedException("GLASM instruction");
 }
 
-void EmitFindSMsb32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                    [[maybe_unused]] std::string_view value) {
+void EmitFindSMsb32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarS32 value) {
     throw NotImplementedException("GLASM instruction");
 }
 
-void EmitFindUMsb32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                    [[maybe_unused]] std::string_view value) {
+void EmitFindUMsb32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarU32 value) {
     throw NotImplementedException("GLASM instruction");
 }
 
-void EmitSMin32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                [[maybe_unused]] std::string_view a, [[maybe_unused]] std::string_view b) {
+void EmitSMin32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarS32 a,
+                [[maybe_unused]] ScalarS32 b) {
     throw NotImplementedException("GLASM instruction");
 }
 
-void EmitUMin32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                [[maybe_unused]] std::string_view a, [[maybe_unused]] std::string_view b) {
+void EmitUMin32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarU32 a,
+                [[maybe_unused]] ScalarU32 b) {
     throw NotImplementedException("GLASM instruction");
 }
 
-void EmitSMax32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                [[maybe_unused]] std::string_view a, [[maybe_unused]] std::string_view b) {
+void EmitSMax32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarS32 a,
+                [[maybe_unused]] ScalarS32 b) {
     throw NotImplementedException("GLASM instruction");
 }
 
-void EmitUMax32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                [[maybe_unused]] std::string_view a, [[maybe_unused]] std::string_view b) {
+void EmitUMax32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarU32 a,
+                [[maybe_unused]] ScalarU32 b) {
     throw NotImplementedException("GLASM instruction");
 }
 
 void EmitSClamp32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                  [[maybe_unused]] std::string_view value, [[maybe_unused]] std::string_view min,
-                  [[maybe_unused]] std::string_view max) {
+                  [[maybe_unused]] ScalarS32 value, [[maybe_unused]] ScalarS32 min,
+                  [[maybe_unused]] ScalarS32 max) {
     throw NotImplementedException("GLASM instruction");
 }
 
 void EmitUClamp32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                  [[maybe_unused]] std::string_view value, [[maybe_unused]] std::string_view min,
-                  [[maybe_unused]] std::string_view max) {
+                  [[maybe_unused]] ScalarU32 value, [[maybe_unused]] ScalarU32 min,
+                  [[maybe_unused]] ScalarU32 max) {
     throw NotImplementedException("GLASM instruction");
 }
 
-void EmitSLessThan([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                   [[maybe_unused]] std::string_view lhs, [[maybe_unused]] std::string_view rhs) {
-    ctx.Add("SLT.S {},{},{};", inst, lhs, rhs);
+void EmitSLessThan([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarS32 lhs,
+                   [[maybe_unused]] ScalarS32 rhs) {
+    throw NotImplementedException("GLASM instruction");
 }
 
-void EmitULessThan([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                   [[maybe_unused]] std::string_view lhs, [[maybe_unused]] std::string_view rhs) {
-    ctx.Add("SLT.U {},{},{};", inst, lhs, rhs);
+void EmitULessThan([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarU32 lhs,
+                   [[maybe_unused]] ScalarU32 rhs) {
+    throw NotImplementedException("GLASM instruction");
 }
 
-void EmitIEqual([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                [[maybe_unused]] std::string_view lhs, [[maybe_unused]] std::string_view rhs) {
-    ctx.Add("SEQ {},{},{};", inst, lhs, rhs);
+void EmitIEqual([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarS32 lhs,
+                [[maybe_unused]] ScalarS32 rhs) {
+    throw NotImplementedException("GLASM instruction");
 }
 
-void EmitSLessThanEqual([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                        [[maybe_unused]] std::string_view lhs,
-                        [[maybe_unused]] std::string_view rhs) {
-    ctx.Add("SLE.S {},{},{};", inst, lhs, rhs);
+void EmitSLessThanEqual([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarS32 lhs,
+                        [[maybe_unused]] ScalarS32 rhs) {
+    throw NotImplementedException("GLASM instruction");
 }
 
-void EmitULessThanEqual([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                        [[maybe_unused]] std::string_view lhs,
-                        [[maybe_unused]] std::string_view rhs) {
-    ctx.Add("SLE.U {},{},{};", inst, lhs, rhs);
+void EmitULessThanEqual([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarU32 lhs,
+                        [[maybe_unused]] ScalarU32 rhs) {
+    throw NotImplementedException("GLASM instruction");
 }
 
-void EmitSGreaterThan([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                      [[maybe_unused]] std::string_view lhs,
-                      [[maybe_unused]] std::string_view rhs) {
-    ctx.Add("SGT.S {},{},{};", inst, lhs, rhs);
+void EmitSGreaterThan([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarS32 lhs,
+                      [[maybe_unused]] ScalarS32 rhs) {
+    throw NotImplementedException("GLASM instruction");
 }
 
-void EmitUGreaterThan([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                      [[maybe_unused]] std::string_view lhs,
-                      [[maybe_unused]] std::string_view rhs) {
-    ctx.Add("SGT.U {},{},{};", inst, lhs, rhs);
+void EmitUGreaterThan([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarU32 lhs,
+                      [[maybe_unused]] ScalarU32 rhs) {
+    throw NotImplementedException("GLASM instruction");
 }
 
-void EmitINotEqual([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                   [[maybe_unused]] std::string_view lhs, [[maybe_unused]] std::string_view rhs) {
-    ctx.Add("SNE.U {},{},{};", inst, lhs, rhs);
+void EmitINotEqual([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarS32 lhs,
+                   [[maybe_unused]] ScalarS32 rhs) {
+    throw NotImplementedException("GLASM instruction");
 }
 
-void EmitSGreaterThanEqual([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                           [[maybe_unused]] std::string_view lhs,
-                           [[maybe_unused]] std::string_view rhs) {
-    ctx.Add("SGE.S {},{},{};", inst, lhs, rhs);
+void EmitSGreaterThanEqual([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarS32 lhs,
+                           [[maybe_unused]] ScalarS32 rhs) {
+    throw NotImplementedException("GLASM instruction");
 }
 
-void EmitUGreaterThanEqual([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                           [[maybe_unused]] std::string_view lhs,
-                           [[maybe_unused]] std::string_view rhs) {
-    ctx.Add("SGE.U {},{},{};", inst, lhs, rhs);
+void EmitUGreaterThanEqual([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarU32 lhs,
+                           [[maybe_unused]] ScalarU32 rhs) {
+    throw NotImplementedException("GLASM instruction");
 }
 
 } // namespace Shader::Backend::GLASM
-- 
cgit v1.2.3-70-g09d2