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)
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)
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()
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)
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()
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)
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)
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()
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)
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()
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()
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)
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()
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
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
RValue<Int> RoundInt(RValue<Float> cast)
{
- assert(false && "UNIMPLEMENTED"); return RValue<Int>(nullptr);
+ assert(false && "UNIMPLEMENTED"); return RValue<Int>(V(nullptr));
}
Type *Int::getType()
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()
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
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
// RValue<UInt> RoundUInt(RValue<Float> cast)
// {
-// assert(false && "UNIMPLEMENTED"); return RValue<UInt>(nullptr);
+// assert(false && "UNIMPLEMENTED"); return RValue<UInt>(V(nullptr));
// }
Type *UInt::getType()
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)
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)
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()
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)
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)
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)
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)
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<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)
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()
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()
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)
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)
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<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()
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<Long> Ticks()
{
- assert(false && "UNIMPLEMENTED"); return RValue<Long>(nullptr);
+ assert(false && "UNIMPLEMENTED"); return RValue<Long>(V(nullptr));
}
}