From 8ac4452754292b74fa6bf2713dd9f1458ce5243d Mon Sep 17 00:00:00 2001
From: jsmall-nvidia <jsmall@nvidia.com>
Date: Wed, 27 Feb 2019 12:15:02 -0500
Subject: Use kIRPseudoOp_Pos for identity asuint/asint/asfloat casts.  (#865)

* * Add 'identity' version of bit casts (asint, asuint, asfloat) for scalar and vector
* Added identity bit casts for matrix (cos no op). We don't support matrix asint on glsl targets
* Added tests in bit-cast.slang

* Use kIRPseudoOp_Pos for identity asuint/asint/asfloat casts.
---
 source/slang/hlsl.meta.slang   | 48 +++++++++++----------------
 source/slang/hlsl.meta.slang.h | 75 ++++++++++++++++++++++++++----------------
 2 files changed, 65 insertions(+), 58 deletions(-)

(limited to 'source')

diff --git a/source/slang/hlsl.meta.slang b/source/slang/hlsl.meta.slang
index e51016a53..a8fd37243 100644
--- a/source/slang/hlsl.meta.slang
+++ b/source/slang/hlsl.meta.slang
@@ -380,32 +380,30 @@ __target_intrinsic(glsl, "intBitsToFloat")
 float asfloat(int x);
 __target_intrinsic(glsl, "uintBitsToFloat")
 float asfloat(uint x);
-__target_intrinsic(glsl, "$0")
-float asfloat(float x);
 
 // GLSL Vector
 __generic<let N : int>
-__target_intrinsic(glsl, "$0")
-vector<float,N> asfloat(vector<float,N> x);
-__generic<let N : int>
 __target_intrinsic(glsl, "intBitsToFloat")
 vector<float,N> asfloat(vector< int,N> x);
 __generic<let N : int>
 __target_intrinsic(glsl, "uintBitsToFloat")
 vector<float,N> asfloat(vector<uint,N> x);
 
-// GLSL Matrix (only identity for now)
+// No op
+__intrinsic_op($(kIRPseudoOp_Pos))
+float asfloat(float x);
+__generic<let N : int>
+__intrinsic_op($(kIRPseudoOp_Pos))
+vector<float,N> asfloat(vector<float,N> x);
 __generic<let N : int, let M : int>
-__target_intrinsic(glsl, "$0")
+__intrinsic_op($(kIRPseudoOp_Pos))
 matrix<float,N,M> asfloat(matrix<float,N,M> x);
 
 // Pass thru to HLSL
-float asfloat(float x);
 float asfloat(uint x);
 float asfloat(int x);
 __generic<let N : int, let M : int> matrix<float,N,M> asfloat(matrix< int,N,M> x);
 __generic<let N : int, let M : int> matrix<float,N,M> asfloat(matrix<uint,N,M> x);
-__generic<let N : int, let M : int> matrix<float,N,M> asfloat(matrix<float,N,M> x);
 
 // Inverse sine (HLSL SM 1.0)
 __generic<T : __BuiltinFloatingPointType> T asin(T x);
@@ -419,8 +417,6 @@ __target_intrinsic(glsl, "floatBitsToInt")
 int asint(float x);
 __target_intrinsic(glsl, "int($0)")
 int asint(uint x);
-__target_intrinsic(glsl, "$0")
-int asint(int x);
 
 // GLSL Vector
 __generic<let N : int>
@@ -429,27 +425,25 @@ vector<int,N> asint(vector<float,N> x);
 __generic<let N : int>
 __target_intrinsic(glsl, "ivec$N0($0)")
 vector<int,N> asint(vector<uint,N> x);
+
+// No op
+__intrinsic_op($(kIRPseudoOp_Pos))
+int asint(int x);
 __generic<let N : int>
-__target_intrinsic(glsl, "$0")
+__intrinsic_op($(kIRPseudoOp_Pos))
 vector<int,N> asint(vector<int,N> x);
-
-// GLSL Matrix (just identity for now)
-
 __generic<let N : int, let M : int>
-__target_intrinsic(glsl, "$0")
+__intrinsic_op($(kIRPseudoOp_Pos))
 matrix<int,N,M> asint(matrix<int,N,M> x);
 
 // Pass thru HLSL
 
 int asint(float x);
-int asint(int x);
 int asint(uint x);
 
 __generic<let N : int> vector<int,N> asint(vector<uint,N> x);
-__generic<let N : int> vector<int,N> asint(vector<int,N> x);
 __generic<let N : int, let M : int> matrix<int,N,M> asint(matrix<float,N,M> x);
 __generic<let N : int, let M : int> matrix<int,N,M> asint(matrix<uint,N,M> x);
-__generic<let N : int, let M : int> matrix<int,N,M> asint(matrix<int,N,M> x);
 
 // Reinterpret bits of double as a uint (HLSL SM 5.0)
 
@@ -466,8 +460,6 @@ __target_intrinsic(glsl, "floatBitsToUint")
 uint asuint(float x);
 __target_intrinsic(glsl, "uint($0)")
 uint asuint(int x);
-__target_intrinsic(glsl, "$0")
-uint asuint(uint x);
 
 // GLSL Vector
 __generic<let N : int>
@@ -476,28 +468,26 @@ vector<uint,N> asuint(vector<float,N> x);
 __generic<let N : int>
 __target_intrinsic(glsl, "uvec$N0($0)")
 vector<uint,N> asuint(vector<int,N> x);
+
+// No op
+__intrinsic_op($(kIRPseudoOp_Pos))
+uint asuint(uint x);
 __generic<let N : int>
-__target_intrinsic(glsl, "$0")
+__intrinsic_op($(kIRPseudoOp_Pos))
 vector<uint,N> asuint(vector<uint,N> x);
-
-// GLSL Matrix (Identity only for now)
 __generic<let N : int, let M : int>
-__target_intrinsic(glsl, "$0")
+__intrinsic_op($(kIRPseudoOp_Pos))
 matrix<uint,N,M> asuint(matrix<uint,N,M> x);
 
 // Pass thru HLSL
-
 uint asuint(float x);
 uint asuint(int x);
-uint asuint(uint x);
 
 __generic<let N : int> vector<uint,N> asuint(vector<float,N> x);
 __generic<let N : int> vector<uint,N> asuint(vector<int,N> x);
-__generic<let N : int> vector<uint,N> asuint(vector<uint,N> x);
 
 __generic<let N : int, let M : int> matrix<uint,N,M> asuint(matrix<float,N,M> x);
 __generic<let N : int, let M : int> matrix<uint,N,M> asuint(matrix<int,N,M> x);
-__generic<let N : int, let M : int> matrix<uint,N,M> asuint(matrix<uint,N,M> x);
 
 // Inverse tangent (HLSL SM 1.0)
 __generic<T : __BuiltinFloatingPointType> T atan(T x);
diff --git a/source/slang/hlsl.meta.slang.h b/source/slang/hlsl.meta.slang.h
index 5132fbc29..e26269c3c 100644
--- a/source/slang/hlsl.meta.slang.h
+++ b/source/slang/hlsl.meta.slang.h
@@ -425,32 +425,39 @@ SLANG_RAW("__target_intrinsic(glsl, \"intBitsToFloat\")\n")
 SLANG_RAW("float asfloat(int x);\n")
 SLANG_RAW("__target_intrinsic(glsl, \"uintBitsToFloat\")\n")
 SLANG_RAW("float asfloat(uint x);\n")
-SLANG_RAW("__target_intrinsic(glsl, \"$0\")\n")
-SLANG_RAW("float asfloat(float x);\n")
 SLANG_RAW("\n")
 SLANG_RAW("// GLSL Vector\n")
 SLANG_RAW("__generic<let N : int>\n")
-SLANG_RAW("__target_intrinsic(glsl, \"$0\")\n")
-SLANG_RAW("vector<float,N> asfloat(vector<float,N> x);\n")
-SLANG_RAW("__generic<let N : int>\n")
 SLANG_RAW("__target_intrinsic(glsl, \"intBitsToFloat\")\n")
 SLANG_RAW("vector<float,N> asfloat(vector< int,N> x);\n")
 SLANG_RAW("__generic<let N : int>\n")
 SLANG_RAW("__target_intrinsic(glsl, \"uintBitsToFloat\")\n")
 SLANG_RAW("vector<float,N> asfloat(vector<uint,N> x);\n")
 SLANG_RAW("\n")
-SLANG_RAW("// GLSL Matrix (only identity for now)\n")
+SLANG_RAW("// No op\n")
+SLANG_RAW("__intrinsic_op(")
+SLANG_SPLICE(kIRPseudoOp_Pos
+)
+SLANG_RAW(")\n")
+SLANG_RAW("float asfloat(float x);\n")
+SLANG_RAW("__generic<let N : int>\n")
+SLANG_RAW("__intrinsic_op(")
+SLANG_SPLICE(kIRPseudoOp_Pos
+)
+SLANG_RAW(")\n")
+SLANG_RAW("vector<float,N> asfloat(vector<float,N> x);\n")
 SLANG_RAW("__generic<let N : int, let M : int>\n")
-SLANG_RAW("__target_intrinsic(glsl, \"$0\")\n")
+SLANG_RAW("__intrinsic_op(")
+SLANG_SPLICE(kIRPseudoOp_Pos
+)
+SLANG_RAW(")\n")
 SLANG_RAW("matrix<float,N,M> asfloat(matrix<float,N,M> x);\n")
 SLANG_RAW("\n")
 SLANG_RAW("// Pass thru to HLSL\n")
-SLANG_RAW("float asfloat(float x);\n")
 SLANG_RAW("float asfloat(uint x);\n")
 SLANG_RAW("float asfloat(int x);\n")
 SLANG_RAW("__generic<let N : int, let M : int> matrix<float,N,M> asfloat(matrix< int,N,M> x);\n")
 SLANG_RAW("__generic<let N : int, let M : int> matrix<float,N,M> asfloat(matrix<uint,N,M> x);\n")
-SLANG_RAW("__generic<let N : int, let M : int> matrix<float,N,M> asfloat(matrix<float,N,M> x);\n")
 SLANG_RAW("\n")
 SLANG_RAW("// Inverse sine (HLSL SM 1.0)\n")
 SLANG_RAW("__generic<T : __BuiltinFloatingPointType> T asin(T x);\n")
@@ -464,8 +471,6 @@ SLANG_RAW("__target_intrinsic(glsl, \"floatBitsToInt\")\n")
 SLANG_RAW("int asint(float x);\n")
 SLANG_RAW("__target_intrinsic(glsl, \"int($0)\")\n")
 SLANG_RAW("int asint(uint x);\n")
-SLANG_RAW("__target_intrinsic(glsl, \"$0\")\n")
-SLANG_RAW("int asint(int x);\n")
 SLANG_RAW("\n")
 SLANG_RAW("// GLSL Vector\n")
 SLANG_RAW("__generic<let N : int>\n")
@@ -474,27 +479,34 @@ SLANG_RAW("vector<int,N> asint(vector<float,N> x);\n")
 SLANG_RAW("__generic<let N : int>\n")
 SLANG_RAW("__target_intrinsic(glsl, \"ivec$N0($0)\")\n")
 SLANG_RAW("vector<int,N> asint(vector<uint,N> x);\n")
+SLANG_RAW("\n")
+SLANG_RAW("// No op\n")
+SLANG_RAW("__intrinsic_op(")
+SLANG_SPLICE(kIRPseudoOp_Pos
+)
+SLANG_RAW(")\n")
+SLANG_RAW("int asint(int x);\n")
 SLANG_RAW("__generic<let N : int>\n")
-SLANG_RAW("__target_intrinsic(glsl, \"$0\")\n")
+SLANG_RAW("__intrinsic_op(")
+SLANG_SPLICE(kIRPseudoOp_Pos
+)
+SLANG_RAW(")\n")
 SLANG_RAW("vector<int,N> asint(vector<int,N> x);\n")
-SLANG_RAW("\n")
-SLANG_RAW("// GLSL Matrix (just identity for now)\n")
-SLANG_RAW("\n")
 SLANG_RAW("__generic<let N : int, let M : int>\n")
-SLANG_RAW("__target_intrinsic(glsl, \"$0\")\n")
+SLANG_RAW("__intrinsic_op(")
+SLANG_SPLICE(kIRPseudoOp_Pos
+)
+SLANG_RAW(")\n")
 SLANG_RAW("matrix<int,N,M> asint(matrix<int,N,M> x);\n")
 SLANG_RAW("\n")
 SLANG_RAW("// Pass thru HLSL\n")
 SLANG_RAW("\n")
 SLANG_RAW("int asint(float x);\n")
-SLANG_RAW("int asint(int x);\n")
 SLANG_RAW("int asint(uint x);\n")
 SLANG_RAW("\n")
 SLANG_RAW("__generic<let N : int> vector<int,N> asint(vector<uint,N> x);\n")
-SLANG_RAW("__generic<let N : int> vector<int,N> asint(vector<int,N> x);\n")
 SLANG_RAW("__generic<let N : int, let M : int> matrix<int,N,M> asint(matrix<float,N,M> x);\n")
 SLANG_RAW("__generic<let N : int, let M : int> matrix<int,N,M> asint(matrix<uint,N,M> x);\n")
-SLANG_RAW("__generic<let N : int, let M : int> matrix<int,N,M> asint(matrix<int,N,M> x);\n")
 SLANG_RAW("\n")
 SLANG_RAW("// Reinterpret bits of double as a uint (HLSL SM 5.0)\n")
 SLANG_RAW("\n")
@@ -511,8 +523,6 @@ SLANG_RAW("__target_intrinsic(glsl, \"floatBitsToUint\")\n")
 SLANG_RAW("uint asuint(float x);\n")
 SLANG_RAW("__target_intrinsic(glsl, \"uint($0)\")\n")
 SLANG_RAW("uint asuint(int x);\n")
-SLANG_RAW("__target_intrinsic(glsl, \"$0\")\n")
-SLANG_RAW("uint asuint(uint x);\n")
 SLANG_RAW("\n")
 SLANG_RAW("// GLSL Vector\n")
 SLANG_RAW("__generic<let N : int>\n")
@@ -521,28 +531,35 @@ SLANG_RAW("vector<uint,N> asuint(vector<float,N> x);\n")
 SLANG_RAW("__generic<let N : int>\n")
 SLANG_RAW("__target_intrinsic(glsl, \"uvec$N0($0)\")\n")
 SLANG_RAW("vector<uint,N> asuint(vector<int,N> x);\n")
+SLANG_RAW("\n")
+SLANG_RAW("// No op\n")
+SLANG_RAW("__intrinsic_op(")
+SLANG_SPLICE(kIRPseudoOp_Pos
+)
+SLANG_RAW(")\n")
+SLANG_RAW("uint asuint(uint x);\n")
 SLANG_RAW("__generic<let N : int>\n")
-SLANG_RAW("__target_intrinsic(glsl, \"$0\")\n")
+SLANG_RAW("__intrinsic_op(")
+SLANG_SPLICE(kIRPseudoOp_Pos
+)
+SLANG_RAW(")\n")
 SLANG_RAW("vector<uint,N> asuint(vector<uint,N> x);\n")
-SLANG_RAW("\n")
-SLANG_RAW("// GLSL Matrix (Identity only for now)\n")
 SLANG_RAW("__generic<let N : int, let M : int>\n")
-SLANG_RAW("__target_intrinsic(glsl, \"$0\")\n")
+SLANG_RAW("__intrinsic_op(")
+SLANG_SPLICE(kIRPseudoOp_Pos
+)
+SLANG_RAW(")\n")
 SLANG_RAW("matrix<uint,N,M> asuint(matrix<uint,N,M> x);\n")
 SLANG_RAW("\n")
 SLANG_RAW("// Pass thru HLSL\n")
-SLANG_RAW("\n")
 SLANG_RAW("uint asuint(float x);\n")
 SLANG_RAW("uint asuint(int x);\n")
-SLANG_RAW("uint asuint(uint x);\n")
 SLANG_RAW("\n")
 SLANG_RAW("__generic<let N : int> vector<uint,N> asuint(vector<float,N> x);\n")
 SLANG_RAW("__generic<let N : int> vector<uint,N> asuint(vector<int,N> x);\n")
-SLANG_RAW("__generic<let N : int> vector<uint,N> asuint(vector<uint,N> x);\n")
 SLANG_RAW("\n")
 SLANG_RAW("__generic<let N : int, let M : int> matrix<uint,N,M> asuint(matrix<float,N,M> x);\n")
 SLANG_RAW("__generic<let N : int, let M : int> matrix<uint,N,M> asuint(matrix<int,N,M> x);\n")
-SLANG_RAW("__generic<let N : int, let M : int> matrix<uint,N,M> asuint(matrix<uint,N,M> x);\n")
 SLANG_RAW("\n")
 SLANG_RAW("// Inverse tangent (HLSL SM 1.0)\n")
 SLANG_RAW("__generic<T : __BuiltinFloatingPointType> T atan(T x);\n")
-- 
cgit v1.2.3