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/7371
Reviewed-by: Alexis Hétu <sugoi@google.com>
Reviewed-by: Nicolas Capens <capn@google.com>
Tested-by: Nicolas Capens <capn@google.com>

diff --git a/src/Reactor/SubzeroReactor.cpp b/src/Reactor/SubzeroReactor.cpp
index a27b986..021005d 100644 (file)
--- a/src/Reactor/SubzeroReactor.cpp
+++ b/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));
        }
 }