Skip to content

S
swiftshader
Commit c37252c9 by Nicolas Capens
Options

Use Value null pointers for dummy RValues.

This refactoring paves the way for the next patch to support constructing RValues from Constant pointers as well. Bug swiftshader:12 Change-Id: I26df3da13314de556dc1af40388278d144560b97 Reviewed-on: https://swiftshader-review.googlesource.com/7371Reviewed-by: 's avatarAlexis Hétu <sugoi@google.com> Reviewed-by: 's avatarNicolas Capens <capn@google.com> Tested-by: 's avatarNicolas Capens <capn@google.com>
parent 58e61f29
Showing with 141 additions and 141 deletions
src/Reactor/SubzeroReactor.cpp
......@@ -1969,12 +1969,12 @@ namespace sw
RValue<Byte8> operator+(RValue<Byte8> lhs, RValue<Byte8> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<Byte8>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Byte8>(V(nullptr));
}
RValue<Byte8> operator-(RValue<Byte8> lhs, RValue<Byte8> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<Byte8>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Byte8>(V(nullptr));
}
// RValue<Byte8> operator*(RValue<Byte8> lhs, RValue<Byte8> rhs)
......@@ -1994,17 +1994,17 @@ namespace sw
RValue<Byte8> operator&(RValue<Byte8> lhs, RValue<Byte8> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<Byte8>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Byte8>(V(nullptr));
}
RValue<Byte8> operator|(RValue<Byte8> lhs, RValue<Byte8> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<Byte8>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Byte8>(V(nullptr));
}
RValue<Byte8> operator^(RValue<Byte8> lhs, RValue<Byte8> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<Byte8>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Byte8>(V(nullptr));
}
// RValue<Byte8> operator<<(RValue<Byte8> lhs, unsigned char rhs)
......@@ -2084,42 +2084,42 @@ namespace sw
RValue<Byte8> AddSat(RValue<Byte8> x, RValue<Byte8> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Byte8>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Byte8>(V(nullptr));
}
RValue<Byte8> SubSat(RValue<Byte8> x, RValue<Byte8> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Byte8>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Byte8>(V(nullptr));
}
RValue<Short4> Unpack(RValue<Byte4> x)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
RValue<Short4> UnpackLow(RValue<Byte8> x, RValue<Byte8> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
RValue<Short4> UnpackHigh(RValue<Byte8> x, RValue<Byte8> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
RValue<Int> SignMask(RValue<Byte8> x)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int>(V(nullptr));
}
// RValue<Byte8> CmpGT(RValue<Byte8> x, RValue<Byte8> y)
// {
// assert(false && "UNIMPLEMENTED"); return RValue<Byte8>(nullptr);
// assert(false && "UNIMPLEMENTED"); return RValue<Byte8>(V(nullptr));
// }
RValue<Byte8> CmpEQ(RValue<Byte8> x, RValue<Byte8> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Byte8>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Byte8>(V(nullptr));
}
Type *Byte8::getType()
......@@ -2194,12 +2194,12 @@ namespace sw
RValue<SByte8> operator+(RValue<SByte8> lhs, RValue<SByte8> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<SByte8>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<SByte8>(V(nullptr));
}
RValue<SByte8> operator-(RValue<SByte8> lhs, RValue<SByte8> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<SByte8>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<SByte8>(V(nullptr));
}
// RValue<SByte8> operator*(RValue<SByte8> lhs, RValue<SByte8> rhs)
......@@ -2309,37 +2309,37 @@ namespace sw
RValue<SByte8> AddSat(RValue<SByte8> x, RValue<SByte8> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<SByte8>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<SByte8>(V(nullptr));
}
RValue<SByte8> SubSat(RValue<SByte8> x, RValue<SByte8> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<SByte8>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<SByte8>(V(nullptr));
}
RValue<Short4> UnpackLow(RValue<SByte8> x, RValue<SByte8> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
RValue<Short4> UnpackHigh(RValue<SByte8> x, RValue<SByte8> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
RValue<Int> SignMask(RValue<SByte8> x)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int>(V(nullptr));
}
RValue<Byte8> CmpGT(RValue<SByte8> x, RValue<SByte8> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Byte8>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Byte8>(V(nullptr));
}
RValue<Byte8> CmpEQ(RValue<SByte8> x, RValue<SByte8> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Byte8>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Byte8>(V(nullptr));
}
Type *SByte8::getType()
......@@ -2536,17 +2536,17 @@ namespace sw
RValue<Short4> operator+(RValue<Short4> lhs, RValue<Short4> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
RValue<Short4> operator-(RValue<Short4> lhs, RValue<Short4> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
RValue<Short4> operator*(RValue<Short4> lhs, RValue<Short4> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
// RValue<Short4> operator/(RValue<Short4> lhs, RValue<Short4> rhs)
......@@ -2561,45 +2561,45 @@ namespace sw
RValue<Short4> operator&(RValue<Short4> lhs, RValue<Short4> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
RValue<Short4> operator|(RValue<Short4> lhs, RValue<Short4> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
RValue<Short4> operator^(RValue<Short4> lhs, RValue<Short4> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
RValue<Short4> operator<<(RValue<Short4> lhs, unsigned char rhs)
{
// return RValue<Short4>(Nucleus::createShl(lhs.value, rhs.value));
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
RValue<Short4> operator>>(RValue<Short4> lhs, unsigned char rhs)
{
// return RValue<Short4>(Nucleus::createAShr(lhs.value, rhs.value));
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
RValue<Short4> operator<<(RValue<Short4> lhs, RValue<Long1> rhs)
{
// return RValue<Short4>(Nucleus::createShl(lhs.value, rhs.value));
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
RValue<Short4> operator>>(RValue<Short4> lhs, RValue<Long1> rhs)
{
// return RValue<Short4>(Nucleus::createAShr(lhs.value, rhs.value));
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
RValue<Short4> operator+=(const Short4 &lhs, RValue<Short4> rhs)
......@@ -2669,87 +2669,87 @@ namespace sw
RValue<Short4> operator-(RValue<Short4> val)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
RValue<Short4> operator~(RValue<Short4> val)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
RValue<Short4> RoundShort4(RValue<Float4> cast)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
RValue<Short4> Max(RValue<Short4> x, RValue<Short4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
RValue<Short4> Min(RValue<Short4> x, RValue<Short4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
RValue<Short4> AddSat(RValue<Short4> x, RValue<Short4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
RValue<Short4> SubSat(RValue<Short4> x, RValue<Short4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
RValue<Short4> MulHigh(RValue<Short4> x, RValue<Short4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
RValue<Int2> MulAdd(RValue<Short4> x, RValue<Short4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(V(nullptr));
}
RValue<SByte8> Pack(RValue<Short4> x, RValue<Short4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<SByte8>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<SByte8>(V(nullptr));
}
RValue<Int2> UnpackLow(RValue<Short4> x, RValue<Short4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(V(nullptr));
}
RValue<Int2> UnpackHigh(RValue<Short4> x, RValue<Short4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(V(nullptr));
}
RValue<Short4> Swizzle(RValue<Short4> x, unsigned char select)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
RValue<Short4> Insert(RValue<Short4> val, RValue<Short> element, int i)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
RValue<Short> Extract(RValue<Short4> val, int i)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short>(V(nullptr));
}
RValue<Short4> CmpGT(RValue<Short4> x, RValue<Short4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
RValue<Short4> CmpEQ(RValue<Short4> x, RValue<Short4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
}
Type *Short4::getType()
......@@ -2880,37 +2880,37 @@ namespace sw
RValue<UShort4> operator+(RValue<UShort4> lhs, RValue<UShort4> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(V(nullptr));
}
RValue<UShort4> operator-(RValue<UShort4> lhs, RValue<UShort4> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(V(nullptr));
}
RValue<UShort4> operator*(RValue<UShort4> lhs, RValue<UShort4> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(V(nullptr));
}
RValue<UShort4> operator<<(RValue<UShort4> lhs, unsigned char rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(V(nullptr));
}
RValue<UShort4> operator>>(RValue<UShort4> lhs, unsigned char rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(V(nullptr));
}
RValue<UShort4> operator<<(RValue<UShort4> lhs, RValue<Long1> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(V(nullptr));
}
RValue<UShort4> operator>>(RValue<UShort4> lhs, RValue<Long1> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(V(nullptr));
}
RValue<UShort4> operator<<=(const UShort4 &lhs, unsigned char rhs)
......@@ -2935,42 +2935,42 @@ namespace sw
RValue<UShort4> operator~(RValue<UShort4> val)
{
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(V(nullptr));
}
RValue<UShort4> Max(RValue<UShort4> x, RValue<UShort4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(V(nullptr));
}
RValue<UShort4> Min(RValue<UShort4> x, RValue<UShort4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(V(nullptr));
}
RValue<UShort4> AddSat(RValue<UShort4> x, RValue<UShort4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(V(nullptr));
}
RValue<UShort4> SubSat(RValue<UShort4> x, RValue<UShort4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(V(nullptr));
}
RValue<UShort4> MulHigh(RValue<UShort4> x, RValue<UShort4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(V(nullptr));
}
RValue<UShort4> Average(RValue<UShort4> x, RValue<UShort4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(V(nullptr));
}
RValue<Byte8> Pack(RValue<UShort4> x, RValue<UShort4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Byte8>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Byte8>(V(nullptr));
}
Type *UShort4::getType()
......@@ -3017,27 +3017,27 @@ namespace sw
RValue<Short8> operator<<(RValue<Short8> lhs, unsigned char rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short8>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short8>(V(nullptr));
}
RValue<Short8> operator>>(RValue<Short8> lhs, unsigned char rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short8>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short8>(V(nullptr));
}
RValue<Int4> MulAdd(RValue<Short8> x, RValue<Short8> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int4>(V(nullptr));
}
RValue<Int4> Abs(RValue<Int4> x)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int4>(V(nullptr));
}
RValue<Short8> MulHigh(RValue<Short8> x, RValue<Short8> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short8>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short8>(V(nullptr));
}
Type *Short8::getType()
......@@ -3102,12 +3102,12 @@ namespace sw
RValue<UShort8> operator<<(RValue<UShort8> lhs, unsigned char rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<UShort8>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UShort8>(V(nullptr));
}
RValue<UShort8> operator>>(RValue<UShort8> lhs, unsigned char rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<UShort8>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UShort8>(V(nullptr));
}
RValue<UShort8> operator+(RValue<UShort8> lhs, RValue<UShort8> rhs)
......@@ -3132,18 +3132,18 @@ namespace sw
RValue<UShort8> Swizzle(RValue<UShort8> x, char select0, char select1, char select2, char select3, char select4, char select5, char select6, char select7)
{
assert(false && "UNIMPLEMENTED"); return RValue<UShort8>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UShort8>(V(nullptr));
}
RValue<UShort8> MulHigh(RValue<UShort8> x, RValue<UShort8> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<UShort8>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UShort8>(V(nullptr));
}
// FIXME: Implement as Shuffle(x, y, Select(i0, ..., i16)) and Shuffle(x, y, SELECT_PACK_REPEAT(element))
// RValue<UShort8> PackRepeat(RValue<Byte16> x, RValue<Byte16> y, int element)
// {
// assert(false && "UNIMPLEMENTED"); return RValue<UShort8>(nullptr);
// assert(false && "UNIMPLEMENTED"); return RValue<UShort8>(V(nullptr));
// }
Type *UShort8::getType()
......@@ -3414,7 +3414,7 @@ namespace sw
RValue<Int> operator++(const Int &val, int) // Post-increment
{
assert(false && "UNIMPLEMENTED"); return RValue<Int>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int>(V(nullptr));
}
const Int &operator++(const Int &val) // Pre-increment
......@@ -3424,7 +3424,7 @@ namespace sw
RValue<Int> operator--(const Int &val, int) // Post-decrement
{
assert(false && "UNIMPLEMENTED"); return RValue<Int>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int>(V(nullptr));
}
const Int &operator--(const Int &val) // Pre-decrement
......@@ -3479,7 +3479,7 @@ namespace sw
RValue<Int> RoundInt(RValue<Float> cast)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int>(V(nullptr));
}
Type *Int::getType()
......@@ -3585,7 +3585,7 @@ namespace sw
RValue<Long2> UnpackHigh(RValue<Long2> x, RValue<Long2> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Long2>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Long2>(V(nullptr));
}
Type *Long2::getType()
......@@ -3833,7 +3833,7 @@ namespace sw
RValue<UInt> operator++(const UInt &val, int) // Post-increment
{
assert(false && "UNIMPLEMENTED"); return RValue<UInt>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UInt>(V(nullptr));
}
const UInt &operator++(const UInt &val) // Pre-increment
......@@ -3843,7 +3843,7 @@ namespace sw
RValue<UInt> operator--(const UInt &val, int) // Post-decrement
{
assert(false && "UNIMPLEMENTED"); return RValue<UInt>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UInt>(V(nullptr));
}
const UInt &operator--(const UInt &val) // Pre-decrement
......@@ -3898,7 +3898,7 @@ namespace sw
// RValue<UInt> RoundUInt(RValue<Float> cast)
// {
// assert(false && "UNIMPLEMENTED"); return RValue<UInt>(nullptr);
// assert(false && "UNIMPLEMENTED"); return RValue<UInt>(V(nullptr));
// }
Type *UInt::getType()
......@@ -3994,12 +3994,12 @@ namespace sw
RValue<Int2> operator+(RValue<Int2> lhs, RValue<Int2> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(V(nullptr));
}
RValue<Int2> operator-(RValue<Int2> lhs, RValue<Int2> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(V(nullptr));
}
// RValue<Int2> operator*(RValue<Int2> lhs, RValue<Int2> rhs)
......@@ -4019,37 +4019,37 @@ namespace sw
RValue<Int2> operator&(RValue<Int2> lhs, RValue<Int2> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(V(nullptr));
}
RValue<Int2> operator|(RValue<Int2> lhs, RValue<Int2> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(V(nullptr));
}
RValue<Int2> operator^(RValue<Int2> lhs, RValue<Int2> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(V(nullptr));
}
RValue<Int2> operator<<(RValue<Int2> lhs, unsigned char rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(V(nullptr));
}
RValue<Int2> operator>>(RValue<Int2> lhs, unsigned char rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(V(nullptr));
}
RValue<Int2> operator<<(RValue<Int2> lhs, RValue<Long1> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(V(nullptr));
}
RValue<Int2> operator>>(RValue<Int2> lhs, RValue<Long1> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(V(nullptr));
}
RValue<Int2> operator+=(const Int2 &lhs, RValue<Int2> rhs)
......@@ -4124,27 +4124,27 @@ namespace sw
RValue<Int2> operator~(RValue<Int2> val)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(V(nullptr));
}
RValue<Long1> UnpackLow(RValue<Int2> x, RValue<Int2> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Long1>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Long1>(V(nullptr));
}
RValue<Long1> UnpackHigh(RValue<Int2> x, RValue<Int2> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Long1>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Long1>(V(nullptr));
}
RValue<Int> Extract(RValue<Int2> val, int i)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int>(V(nullptr));
}
RValue<Int2> Insert(RValue<Int2> val, RValue<Int> element, int i)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int2>(V(nullptr));
}
Type *Int2::getType()
......@@ -4212,12 +4212,12 @@ namespace sw
RValue<UInt2> operator+(RValue<UInt2> lhs, RValue<UInt2> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<UInt2>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UInt2>(V(nullptr));
}
RValue<UInt2> operator-(RValue<UInt2> lhs, RValue<UInt2> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<UInt2>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UInt2>(V(nullptr));
}
// RValue<UInt2> operator*(RValue<UInt2> lhs, RValue<UInt2> rhs)
......@@ -4237,37 +4237,37 @@ namespace sw
RValue<UInt2> operator&(RValue<UInt2> lhs, RValue<UInt2> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<UInt2>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UInt2>(V(nullptr));
}
RValue<UInt2> operator|(RValue<UInt2> lhs, RValue<UInt2> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<UInt2>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UInt2>(V(nullptr));
}
RValue<UInt2> operator^(RValue<UInt2> lhs, RValue<UInt2> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<UInt2>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UInt2>(V(nullptr));
}
RValue<UInt2> operator<<(RValue<UInt2> lhs, unsigned char rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<UInt2>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UInt2>(V(nullptr));
}
RValue<UInt2> operator>>(RValue<UInt2> lhs, unsigned char rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<UInt2>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UInt2>(V(nullptr));
}
RValue<UInt2> operator<<(RValue<UInt2> lhs, RValue<Long1> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<UInt2>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UInt2>(V(nullptr));
}
RValue<UInt2> operator>>(RValue<UInt2> lhs, RValue<Long1> rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<UInt2>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UInt2>(V(nullptr));
}
RValue<UInt2> operator+=(const UInt2 &lhs, RValue<UInt2> rhs)
......@@ -4554,12 +4554,12 @@ namespace sw
RValue<Int4> operator<<(RValue<Int4> lhs, unsigned char rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int4>(V(nullptr));
}
RValue<Int4> operator>>(RValue<Int4> lhs, unsigned char rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int4>(V(nullptr));
}
RValue<Int4> operator<<(RValue<Int4> lhs, RValue<Int4> rhs)
......@@ -4669,22 +4669,22 @@ namespace sw
RValue<Int4> Max(RValue<Int4> x, RValue<Int4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int4>(V(nullptr));
}
RValue<Int4> Min(RValue<Int4> x, RValue<Int4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int4>(V(nullptr));
}
RValue<Int4> RoundInt(RValue<Float4> cast)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int4>(V(nullptr));
}
RValue<Short8> Pack(RValue<Int4> x, RValue<Int4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Short8>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Short8>(V(nullptr));
}
RValue<Int> Extract(RValue<Int4> x, int i)
......@@ -4699,7 +4699,7 @@ namespace sw
RValue<Int> SignMask(RValue<Int4> x)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int>(V(nullptr));
}
RValue<Int4> Swizzle(RValue<Int4> x, unsigned char select)
......@@ -4873,12 +4873,12 @@ namespace sw
RValue<UInt4> operator<<(RValue<UInt4> lhs, unsigned char rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<UInt4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UInt4>(V(nullptr));
}
RValue<UInt4> operator>>(RValue<UInt4> lhs, unsigned char rhs)
{
assert(false && "UNIMPLEMENTED"); return RValue<UInt4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UInt4>(V(nullptr));
}
RValue<UInt4> operator<<(RValue<UInt4> lhs, RValue<UInt4> rhs)
......@@ -4988,17 +4988,17 @@ namespace sw
RValue<UInt4> Max(RValue<UInt4> x, RValue<UInt4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<UInt4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UInt4>(V(nullptr));
}
RValue<UInt4> Min(RValue<UInt4> x, RValue<UInt4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<UInt4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UInt4>(V(nullptr));
}
RValue<UShort8> Pack(RValue<UInt4> x, RValue<UInt4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<UShort8>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<UShort8>(V(nullptr));
}
Type *UInt4::getType()
......@@ -5159,42 +5159,42 @@ namespace sw
RValue<Float> Rcp_pp(RValue<Float> x, bool exactAtPow2)
{
assert(false && "UNIMPLEMENTED"); return RValue<Float>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Float>(V(nullptr));
}
RValue<Float> RcpSqrt_pp(RValue<Float> x)
{
assert(false && "UNIMPLEMENTED"); return RValue<Float>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Float>(V(nullptr));
}
RValue<Float> Sqrt(RValue<Float> x)
{
assert(false && "UNIMPLEMENTED"); return RValue<Float>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Float>(V(nullptr));
}
RValue<Float> Round(RValue<Float> x)
{
assert(false && "UNIMPLEMENTED"); return RValue<Float>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Float>(V(nullptr));
}
RValue<Float> Trunc(RValue<Float> x)
{
assert(false && "UNIMPLEMENTED"); return RValue<Float>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Float>(V(nullptr));
}
RValue<Float> Frac(RValue<Float> x)
{
assert(false && "UNIMPLEMENTED"); return RValue<Float>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Float>(V(nullptr));
}
RValue<Float> Floor(RValue<Float> x)
{
assert(false && "UNIMPLEMENTED"); return RValue<Float>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Float>(V(nullptr));
}
RValue<Float> Ceil(RValue<Float> x)
{
assert(false && "UNIMPLEMENTED"); return RValue<Float>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Float>(V(nullptr));
}
Type *Float::getType()
......@@ -5453,32 +5453,32 @@ namespace sw
RValue<Float4> Abs(RValue<Float4> x)
{
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(V(nullptr));
}
RValue<Float4> Max(RValue<Float4> x, RValue<Float4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(V(nullptr));
}
RValue<Float4> Min(RValue<Float4> x, RValue<Float4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(V(nullptr));
}
RValue<Float4> Rcp_pp(RValue<Float4> x, bool exactAtPow2)
{
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(V(nullptr));
}
RValue<Float4> RcpSqrt_pp(RValue<Float4> x)
{
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(V(nullptr));
}
RValue<Float4> Sqrt(RValue<Float4> x)
{
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(V(nullptr));
}
RValue<Float4> Insert(const Float4 &val, RValue<Float> element, int i)
......@@ -5503,17 +5503,17 @@ namespace sw
RValue<Float4> ShuffleLowHigh(RValue<Float4> x, RValue<Float4> y, unsigned char imm)
{
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(V(nullptr));
}
RValue<Float4> UnpackLow(RValue<Float4> x, RValue<Float4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(V(nullptr));
}
RValue<Float4> UnpackHigh(RValue<Float4> x, RValue<Float4> y)
{
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(V(nullptr));
}
RValue<Float4> Mask(Float4 &lhs, RValue<Float4> rhs, unsigned char select)
......@@ -5527,7 +5527,7 @@ namespace sw
RValue<Int> SignMask(RValue<Float4> x)
{
assert(false && "UNIMPLEMENTED"); return RValue<Int>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Int>(V(nullptr));
}
RValue<Int4> CmpEQ(RValue<Float4> x, RValue<Float4> y)
......@@ -5562,27 +5562,27 @@ namespace sw
RValue<Float4> Round(RValue<Float4> x)
{
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(V(nullptr));
}
RValue<Float4> Trunc(RValue<Float4> x)
{
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(V(nullptr));
}
RValue<Float4> Frac(RValue<Float4> x)
{
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(V(nullptr));
}
RValue<Float4> Floor(RValue<Float4> x)
{
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(V(nullptr));
}
RValue<Float4> Ceil(RValue<Float4> x)
{
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(V(nullptr));
}
Type *Float4::getType()
......@@ -5592,7 +5592,7 @@ namespace sw
RValue<Pointer<Byte>> operator+(RValue<Pointer<Byte>> lhs, int offset)
{
assert(false && "UNIMPLEMENTED"); return RValue<Pointer<Byte>>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Pointer<Byte>>(V(nullptr));
}
RValue<Pointer<Byte>> operator+(RValue<Pointer<Byte>> lhs, RValue<Int> offset)
......@@ -5697,7 +5697,7 @@ namespace sw
RValue<Long> Ticks()
{
assert(false && "UNIMPLEMENTED"); return RValue<Long>(nullptr);
assert(false && "UNIMPLEMENTED"); return RValue<Long>(V(nullptr));
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment