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 ...@@ -1969,12 +1969,12 @@ namespace sw
RValue<Byte8> operator+(RValue<Byte8> lhs, RValue<Byte8> rhs) 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) 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) // RValue<Byte8> operator*(RValue<Byte8> lhs, RValue<Byte8> rhs)
...@@ -1994,17 +1994,17 @@ namespace sw ...@@ -1994,17 +1994,17 @@ namespace sw
RValue<Byte8> operator&(RValue<Byte8> lhs, RValue<Byte8> rhs) 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) 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) 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) // RValue<Byte8> operator<<(RValue<Byte8> lhs, unsigned char rhs)
...@@ -2084,42 +2084,42 @@ namespace sw ...@@ -2084,42 +2084,42 @@ namespace sw
RValue<Byte8> AddSat(RValue<Byte8> x, RValue<Byte8> y) 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) 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) 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) 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) 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) 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) // 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) 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() Type *Byte8::getType()
...@@ -2194,12 +2194,12 @@ namespace sw ...@@ -2194,12 +2194,12 @@ namespace sw
RValue<SByte8> operator+(RValue<SByte8> lhs, RValue<SByte8> rhs) 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) 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) // RValue<SByte8> operator*(RValue<SByte8> lhs, RValue<SByte8> rhs)
...@@ -2309,37 +2309,37 @@ namespace sw ...@@ -2309,37 +2309,37 @@ namespace sw
RValue<SByte8> AddSat(RValue<SByte8> x, RValue<SByte8> y) 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) 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) 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) 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) 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) 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) 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() Type *SByte8::getType()
...@@ -2536,17 +2536,17 @@ namespace sw ...@@ -2536,17 +2536,17 @@ namespace sw
RValue<Short4> operator+(RValue<Short4> lhs, RValue<Short4> rhs) 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) 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) 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) // RValue<Short4> operator/(RValue<Short4> lhs, RValue<Short4> rhs)
...@@ -2561,45 +2561,45 @@ namespace sw ...@@ -2561,45 +2561,45 @@ namespace sw
RValue<Short4> operator&(RValue<Short4> lhs, RValue<Short4> rhs) 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) 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) 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) RValue<Short4> operator<<(RValue<Short4> lhs, unsigned char rhs)
{ {
// return RValue<Short4>(Nucleus::createShl(lhs.value, rhs.value)); // 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) RValue<Short4> operator>>(RValue<Short4> lhs, unsigned char rhs)
{ {
// return RValue<Short4>(Nucleus::createAShr(lhs.value, rhs.value)); // 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) RValue<Short4> operator<<(RValue<Short4> lhs, RValue<Long1> rhs)
{ {
// return RValue<Short4>(Nucleus::createShl(lhs.value, rhs.value)); // 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) RValue<Short4> operator>>(RValue<Short4> lhs, RValue<Long1> rhs)
{ {
// return RValue<Short4>(Nucleus::createAShr(lhs.value, rhs.value)); // 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) RValue<Short4> operator+=(const Short4 &lhs, RValue<Short4> rhs)
...@@ -2669,87 +2669,87 @@ namespace sw ...@@ -2669,87 +2669,87 @@ namespace sw
RValue<Short4> operator-(RValue<Short4> val) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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() Type *Short4::getType()
...@@ -2880,37 +2880,37 @@ namespace sw ...@@ -2880,37 +2880,37 @@ namespace sw
RValue<UShort4> operator+(RValue<UShort4> lhs, RValue<UShort4> rhs) 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) 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) 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) 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) 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) 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) 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) RValue<UShort4> operator<<=(const UShort4 &lhs, unsigned char rhs)
...@@ -2935,42 +2935,42 @@ namespace sw ...@@ -2935,42 +2935,42 @@ namespace sw
RValue<UShort4> operator~(RValue<UShort4> val) 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) 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) 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) 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) 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) 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) 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) 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() Type *UShort4::getType()
...@@ -3017,27 +3017,27 @@ namespace sw ...@@ -3017,27 +3017,27 @@ namespace sw
RValue<Short8> operator<<(RValue<Short8> lhs, unsigned char rhs) 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) 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) 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) 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) 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() Type *Short8::getType()
...@@ -3102,12 +3102,12 @@ namespace sw ...@@ -3102,12 +3102,12 @@ namespace sw
RValue<UShort8> operator<<(RValue<UShort8> lhs, unsigned char rhs) 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) 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) RValue<UShort8> operator+(RValue<UShort8> lhs, RValue<UShort8> rhs)
...@@ -3132,18 +3132,18 @@ namespace sw ...@@ -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) 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) 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)) // 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) // 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() Type *UShort8::getType()
...@@ -3414,7 +3414,7 @@ namespace sw ...@@ -3414,7 +3414,7 @@ namespace sw
RValue<Int> operator++(const Int &val, int) // Post-increment 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 const Int &operator++(const Int &val) // Pre-increment
...@@ -3424,7 +3424,7 @@ namespace sw ...@@ -3424,7 +3424,7 @@ namespace sw
RValue<Int> operator--(const Int &val, int) // Post-decrement 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 const Int &operator--(const Int &val) // Pre-decrement
...@@ -3479,7 +3479,7 @@ namespace sw ...@@ -3479,7 +3479,7 @@ namespace sw
RValue<Int> RoundInt(RValue<Float> cast) RValue<Int> RoundInt(RValue<Float> cast)
{ {
assert(false && "UNIMPLEMENTED"); return RValue<Int>(nullptr); assert(false && "UNIMPLEMENTED"); return RValue<Int>(V(nullptr));
} }
Type *Int::getType() Type *Int::getType()
...@@ -3585,7 +3585,7 @@ namespace sw ...@@ -3585,7 +3585,7 @@ namespace sw
RValue<Long2> UnpackHigh(RValue<Long2> x, RValue<Long2> y) 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() Type *Long2::getType()
...@@ -3833,7 +3833,7 @@ namespace sw ...@@ -3833,7 +3833,7 @@ namespace sw
RValue<UInt> operator++(const UInt &val, int) // Post-increment 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 const UInt &operator++(const UInt &val) // Pre-increment
...@@ -3843,7 +3843,7 @@ namespace sw ...@@ -3843,7 +3843,7 @@ namespace sw
RValue<UInt> operator--(const UInt &val, int) // Post-decrement 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 const UInt &operator--(const UInt &val) // Pre-decrement
...@@ -3898,7 +3898,7 @@ namespace sw ...@@ -3898,7 +3898,7 @@ namespace sw
// RValue<UInt> RoundUInt(RValue<Float> cast) // RValue<UInt> RoundUInt(RValue<Float> cast)
// { // {
// assert(false && "UNIMPLEMENTED"); return RValue<UInt>(nullptr); // assert(false && "UNIMPLEMENTED"); return RValue<UInt>(V(nullptr));
// } // }
Type *UInt::getType() Type *UInt::getType()
...@@ -3994,12 +3994,12 @@ namespace sw ...@@ -3994,12 +3994,12 @@ namespace sw
RValue<Int2> operator+(RValue<Int2> lhs, RValue<Int2> rhs) 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) 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) // RValue<Int2> operator*(RValue<Int2> lhs, RValue<Int2> rhs)
...@@ -4019,37 +4019,37 @@ namespace sw ...@@ -4019,37 +4019,37 @@ namespace sw
RValue<Int2> operator&(RValue<Int2> lhs, RValue<Int2> rhs) 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) 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) 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) 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) 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) 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) 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) RValue<Int2> operator+=(const Int2 &lhs, RValue<Int2> rhs)
...@@ -4124,27 +4124,27 @@ namespace sw ...@@ -4124,27 +4124,27 @@ namespace sw
RValue<Int2> operator~(RValue<Int2> val) 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) 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) 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) 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) 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() Type *Int2::getType()
...@@ -4212,12 +4212,12 @@ namespace sw ...@@ -4212,12 +4212,12 @@ namespace sw
RValue<UInt2> operator+(RValue<UInt2> lhs, RValue<UInt2> rhs) 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) 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) // RValue<UInt2> operator*(RValue<UInt2> lhs, RValue<UInt2> rhs)
...@@ -4237,37 +4237,37 @@ namespace sw ...@@ -4237,37 +4237,37 @@ namespace sw
RValue<UInt2> operator&(RValue<UInt2> lhs, RValue<UInt2> rhs) 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) 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) 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) 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) 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) 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) 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) RValue<UInt2> operator+=(const UInt2 &lhs, RValue<UInt2> rhs)
...@@ -4554,12 +4554,12 @@ namespace sw ...@@ -4554,12 +4554,12 @@ namespace sw
RValue<Int4> operator<<(RValue<Int4> lhs, unsigned char rhs) 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) 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) RValue<Int4> operator<<(RValue<Int4> lhs, RValue<Int4> rhs)
...@@ -4669,22 +4669,22 @@ namespace sw ...@@ -4669,22 +4669,22 @@ namespace sw
RValue<Int4> Max(RValue<Int4> x, RValue<Int4> y) 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) 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) 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) 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) RValue<Int> Extract(RValue<Int4> x, int i)
...@@ -4699,7 +4699,7 @@ namespace sw ...@@ -4699,7 +4699,7 @@ namespace sw
RValue<Int> SignMask(RValue<Int4> x) 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) RValue<Int4> Swizzle(RValue<Int4> x, unsigned char select)
...@@ -4873,12 +4873,12 @@ namespace sw ...@@ -4873,12 +4873,12 @@ namespace sw
RValue<UInt4> operator<<(RValue<UInt4> lhs, unsigned char rhs) 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) 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) RValue<UInt4> operator<<(RValue<UInt4> lhs, RValue<UInt4> rhs)
...@@ -4988,17 +4988,17 @@ namespace sw ...@@ -4988,17 +4988,17 @@ namespace sw
RValue<UInt4> Max(RValue<UInt4> x, RValue<UInt4> y) 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) 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) 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() Type *UInt4::getType()
...@@ -5159,42 +5159,42 @@ namespace sw ...@@ -5159,42 +5159,42 @@ namespace sw
RValue<Float> Rcp_pp(RValue<Float> x, bool exactAtPow2) 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) 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) 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) 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) 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) 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) 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) RValue<Float> Ceil(RValue<Float> x)
{ {
assert(false && "UNIMPLEMENTED"); return RValue<Float>(nullptr); assert(false && "UNIMPLEMENTED"); return RValue<Float>(V(nullptr));
} }
Type *Float::getType() Type *Float::getType()
...@@ -5453,32 +5453,32 @@ namespace sw ...@@ -5453,32 +5453,32 @@ namespace sw
RValue<Float4> Abs(RValue<Float4> x) 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) 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) 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) 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) 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) 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) RValue<Float4> Insert(const Float4 &val, RValue<Float> element, int i)
...@@ -5503,17 +5503,17 @@ namespace sw ...@@ -5503,17 +5503,17 @@ namespace sw
RValue<Float4> ShuffleLowHigh(RValue<Float4> x, RValue<Float4> y, unsigned char imm) 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) 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) 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) RValue<Float4> Mask(Float4 &lhs, RValue<Float4> rhs, unsigned char select)
...@@ -5527,7 +5527,7 @@ namespace sw ...@@ -5527,7 +5527,7 @@ namespace sw
RValue<Int> SignMask(RValue<Float4> x) 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) RValue<Int4> CmpEQ(RValue<Float4> x, RValue<Float4> y)
...@@ -5562,27 +5562,27 @@ namespace sw ...@@ -5562,27 +5562,27 @@ namespace sw
RValue<Float4> Round(RValue<Float4> x) 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) 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) 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) 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) RValue<Float4> Ceil(RValue<Float4> x)
{ {
assert(false && "UNIMPLEMENTED"); return RValue<Float4>(nullptr); assert(false && "UNIMPLEMENTED"); return RValue<Float4>(V(nullptr));
} }
Type *Float4::getType() Type *Float4::getType()
...@@ -5592,7 +5592,7 @@ namespace sw ...@@ -5592,7 +5592,7 @@ namespace sw
RValue<Pointer<Byte>> operator+(RValue<Pointer<Byte>> lhs, int offset) 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) RValue<Pointer<Byte>> operator+(RValue<Pointer<Byte>> lhs, RValue<Int> offset)
...@@ -5697,7 +5697,7 @@ namespace sw ...@@ -5697,7 +5697,7 @@ namespace sw
RValue<Long> Ticks() 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