summaryrefslogtreecommitdiffstats
path: root/source
diff options
context:
space:
mode:
Diffstat (limited to 'source')
-rw-r--r--source/slang/core.meta.slang270
-rw-r--r--source/slang/slang-stdlib.cpp42
2 files changed, 266 insertions, 46 deletions
diff --git a/source/slang/core.meta.slang b/source/slang/core.meta.slang
index 42295eeca..c0c8c84f6 100644
--- a/source/slang/core.meta.slang
+++ b/source/slang/core.meta.slang
@@ -398,6 +398,9 @@ void __store<T>(Ptr<T> ptr, T val);
__intrinsic_op($(kIROp_getElementPtr))
Ptr<T> __getElementPtr<T>(Ptr<T> ptr, int index);
+__intrinsic_op($(kIROp_getElementPtr))
+Ptr<T> __getElementPtr<T>(Ptr<T> ptr, int64_t index);
+
__generic<T>
__intrinsic_op($(kIROp_Less))
bool operator<(Ptr<T> p1, Ptr<T> p2);
@@ -429,8 +432,8 @@ extension bool
__intrinsic_op($(kIROp_CastPtrToBool))
__init(Ptr<T> ptr);
- static bool maxValue = true;
- static bool minValue = false;
+ static const bool maxValue = true;
+ static const bool minValue = false;
}
extension uint64_t
@@ -439,8 +442,8 @@ extension uint64_t
__intrinsic_op($(kIROp_Construct))
__init(Ptr<T> ptr);
- static uint64_t maxValue = 0xFFFFFFFFFFFFFFFFULL;
- static uint64_t minValue = 0;
+ static const uint64_t maxValue = 0xFFFFFFFFFFFFFFFFULL;
+ static const uint64_t minValue = 0;
}
extension int64_t
@@ -449,8 +452,8 @@ extension int64_t
__intrinsic_op($(kIROp_Construct))
__init(Ptr<T> ptr);
- static int64_t maxValue = 0x7FFFFFFFFFFFFFFFLL;
- static int64_t minValue = -0x8000000000000000LL;
+ static const int64_t maxValue = 0x7FFFFFFFFFFFFFFFLL;
+ static const int64_t minValue = -0x8000000000000000LL;
}
__generic<T>
@@ -555,50 +558,59 @@ __intrinsic_type($(kIROp_DynamicType))
struct __Dynamic
{};
+extension half
+{
+ static const half maxValue = half(65504);
+ static const half minValue = half(-65504);
+}
+
extension float
{
- static float maxValue = 340282346638528859811704183484516925440.0f;
+ static const float maxValue = 340282346638528859811704183484516925440.0f;
+ static const float minValue = -340282346638528859811704183484516925440.0f;
+
}
extension double
{
- static double maxValue = 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.0;
+ static const double maxValue = 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.0;
+ static const double minValue = -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.0;
}
extension int
{
- static int maxValue = 2147483647;
- static int minValue = -2147483648;
+ static const int maxValue = 2147483647;
+ static const int minValue = -2147483648;
}
extension uint
{
- static uint maxValue = 4294967295;
- static uint minValue = 0;
+ static const uint maxValue = 4294967295;
+ static const uint minValue = 0;
}
extension int8_t
{
- static int8_t maxValue = 127;
- static int8_t minValue = -128;
+ static const int8_t maxValue = 127;
+ static const int8_t minValue = -128;
}
-extension uint16_t
+extension uint8_t
{
- static uint16_t maxValue = 255;
- static uint16_t minValue = 0;
+ static const uint8_t maxValue = 255;
+ static const uint8_t minValue = 0;
}
-extension int16_t
+extension uint16_t
{
- static int16_t maxValue = 32767;
- static int16_t minValue = -32768;
+ static const uint16_t maxValue = 65535;
+ static const uint16_t minValue = 0;
}
-extension uint16_t
+extension int16_t
{
- static uint16_t maxValue = 65535;
- static uint16_t minValue = 0;
+ static const int16_t maxValue = 32767;
+ static const int16_t minValue = -32768;
}
/// An `N` component vector with elements of type `T`.
@@ -1795,6 +1807,7 @@ for (auto op : intrinsicUnaryOps)
// scalar version
sb << "__prefix __intrinsic_op(" << int(op.opCode) << ") " << resultType << " operator" << op.opName << "(" << type.name << " value);\n";
+ sb << "__intrinsic_op(" << int(op.opCode) << ") " << resultType << " __" << op.funcName << "(" << type.name << " value);\n";
// vector version
sb << "__generic<let N : int> ";
@@ -1939,6 +1952,7 @@ for (auto op : intrinsicBinaryOps)
// scalar version
sb << "__intrinsic_op(" << int(op.opCode) << ") " << resultType << " operator" << op.opName << "(" << leftType << " left, " << rightType << " right);\n";
+ sb << "__intrinsic_op(" << int(op.opCode) << ") " << resultType << " __" << op.funcName << "(" << leftType << " left, " << rightType << " right);\n";
// vector version
sb << "__generic<let N : int> ";
@@ -2041,11 +2055,12 @@ for (auto op : intrinsicBinaryOps)
static const struct ShiftOpInfo
{
char const* name;
+ char const* funcName;
int op;
} kShiftOps[] =
{
- { "<<", kIROp_Lsh },
- { ">>", kIROp_Rsh },
+ { "<<", "shl", kIROp_Lsh },
+ { ">>", "shr", kIROp_Rsh },
};
for(auto info : kShiftOps) {
}}}}
@@ -2055,6 +2070,10 @@ __intrinsic_op($(info.op))
L operator$(info.name)(L left, R right);
__generic<L: __BuiltinIntegerType, R: __BuiltinIntegerType>
+__intrinsic_op($(info.op))
+L __$(info.funcName)(L left, R right);
+
+__generic<L: __BuiltinIntegerType, R: __BuiltinIntegerType>
[__unsafeForceInlineEarly]
L operator$(info.name)=(in out L left, R right)
{
@@ -2188,6 +2207,7 @@ ${{{{
//@ public:
+
// Bit cast
__generic<T, U>
[__unsafeForceInlineEarly]
@@ -2276,6 +2296,206 @@ bool operator!=(E left, E right);
//@ public:
+// public interfaces for generic arithmetic types.
+
+interface IComparable
+{
+ int compareTo(This other);
+}
+
+interface IArithmetic : IComparable
+{
+ This add(This other);
+ This sub(This other);
+ This mul(This other);
+ This div(This other);
+ This mod(This other);
+ This neg();
+ __init(int val);
+ static const This maxValue;
+ static const This minValue;
+}
+
+interface IInteger : IArithmetic
+{
+ This shl(int value);
+ This shr(int value);
+ This bitAnd(This other);
+ This bitOr(This other);
+ This bitXor(This other);
+ This bitNot();
+ int toInt();
+ int64_t toInt64();
+ uint toUInt();
+ uint64_t toUInt64();
+}
+
+interface IFloat : IArithmetic
+{
+ __init(float value);
+ float toFloat();
+}
+
+__generic<T : IComparable>
+[__unsafeForceInlineEarly]
+bool operator<(T v0, T v1)
+{
+ return v0.compareTo(v1) < 0;
+}
+__generic<T : IComparable>
+[__unsafeForceInlineEarly]
+bool operator>(T v0, T v1)
+{
+ return v0.compareTo(v1) > 0;
+}
+__generic<T : IComparable>
+[__unsafeForceInlineEarly]
+bool operator ==(T v0, T v1)
+{
+ return v0.compareTo(v1) == 0;
+}
+__generic<T : IComparable>
+[__unsafeForceInlineEarly]
+bool operator >=(T v0, T v1)
+{
+ return v0.compareTo(v1) >= 0;
+}
+__generic<T : IComparable>
+[__unsafeForceInlineEarly]
+bool operator <=(T v0, T v1)
+{
+ return v0.compareTo(v1) <= 0;
+}
+__generic<T : IComparable>
+[__unsafeForceInlineEarly]
+bool operator !=(T v0, T v1)
+{
+ return v0.compareTo(v1) != 0;
+}
+
+__generic<T : IArithmetic>
+[__unsafeForceInlineEarly]
+T operator +(T v0, T v1)
+{
+ return v0.add(v1);
+}
+
+__generic<T : IArithmetic>
+[__unsafeForceInlineEarly]
+T operator -(T v0, T v1)
+{
+ return v0.sub(v1);
+}
+
+__generic<T : IArithmetic>
+[__unsafeForceInlineEarly]
+T operator *(T v0, T v1)
+{
+ return v0.mul(v1);
+}
+
+__generic<T : IArithmetic>
+[__unsafeForceInlineEarly]
+T operator /(T v0, T v1)
+{
+ return v0.div(v1);
+}
+
+__generic<T : IArithmetic>
+[__unsafeForceInlineEarly]
+T operator %(T v0, T v1)
+{
+ return v0.mod(v1);
+}
+
+__generic<T : IArithmetic>
+[__unsafeForceInlineEarly]
+__prefix T operator -(T v0)
+{
+ return v0.neg();
+}
+__generic<T : IInteger>
+[__unsafeForceInlineEarly]
+T operator &(T v0, T v1)
+{
+ return v0.bitAnd(v1);
+}
+__generic<T : IInteger>
+[__unsafeForceInlineEarly]
+T operator |(T v0, T v1)
+{
+ return v0.bitOr(v1);
+}
+__generic<T : IInteger>
+[__unsafeForceInlineEarly]
+T operator ^(T v0, T v1)
+{
+ return v0.bitXor(v1);
+}
+__generic<T : IInteger>
+[__unsafeForceInlineEarly]
+__prefix T operator ~(T v0)
+{
+ return v0.bitNot();
+}
+
+// Provide implementations to public generic arithmetic interfaces for builtin types.
+
+${{{{
+// Code gen integer type implementations.
+
+for (int tt = 0; tt < kBaseTypeCount; ++tt)
+{
+ if (kBaseTypes[tt].flags & (SINT_MASK | UINT_MASK))
+ {
+}}}}
+extension $(kBaseTypes[tt].name) : IInteger
+{
+ [__unsafeForceInlineEarly] int compareTo(This other){return this-other;}
+ [__unsafeForceInlineEarly] This add(This other) { return __add(this, other); }
+ [__unsafeForceInlineEarly] This sub(This other) { return __sub(this, other); }
+ [__unsafeForceInlineEarly] This mul(This other) { return __mul(this, other); }
+ [__unsafeForceInlineEarly] This div(This other) { return __div(this, other); }
+ [__unsafeForceInlineEarly] This mod(This other) { return __irem(this, other); }
+ [__unsafeForceInlineEarly] This neg() { return __neg(this); }
+ [__unsafeForceInlineEarly] This shl(int other) { return __shl(this, other); }
+ [__unsafeForceInlineEarly] This shr(int other) { return __shr(this, other); }
+ [__unsafeForceInlineEarly] This bitAnd(This other) { return __add(this, other); }
+ [__unsafeForceInlineEarly] This bitOr(This other) { return __or(this, other); }
+ [__unsafeForceInlineEarly] This bitXor(This other) { return __xor(this, other); }
+ [__unsafeForceInlineEarly] This bitNot() { return __not(this); }
+ [__unsafeForceInlineEarly] int toInt() { return int(this); }
+ [__unsafeForceInlineEarly] int64_t toInt64() { return int64_t(this); }
+ [__unsafeForceInlineEarly] uint toUInt() { return uint(this); }
+ [__unsafeForceInlineEarly] uint64_t toUInt64() { return uint64_t(this); }
+}
+${{{{
+ }
+ else if (kBaseTypes[tt].flags & FLOAT_MASK)
+ {
+}}}}
+
+extension $(kBaseTypes[tt].name) : IFloat
+{
+ [__unsafeForceInlineEarly] static int __sign(This val)
+ {
+ return int(__leq(This(0),val)) - int(__leq(val,This(0)));
+ }
+
+ [__unsafeForceInlineEarly] int compareTo(This other) { return __sign(this-other); }
+ [__unsafeForceInlineEarly] This add(This other) { return __add(this, other); }
+ [__unsafeForceInlineEarly] This sub(This other) { return __sub(this, other); }
+ [__unsafeForceInlineEarly] This mul(This other) { return __mul(this, other); }
+ [__unsafeForceInlineEarly] This div(This other) { return __div(this, other); }
+ [__unsafeForceInlineEarly] This mod(This other) { return __frem(this, other); }
+ [__unsafeForceInlineEarly] This neg() { return __neg(this); }
+ [__unsafeForceInlineEarly] float toFloat() { return float(this); }
+}
+${{{{
+ }
+}
+}}}}
+
// Binding Attributes
__attributeTarget(DeclBase)
diff --git a/source/slang/slang-stdlib.cpp b/source/slang/slang-stdlib.cpp
index 1ead48cb8..ac952d2eb 100644
--- a/source/slang/slang-stdlib.cpp
+++ b/source/slang/slang-stdlib.cpp
@@ -189,32 +189,32 @@ namespace Slang
}
}
- struct IntrinsicOpInfo { IROp opCode; char const* opName; char const* interface; unsigned flags; };
+ struct IntrinsicOpInfo { IROp opCode; char const* funcName; char const* opName; char const* interface; unsigned flags; };
static const IntrinsicOpInfo intrinsicUnaryOps[] = {
- { kIROp_Neg, "-", "__BuiltinArithmeticType", ARITHMETIC_MASK },
- { kIROp_Not, "!", nullptr, BOOL_MASK | BOOL_RESULT },
- { kIROp_BitNot, "~", "__BuiltinIntegerType", INT_MASK },
+ { kIROp_Neg, "neg", "-", "__BuiltinArithmeticType", ARITHMETIC_MASK },
+ { kIROp_Not, "logicalNot", "!", nullptr, BOOL_MASK | BOOL_RESULT },
+ { kIROp_BitNot, "not", "~", "__BuiltinIntegerType", INT_MASK },
};
static const IntrinsicOpInfo intrinsicBinaryOps[] = {
- { kIROp_Add, "+", "__BuiltinArithmeticType", ARITHMETIC_MASK },
- { kIROp_Sub, "-", "__BuiltinArithmeticType", ARITHMETIC_MASK },
- { kIROp_Mul, "*", "__BuiltinArithmeticType", ARITHMETIC_MASK },
- { kIROp_Div, "/", "__BuiltinArithmeticType", ARITHMETIC_MASK },
- { kIROp_IRem, "%", "__BuiltinIntegerType", INT_MASK },
- { kIROp_FRem, "%", "__BuiltinFloatingPointType", FLOAT_MASK },
- { kIROp_And, "&&", nullptr, BOOL_MASK | BOOL_RESULT},
- { kIROp_Or, "||", nullptr, BOOL_MASK | BOOL_RESULT },
- { kIROp_BitAnd, "&", "__BuiltinLogicalType", LOGICAL_MASK },
- { kIROp_BitOr, "|", "__BuiltinLogicalType", LOGICAL_MASK },
- { kIROp_BitXor, "^", "__BuiltinLogicalType", LOGICAL_MASK },
- { kIROp_Eql, "==", "__BuiltinType", ANY_MASK | BOOL_RESULT },
- { kIROp_Neq, "!=", "__BuiltinType", ANY_MASK | BOOL_RESULT },
- { kIROp_Greater, ">", "__BuiltinArithmeticType", ARITHMETIC_MASK | BOOL_RESULT },
- { kIROp_Less, "<", "__BuiltinArithmeticType", ARITHMETIC_MASK | BOOL_RESULT },
- { kIROp_Geq, ">=", "__BuiltinArithmeticType", ARITHMETIC_MASK | BOOL_RESULT },
- { kIROp_Leq, "<=", "__BuiltinArithmeticType", ARITHMETIC_MASK | BOOL_RESULT },
+ {kIROp_Add, "add", "+", "__BuiltinArithmeticType", ARITHMETIC_MASK},
+ {kIROp_Sub, "sub", "-", "__BuiltinArithmeticType", ARITHMETIC_MASK},
+ {kIROp_Mul, "mul", "*", "__BuiltinArithmeticType", ARITHMETIC_MASK},
+ {kIROp_Div, "div", "/", "__BuiltinArithmeticType", ARITHMETIC_MASK},
+ {kIROp_IRem, "irem", "%", "__BuiltinIntegerType", INT_MASK},
+ {kIROp_FRem, "frem", "%", "__BuiltinFloatingPointType", FLOAT_MASK},
+ {kIROp_And, "logicalAnd", "&&", nullptr, BOOL_MASK | BOOL_RESULT},
+ {kIROp_Or, "logicalOr", "||", nullptr, BOOL_MASK | BOOL_RESULT},
+ {kIROp_BitAnd, "and", "&", "__BuiltinLogicalType", LOGICAL_MASK},
+ {kIROp_BitOr, "or", "|", "__BuiltinLogicalType", LOGICAL_MASK},
+ {kIROp_BitXor, "xor", "^", "__BuiltinLogicalType", LOGICAL_MASK},
+ {kIROp_Eql, "eql", "==", "__BuiltinType", ANY_MASK | BOOL_RESULT},
+ {kIROp_Neq, "neq", "!=", "__BuiltinType", ANY_MASK | BOOL_RESULT},
+ {kIROp_Greater, "greater", ">", "__BuiltinArithmeticType", ARITHMETIC_MASK | BOOL_RESULT},
+ {kIROp_Less, "less", "<", "__BuiltinArithmeticType", ARITHMETIC_MASK | BOOL_RESULT},
+ {kIROp_Geq, "geq", ">=", "__BuiltinArithmeticType", ARITHMETIC_MASK | BOOL_RESULT},
+ {kIROp_Leq, "leq", "<=", "__BuiltinArithmeticType", ARITHMETIC_MASK | BOOL_RESULT},
};
// Both the following functions use these macros.
generated by cgit v1.2.3 (git 2.39.1) at 2026-06-02 14:22:32 +0000