Skip to content

S
swiftshader
Commit 519cf22b by Nicolas Capens Committed by Nicolas Capens
Options

Rename Reactor static getType() methods to type()

This is just a refactoring which will allow adding a virtual getType() method in a subsequent change without overload naming conflicts. 'isVoid()' has been removed since it appears unused now. Bug: b/155302798 Change-Id: I16f5cbd947da9581e0f20837497f6b61cfeb7a21 Reviewed-on: https://swiftshader-review.googlesource.com/c/SwiftShader/+/45008 Presubmit-Ready: Nicolas Capens <nicolascapens@google.com> Reviewed-by: 's avatarAntonio Maiorano <amaiorano@google.com> Tested-by: 's avatarNicolas Capens <nicolascapens@google.com> Kokoro-Result: kokoro <noreply+kokoro@google.com>
parent 57eb48ae
Showing with 324 additions and 334 deletions
src/Reactor/Coroutine.hpp
......@@ -157,16 +157,16 @@ Coroutine<Return(Arguments...)>::Coroutine()
{
core.reset(new Nucleus());
std::vector<Type *> types = { CToReactorT<Arguments>::getType()... };
std::vector<Type *> types = { CToReactorT<Arguments>::type()... };
for(auto type : types)
{
if(type != Void::getType())
if(type != Void::type())
{
arguments.push_back(type);
}
}
Nucleus::createCoroutine(CToReactorT<Return>::getType(), arguments);
Nucleus::createCoroutine(CToReactorT<Return>::type(), arguments);
}
template<typename Return, typename... Arguments>
......
src/Reactor/LLVMReactor.cpp
......@@ -537,12 +537,12 @@ llvm::Type *T(Type *t)
// Use 128-bit vectors to implement logically shorter ones.
switch(asInternalType(t))
{
case Type_v2i32: return T(Int4::getType());
case Type_v4i16: return T(Short8::getType());
case Type_v2i16: return T(Short8::getType());
case Type_v8i8: return T(Byte16::getType());
case Type_v4i8: return T(Byte16::getType());
case Type_v2f32: return T(Float4::getType());
case Type_v2i32: return T(Int4::type());
case Type_v4i16: return T(Short8::type());
case Type_v2i16: return T(Short8::type());
case Type_v8i8: return T(Byte16::type());
case Type_v4i8: return T(Byte16::type());
case Type_v2f32: return T(Float4::type());
case Type_LLVM: return reinterpret_cast<llvm::Type *>(t);
default:
UNREACHABLE("asInternalType(t): %d", int(asInternalType(t)));
......@@ -808,7 +808,7 @@ void Nucleus::createRetVoid()
{
RR_DEBUG_INFO_UPDATE_LOC();
ASSERT_MSG(jit->function->getReturnType() == T(Void::getType()), "Return type mismatch");
ASSERT_MSG(jit->function->getReturnType() == T(Void::type()), "Return type mismatch");
// Code generated after this point is unreachable, so any variables
// being read can safely return an undefined value. We have to avoid
......@@ -989,17 +989,17 @@ Value *Nucleus::createLoad(Value *ptr, Type *type, bool isVolatile, unsigned int
case Type_v2f32:
return createBitCast(
createInsertElement(
V(llvm::UndefValue::get(llvm::VectorType::get(T(Long::getType()), 2))),
createLoad(createBitCast(ptr, Pointer<Long>::getType()), Long::getType(), isVolatile, alignment, atomic, memoryOrder),
V(llvm::UndefValue::get(llvm::VectorType::get(T(Long::type()), 2))),
createLoad(createBitCast(ptr, Pointer<Long>::type()), Long::type(), isVolatile, alignment, atomic, memoryOrder),
0),
type);
case Type_v2i16:
case Type_v4i8:
if(alignment != 0) // Not a local variable (all vectors are 128-bit).
{
Value *u = V(llvm::UndefValue::get(llvm::VectorType::get(T(Long::getType()), 2)));
Value *i = createLoad(createBitCast(ptr, Pointer<Int>::getType()), Int::getType(), isVolatile, alignment, atomic, memoryOrder);
i = createZExt(i, Long::getType());
Value *u = V(llvm::UndefValue::get(llvm::VectorType::get(T(Long::type()), 2)));
Value *i = createLoad(createBitCast(ptr, Pointer<Int>::type()), Int::type(), isVolatile, alignment, atomic, memoryOrder);
i = createZExt(i, Long::type());
Value *v = createInsertElement(u, i, 0);
return createBitCast(v, type);
}
......@@ -1073,18 +1073,18 @@ Value *Nucleus::createStore(Value *value, Value *ptr, Type *type, bool isVolatil
case Type_v2f32:
createStore(
createExtractElement(
createBitCast(value, T(llvm::VectorType::get(T(Long::getType()), 2))), Long::getType(), 0),
createBitCast(ptr, Pointer<Long>::getType()),
Long::getType(), isVolatile, alignment, atomic, memoryOrder);
createBitCast(value, T(llvm::VectorType::get(T(Long::type()), 2))), Long::type(), 0),
createBitCast(ptr, Pointer<Long>::type()),
Long::type(), isVolatile, alignment, atomic, memoryOrder);
return value;
case Type_v2i16:
case Type_v4i8:
if(alignment != 0) // Not a local variable (all vectors are 128-bit).
{
createStore(
createExtractElement(createBitCast(value, Int4::getType()), Int::getType(), 0),
createBitCast(ptr, Pointer<Int>::getType()),
Int::getType(), isVolatile, alignment, atomic, memoryOrder);
createExtractElement(createBitCast(value, Int4::type()), Int::type(), 0),
createBitCast(ptr, Pointer<Int>::type()),
Int::type(), isVolatile, alignment, atomic, memoryOrder);
return value;
}
// Fallthrough to non-emulated case.
......@@ -1231,12 +1231,12 @@ void Nucleus::createMaskedStore(Value *ptr, Value *val, Value *mask, unsigned in
RValue<Float4> Gather(RValue<Pointer<Float>> base, RValue<Int4> offsets, RValue<Int4> mask, unsigned int alignment, bool zeroMaskedLanes /* = false */)
{
return As<Float4>(V(createGather(V(base.value), T(Float::getType()), V(offsets.value), V(mask.value), alignment, zeroMaskedLanes)));
return As<Float4>(V(createGather(V(base.value), T(Float::type()), V(offsets.value), V(mask.value), alignment, zeroMaskedLanes)));
}
RValue<Int4> Gather(RValue<Pointer<Int>> base, RValue<Int4> offsets, RValue<Int4> mask, unsigned int alignment, bool zeroMaskedLanes /* = false */)
{
return As<Int4>(V(createGather(V(base.value), T(Float::getType()), V(offsets.value), V(mask.value), alignment, zeroMaskedLanes)));
return As<Int4>(V(createGather(V(base.value), T(Float::type()), V(offsets.value), V(mask.value), alignment, zeroMaskedLanes)));
}
void Scatter(RValue<Pointer<Float>> base, RValue<Float4> val, RValue<Int4> offsets, RValue<Int4> mask, unsigned int alignment)
......@@ -1274,7 +1274,7 @@ Value *Nucleus::createGEP(Value *ptr, Type *type, Value *index, bool unsignedInd
// x86 supports automatic zero-extending of 32-bit registers to
// 64-bit. Thus when indexing into an array using a uint32 is
// actually faster than an int32.
index = unsignedIndex ? createZExt(index, Long::getType()) : createSExt(index, Long::getType());
index = unsignedIndex ? createZExt(index, Long::type()) : createSExt(index, Long::type());
}
// For non-emulated types we can rely on LLVM's GEP to calculate the
......@@ -1291,7 +1291,7 @@ Value *Nucleus::createGEP(Value *ptr, Type *type, Value *index, bool unsignedInd
// Cast to a byte pointer, apply the byte offset, and cast back to the
// original pointer type.
return createBitCast(
V(jit->builder->CreateGEP(V(createBitCast(ptr, T(llvm::PointerType::get(T(Byte::getType()), 0)))), V(index))),
V(jit->builder->CreateGEP(V(createBitCast(ptr, T(llvm::PointerType::get(T(Byte::type()), 0)))), V(index))),
T(llvm::PointerType::get(T(type), 0)));
}
......@@ -1736,7 +1736,7 @@ Value *Nucleus::createConstantShort(unsigned short i)
Value *Nucleus::createConstantFloat(float x)
{
RR_DEBUG_INFO_UPDATE_LOC();
return V(llvm::ConstantFP::get(T(Float::getType()), x));
return V(llvm::ConstantFP::get(T(Float::type()), x));
}
Value *Nucleus::createNullPointer(Type *Ty)
......@@ -1786,42 +1786,42 @@ Value *Nucleus::createConstantString(const char *v)
return V(ptr);
}
Type *Void::getType()
Type *Void::type()
{
return T(llvm::Type::getVoidTy(jit->context));
}
Type *Bool::getType()
Type *Bool::type()
{
return T(llvm::Type::getInt1Ty(jit->context));
}
Type *Byte::getType()
Type *Byte::type()
{
return T(llvm::Type::getInt8Ty(jit->context));
}
Type *SByte::getType()
Type *SByte::type()
{
return T(llvm::Type::getInt8Ty(jit->context));
}
Type *Short::getType()
Type *Short::type()
{
return T(llvm::Type::getInt16Ty(jit->context));
}
Type *UShort::getType()
Type *UShort::type()
{
return T(llvm::Type::getInt16Ty(jit->context));
}
Type *Byte4::getType()
Type *Byte4::type()
{
return T(Type_v4i8);
}
Type *SByte4::getType()
Type *SByte4::type()
{
return T(Type_v4i8);
}
......@@ -1852,7 +1852,7 @@ RValue<Int> SignMask(RValue<Byte8> x)
#if defined(__i386__) || defined(__x86_64__)
return x86::pmovmskb(x);
#else
return As<Int>(V(lowerSignMask(V(x.value), T(Int::getType()))));
return As<Int>(V(lowerSignMask(V(x.value), T(Int::type()))));
#endif
}
......@@ -1861,7 +1861,7 @@ RValue<Int> SignMask(RValue<Byte8> x)
//#if defined(__i386__) || defined(__x86_64__)
// return x86::pcmpgtb(x, y); // FIXME: Signedness
//#else
// return As<Byte8>(V(lowerPCMP(llvm::ICmpInst::ICMP_SGT, V(x.value), V(y.value), T(Byte8::getType()))));
// return As<Byte8>(V(lowerPCMP(llvm::ICmpInst::ICMP_SGT, V(x.value), V(y.value), T(Byte8::type()))));
//#endif
// }
......@@ -1871,11 +1871,11 @@ RValue<Byte8> CmpEQ(RValue<Byte8> x, RValue<Byte8> y)
#if defined(__i386__) || defined(__x86_64__)
return x86::pcmpeqb(x, y);
#else
return As<Byte8>(V(lowerPCMP(llvm::ICmpInst::ICMP_EQ, V(x.value), V(y.value), T(Byte8::getType()))));
return As<Byte8>(V(lowerPCMP(llvm::ICmpInst::ICMP_EQ, V(x.value), V(y.value), T(Byte8::type()))));
#endif
}
Type *Byte8::getType()
Type *Byte8::type()
{
return T(Type_v8i8);
}
......@@ -1906,7 +1906,7 @@ RValue<Int> SignMask(RValue<SByte8> x)
#if defined(__i386__) || defined(__x86_64__)
return x86::pmovmskb(As<Byte8>(x));
#else
return As<Int>(V(lowerSignMask(V(x.value), T(Int::getType()))));
return As<Int>(V(lowerSignMask(V(x.value), T(Int::type()))));
#endif
}
......@@ -1916,7 +1916,7 @@ RValue<Byte8> CmpGT(RValue<SByte8> x, RValue<SByte8> y)
#if defined(__i386__) || defined(__x86_64__)
return x86::pcmpgtb(x, y);
#else
return As<Byte8>(V(lowerPCMP(llvm::ICmpInst::ICMP_SGT, V(x.value), V(y.value), T(Byte8::getType()))));
return As<Byte8>(V(lowerPCMP(llvm::ICmpInst::ICMP_SGT, V(x.value), V(y.value), T(Byte8::type()))));
#endif
}
......@@ -1926,31 +1926,31 @@ RValue<Byte8> CmpEQ(RValue<SByte8> x, RValue<SByte8> y)
#if defined(__i386__) || defined(__x86_64__)
return x86::pcmpeqb(As<Byte8>(x), As<Byte8>(y));
#else
return As<Byte8>(V(lowerPCMP(llvm::ICmpInst::ICMP_EQ, V(x.value), V(y.value), T(Byte8::getType()))));
return As<Byte8>(V(lowerPCMP(llvm::ICmpInst::ICMP_EQ, V(x.value), V(y.value), T(Byte8::type()))));
#endif
}
Type *SByte8::getType()
Type *SByte8::type()
{
return T(Type_v8i8);
}
Type *Byte16::getType()
Type *Byte16::type()
{
return T(llvm::VectorType::get(T(Byte::getType()), 16));
return T(llvm::VectorType::get(T(Byte::type()), 16));
}
Type *SByte16::getType()
Type *SByte16::type()
{
return T(llvm::VectorType::get(T(SByte::getType()), 16));
return T(llvm::VectorType::get(T(SByte::type()), 16));
}
Type *Short2::getType()
Type *Short2::type()
{
return T(Type_v2i16);
}
Type *UShort2::getType()
Type *UShort2::type()
{
return T(Type_v2i16);
}
......@@ -1959,7 +1959,7 @@ Short4::Short4(RValue<Int4> cast)
{
RR_DEBUG_INFO_UPDATE_LOC();
int select[8] = { 0, 2, 4, 6, 0, 2, 4, 6 };
Value *short8 = Nucleus::createBitCast(cast.value, Short8::getType());
Value *short8 = Nucleus::createBitCast(cast.value, Short8::type());
Value *packed = Nucleus::createShuffleVector(short8, short8, select);
Value *short4 = As<Short4>(Int2(As<Int4>(packed))).value;
......@@ -2095,7 +2095,7 @@ RValue<Short4> CmpGT(RValue<Short4> x, RValue<Short4> y)
#if defined(__i386__) || defined(__x86_64__)
return x86::pcmpgtw(x, y);
#else
return As<Short4>(V(lowerPCMP(llvm::ICmpInst::ICMP_SGT, V(x.value), V(y.value), T(Short4::getType()))));
return As<Short4>(V(lowerPCMP(llvm::ICmpInst::ICMP_SGT, V(x.value), V(y.value), T(Short4::type()))));
#endif
}
......@@ -2105,11 +2105,11 @@ RValue<Short4> CmpEQ(RValue<Short4> x, RValue<Short4> y)
#if defined(__i386__) || defined(__x86_64__)
return x86::pcmpeqw(x, y);
#else
return As<Short4>(V(lowerPCMP(llvm::ICmpInst::ICMP_EQ, V(x.value), V(y.value), T(Short4::getType()))));
return As<Short4>(V(lowerPCMP(llvm::ICmpInst::ICMP_EQ, V(x.value), V(y.value), T(Short4::type()))));
#endif
}
Type *Short4::getType()
Type *Short4::type()
{
return T(Type_v4i16);
}
......@@ -2213,7 +2213,7 @@ RValue<UShort4> Average(RValue<UShort4> x, RValue<UShort4> y)
#endif
}
Type *UShort4::getType()
Type *UShort4::type()
{
return T(Type_v4i16);
}
......@@ -2258,9 +2258,9 @@ RValue<Short8> MulHigh(RValue<Short8> x, RValue<Short8> y)
#endif
}
Type *Short8::getType()
Type *Short8::type()
{
return T(llvm::VectorType::get(T(Short::getType()), 8));
return T(llvm::VectorType::get(T(Short::type()), 8));
}
RValue<UShort8> operator<<(RValue<UShort8> lhs, unsigned char rhs)
......@@ -2293,9 +2293,9 @@ RValue<UShort8> MulHigh(RValue<UShort8> x, RValue<UShort8> y)
#endif
}
Type *UShort8::getType()
Type *UShort8::type()
{
return T(llvm::VectorType::get(T(UShort::getType()), 8));
return T(llvm::VectorType::get(T(UShort::type()), 8));
}
RValue<Int> operator++(Int &val, int) // Post-increment
......@@ -2344,16 +2344,16 @@ RValue<Int> RoundInt(RValue<Float> cast)
#if defined(__i386__) || defined(__x86_64__)
return x86::cvtss2si(cast);
#else
return RValue<Int>(V(lowerRoundInt(V(cast.value), T(Int::getType()))));
return RValue<Int>(V(lowerRoundInt(V(cast.value), T(Int::type()))));
#endif
}
Type *Int::getType()
Type *Int::type()
{
return T(llvm::Type::getInt32Ty(jit->context));
}
Type *Long::getType()
Type *Long::type()
{
return T(llvm::Type::getInt64Ty(jit->context));
}
......@@ -2361,7 +2361,7 @@ Type *Long::getType()
UInt::UInt(RValue<Float> cast)
{
RR_DEBUG_INFO_UPDATE_LOC();
Value *integer = Nucleus::createFPToUI(cast.value, UInt::getType());
Value *integer = Nucleus::createFPToUI(cast.value, UInt::type());
storeValue(integer);
}
......@@ -2414,15 +2414,15 @@ const UInt &operator--(UInt &val) // Pre-decrement
//#endif
// }
Type *UInt::getType()
Type *UInt::type()
{
return T(llvm::Type::getInt32Ty(jit->context));
}
// Int2::Int2(RValue<Int> cast)
// {
// Value *extend = Nucleus::createZExt(cast.value, Long::getType());
// Value *vector = Nucleus::createBitCast(extend, Int2::getType());
// Value *extend = Nucleus::createZExt(cast.value, Long::type());
// Value *vector = Nucleus::createBitCast(extend, Int2::type());
//
// int shuffle[2] = {0, 0};
// Value *replicate = Nucleus::createShuffleVector(vector, vector, shuffle);
......@@ -2454,7 +2454,7 @@ RValue<Int2> operator>>(RValue<Int2> lhs, unsigned char rhs)
#endif
}
Type *Int2::getType()
Type *Int2::type()
{
return T(Type_v2i32);
}
......@@ -2483,7 +2483,7 @@ RValue<UInt2> operator>>(RValue<UInt2> lhs, unsigned char rhs)
#endif
}
Type *UInt2::getType()
Type *UInt2::type()
{
return T(Type_v2i32);
}
......@@ -2501,12 +2501,12 @@ Int4::Int4(RValue<Byte4> cast)
#endif
{
int swizzle[16] = { 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23 };
Value *a = Nucleus::createBitCast(cast.value, Byte16::getType());
Value *b = Nucleus::createShuffleVector(a, Nucleus::createNullValue(Byte16::getType()), swizzle);
Value *a = Nucleus::createBitCast(cast.value, Byte16::type());
Value *b = Nucleus::createShuffleVector(a, Nucleus::createNullValue(Byte16::type()), swizzle);
int swizzle2[8] = { 0, 8, 1, 9, 2, 10, 3, 11 };
Value *c = Nucleus::createBitCast(b, Short8::getType());
Value *d = Nucleus::createShuffleVector(c, Nucleus::createNullValue(Short8::getType()), swizzle2);
Value *c = Nucleus::createBitCast(b, Short8::type());
Value *d = Nucleus::createShuffleVector(c, Nucleus::createNullValue(Short8::type()), swizzle2);
*this = As<Int4>(d);
}
......@@ -2525,11 +2525,11 @@ Int4::Int4(RValue<SByte4> cast)
#endif
{
int swizzle[16] = { 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7 };
Value *a = Nucleus::createBitCast(cast.value, Byte16::getType());
Value *a = Nucleus::createBitCast(cast.value, Byte16::type());
Value *b = Nucleus::createShuffleVector(a, a, swizzle);
int swizzle2[8] = { 0, 0, 1, 1, 2, 2, 3, 3 };
Value *c = Nucleus::createBitCast(b, Short8::getType());
Value *c = Nucleus::createBitCast(b, Short8::type());
Value *d = Nucleus::createShuffleVector(c, c, swizzle2);
*this = As<Int4>(d) >> 24;
......@@ -2608,37 +2608,37 @@ RValue<Int4> operator>>(RValue<Int4> lhs, unsigned char rhs)
RValue<Int4> CmpEQ(RValue<Int4> x, RValue<Int4> y)
{
RR_DEBUG_INFO_UPDATE_LOC();
return RValue<Int4>(Nucleus::createSExt(Nucleus::createICmpEQ(x.value, y.value), Int4::getType()));
return RValue<Int4>(Nucleus::createSExt(Nucleus::createICmpEQ(x.value, y.value), Int4::type()));
}
RValue<Int4> CmpLT(RValue<Int4> x, RValue<Int4> y)
{
RR_DEBUG_INFO_UPDATE_LOC();
return RValue<Int4>(Nucleus::createSExt(Nucleus::createICmpSLT(x.value, y.value), Int4::getType()));
return RValue<Int4>(Nucleus::createSExt(Nucleus::createICmpSLT(x.value, y.value), Int4::type()));
}
RValue<Int4> CmpLE(RValue<Int4> x, RValue<Int4> y)
{
RR_DEBUG_INFO_UPDATE_LOC();
return RValue<Int4>(Nucleus::createSExt(Nucleus::createICmpSLE(x.value, y.value), Int4::getType()));
return RValue<Int4>(Nucleus::createSExt(Nucleus::createICmpSLE(x.value, y.value), Int4::type()));
}
RValue<Int4> CmpNEQ(RValue<Int4> x, RValue<Int4> y)
{
RR_DEBUG_INFO_UPDATE_LOC();
return RValue<Int4>(Nucleus::createSExt(Nucleus::createICmpNE(x.value, y.value), Int4::getType()));
return RValue<Int4>(Nucleus::createSExt(Nucleus::createICmpNE(x.value, y.value), Int4::type()));
}
RValue<Int4> CmpNLT(RValue<Int4> x, RValue<Int4> y)
{
RR_DEBUG_INFO_UPDATE_LOC();
return RValue<Int4>(Nucleus::createSExt(Nucleus::createICmpSGE(x.value, y.value), Int4::getType()));
return RValue<Int4>(Nucleus::createSExt(Nucleus::createICmpSGE(x.value, y.value), Int4::type()));
}
RValue<Int4> CmpNLE(RValue<Int4> x, RValue<Int4> y)
{
RR_DEBUG_INFO_UPDATE_LOC();
return RValue<Int4>(Nucleus::createSExt(Nucleus::createICmpSGT(x.value, y.value), Int4::getType()));
return RValue<Int4>(Nucleus::createSExt(Nucleus::createICmpSGT(x.value, y.value), Int4::type()));
}
RValue<Int4> Max(RValue<Int4> x, RValue<Int4> y)
......@@ -2679,7 +2679,7 @@ RValue<Int4> RoundInt(RValue<Float4> cast)
#if defined(__i386__) || defined(__x86_64__)
return x86::cvtps2dq(cast);
#else
return As<Int4>(V(lowerRoundInt(V(cast.value), T(Int4::getType()))));
return As<Int4>(V(lowerRoundInt(V(cast.value), T(Int4::type()))));
#endif
}
......@@ -2723,20 +2723,20 @@ RValue<Int> SignMask(RValue<Int4> x)
#if defined(__i386__) || defined(__x86_64__)
return x86::movmskps(As<Float4>(x));
#else
return As<Int>(V(lowerSignMask(V(x.value), T(Int::getType()))));
return As<Int>(V(lowerSignMask(V(x.value), T(Int::type()))));
#endif
}
Type *Int4::getType()
Type *Int4::type()
{
return T(llvm::VectorType::get(T(Int::getType()), 4));
return T(llvm::VectorType::get(T(Int::type()), 4));
}
UInt4::UInt4(RValue<Float4> cast)
: XYZW(this)
{
RR_DEBUG_INFO_UPDATE_LOC();
Value *xyzw = Nucleus::createFPToUI(cast.value, UInt4::getType());
Value *xyzw = Nucleus::createFPToUI(cast.value, UInt4::type());
storeValue(xyzw);
}
......@@ -2776,37 +2776,37 @@ RValue<UInt4> operator>>(RValue<UInt4> lhs, unsigned char rhs)
RValue<UInt4> CmpEQ(RValue<UInt4> x, RValue<UInt4> y)
{
RR_DEBUG_INFO_UPDATE_LOC();
return RValue<UInt4>(Nucleus::createSExt(Nucleus::createICmpEQ(x.value, y.value), Int4::getType()));
return RValue<UInt4>(Nucleus::createSExt(Nucleus::createICmpEQ(x.value, y.value), Int4::type()));
}
RValue<UInt4> CmpLT(RValue<UInt4> x, RValue<UInt4> y)
{
RR_DEBUG_INFO_UPDATE_LOC();
return RValue<UInt4>(Nucleus::createSExt(Nucleus::createICmpULT(x.value, y.value), Int4::getType()));
return RValue<UInt4>(Nucleus::createSExt(Nucleus::createICmpULT(x.value, y.value), Int4::type()));
}
RValue<UInt4> CmpLE(RValue<UInt4> x, RValue<UInt4> y)
{
RR_DEBUG_INFO_UPDATE_LOC();
return RValue<UInt4>(Nucleus::createSExt(Nucleus::createICmpULE(x.value, y.value), Int4::getType()));
return RValue<UInt4>(Nucleus::createSExt(Nucleus::createICmpULE(x.value, y.value), Int4::type()));
}
RValue<UInt4> CmpNEQ(RValue<UInt4> x, RValue<UInt4> y)
{
RR_DEBUG_INFO_UPDATE_LOC();
return RValue<UInt4>(Nucleus::createSExt(Nucleus::createICmpNE(x.value, y.value), Int4::getType()));
return RValue<UInt4>(Nucleus::createSExt(Nucleus::createICmpNE(x.value, y.value), Int4::type()));
}
RValue<UInt4> CmpNLT(RValue<UInt4> x, RValue<UInt4> y)
{
RR_DEBUG_INFO_UPDATE_LOC();
return RValue<UInt4>(Nucleus::createSExt(Nucleus::createICmpUGE(x.value, y.value), Int4::getType()));
return RValue<UInt4>(Nucleus::createSExt(Nucleus::createICmpUGE(x.value, y.value), Int4::type()));
}
RValue<UInt4> CmpNLE(RValue<UInt4> x, RValue<UInt4> y)
{
RR_DEBUG_INFO_UPDATE_LOC();
return RValue<UInt4>(Nucleus::createSExt(Nucleus::createICmpUGT(x.value, y.value), Int4::getType()));
return RValue<UInt4>(Nucleus::createSExt(Nucleus::createICmpUGT(x.value, y.value), Int4::type()));
}
RValue<UInt4> Max(RValue<UInt4> x, RValue<UInt4> y)
......@@ -2841,12 +2841,12 @@ RValue<UInt4> Min(RValue<UInt4> x, RValue<UInt4> y)
}
}
Type *UInt4::getType()
Type *UInt4::type()
{
return T(llvm::VectorType::get(T(UInt::getType()), 4));
return T(llvm::VectorType::get(T(UInt::type()), 4));
}
Type *Half::getType()
Type *Half::type()
{
return T(llvm::Type::getInt16Ty(jit->context));
}
......@@ -2972,25 +2972,25 @@ RValue<Float> Ceil(RValue<Float> x)
}
}
Type *Float::getType()
Type *Float::type()
{
return T(llvm::Type::getFloatTy(jit->context));
}
Type *Float2::getType()
Type *Float2::type()
{
return T(Type_v2f32);
}
RValue<Float> Exp2(RValue<Float> v)
{
auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::exp2, { T(Float::getType()) });
auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::exp2, { T(Float::type()) });
return RValue<Float>(V(jit->builder->CreateCall(func, V(v.value))));
}
RValue<Float> Log2(RValue<Float> v)
{
auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::log2, { T(Float::getType()) });
auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::log2, { T(Float::type()) });
return RValue<Float>(V(jit->builder->CreateCall(func, V(v.value))));
}
......@@ -3069,7 +3069,7 @@ RValue<Int> SignMask(RValue<Float4> x)
#if defined(__i386__) || defined(__x86_64__)
return x86::movmskps(x);
#else
return As<Int>(V(lowerFPSignMask(V(x.value), T(Int::getType()))));
return As<Int>(V(lowerFPSignMask(V(x.value), T(Int::type()))));
#endif
}
......@@ -3077,78 +3077,78 @@ RValue<Int4> CmpEQ(RValue<Float4> x, RValue<Float4> y)
{
RR_DEBUG_INFO_UPDATE_LOC();
// return As<Int4>(x86::cmpeqps(x, y));
return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpOEQ(x.value, y.value), Int4::getType()));
return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpOEQ(x.value, y.value), Int4::type()));
}
RValue<Int4> CmpLT(RValue<Float4> x, RValue<Float4> y)
{
RR_DEBUG_INFO_UPDATE_LOC();
// return As<Int4>(x86::cmpltps(x, y));
return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpOLT(x.value, y.value), Int4::getType()));
return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpOLT(x.value, y.value), Int4::type()));
}
RValue<Int4> CmpLE(RValue<Float4> x, RValue<Float4> y)
{
RR_DEBUG_INFO_UPDATE_LOC();
// return As<Int4>(x86::cmpleps(x, y));
return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpOLE(x.value, y.value), Int4::getType()));
return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpOLE(x.value, y.value), Int4::type()));
}
RValue<Int4> CmpNEQ(RValue<Float4> x, RValue<Float4> y)
{
RR_DEBUG_INFO_UPDATE_LOC();
// return As<Int4>(x86::cmpneqps(x, y));
return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpONE(x.value, y.value), Int4::getType()));
return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpONE(x.value, y.value), Int4::type()));
}
RValue<Int4> CmpNLT(RValue<Float4> x, RValue<Float4> y)
{
RR_DEBUG_INFO_UPDATE_LOC();
// return As<Int4>(x86::cmpnltps(x, y));
return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpOGE(x.value, y.value), Int4::getType()));
return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpOGE(x.value, y.value), Int4::type()));
}
RValue<Int4> CmpNLE(RValue<Float4> x, RValue<Float4> y)
{
RR_DEBUG_INFO_UPDATE_LOC();
// return As<Int4>(x86::cmpnleps(x, y));
return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpOGT(x.value, y.value), Int4::getType()));
return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpOGT(x.value, y.value), Int4::type()));
}
RValue<Int4> CmpUEQ(RValue<Float4> x, RValue<Float4> y)
{
RR_DEBUG_INFO_UPDATE_LOC();
return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpUEQ(x.value, y.value), Int4::getType()));
return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpUEQ(x.value, y.value), Int4::type()));
}
RValue<Int4> CmpULT(RValue<Float4> x, RValue<Float4> y)
{
RR_DEBUG_INFO_UPDATE_LOC();
return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpULT(x.value, y.value), Int4::getType()));
return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpULT(x.value, y.value), Int4::type()));
}
RValue<Int4> CmpULE(RValue<Float4> x, RValue<Float4> y)
{
RR_DEBUG_INFO_UPDATE_LOC();
return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpULE(x.value, y.value), Int4::getType()));
return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpULE(x.value, y.value), Int4::type()));
}
RValue<Int4> CmpUNEQ(RValue<Float4> x, RValue<Float4> y)
{
RR_DEBUG_INFO_UPDATE_LOC();
return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpUNE(x.value, y.value), Int4::getType()));
return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpUNE(x.value, y.value), Int4::type()));
}
RValue<Int4> CmpUNLT(RValue<Float4> x, RValue<Float4> y)
{
RR_DEBUG_INFO_UPDATE_LOC();
return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpUGE(x.value, y.value), Int4::getType()));
return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpUGE(x.value, y.value), Int4::type()));
}
RValue<Int4> CmpUNLE(RValue<Float4> x, RValue<Float4> y)
{
RR_DEBUG_INFO_UPDATE_LOC();
return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpUGT(x.value, y.value), Int4::getType()));
return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpUGT(x.value, y.value), Int4::type()));
}
RValue<Float4> Round(RValue<Float4> x)
......@@ -3264,12 +3264,12 @@ RValue<Float4> Tan(RValue<Float4> v)
static RValue<Float4> TransformFloat4PerElement(RValue<Float4> v, const char *name)
{
auto funcTy = ::llvm::FunctionType::get(T(Float::getType()), ::llvm::ArrayRef<llvm::Type *>(T(Float::getType())), false);
auto funcTy = ::llvm::FunctionType::get(T(Float::type()), ::llvm::ArrayRef<llvm::Type *>(T(Float::type())), false);
auto func = jit->module->getOrInsertFunction(name, funcTy);
llvm::Value *out = ::llvm::UndefValue::get(T(Float4::getType()));
llvm::Value *out = ::llvm::UndefValue::get(T(Float4::type()));
for(uint64_t i = 0; i < 4; i++)
{
auto el = jit->builder->CreateCall(func, V(Nucleus::createExtractElement(v.value, Float::getType(), i)));
auto el = jit->builder->CreateCall(func, V(Nucleus::createExtractElement(v.value, Float::type(), i)));
out = V(Nucleus::createInsertElement(V(out), V(el), i));
}
return RValue<Float4>(V(out));
......@@ -3333,16 +3333,16 @@ RValue<Float4> Atan2(RValue<Float4> x, RValue<Float4> y)
{
RR_DEBUG_INFO_UPDATE_LOC();
::llvm::SmallVector<::llvm::Type *, 2> paramTys;
paramTys.push_back(T(Float::getType()));
paramTys.push_back(T(Float::getType()));
auto funcTy = ::llvm::FunctionType::get(T(Float::getType()), paramTys, false);
paramTys.push_back(T(Float::type()));
paramTys.push_back(T(Float::type()));
auto funcTy = ::llvm::FunctionType::get(T(Float::type()), paramTys, false);
auto func = jit->module->getOrInsertFunction("atan2f", funcTy);
llvm::Value *out = ::llvm::UndefValue::get(T(Float4::getType()));
llvm::Value *out = ::llvm::UndefValue::get(T(Float4::type()));
for(uint64_t i = 0; i < 4; i++)
{
auto el = jit->builder->CreateCall2(func, ARGS(
V(Nucleus::createExtractElement(x.value, Float::getType(), i)),
V(Nucleus::createExtractElement(y.value, Float::getType(), i))));
V(Nucleus::createExtractElement(x.value, Float::type(), i)),
V(Nucleus::createExtractElement(y.value, Float::type(), i))));
out = V(Nucleus::createInsertElement(V(out), V(el), i));
}
return RValue<Float4>(V(out));
......@@ -3351,42 +3351,42 @@ RValue<Float4> Atan2(RValue<Float4> x, RValue<Float4> y)
RValue<Float4> Pow(RValue<Float4> x, RValue<Float4> y)
{
RR_DEBUG_INFO_UPDATE_LOC();
auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::pow, { T(Float4::getType()) });
auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::pow, { T(Float4::type()) });
return RValue<Float4>(V(jit->builder->CreateCall2(func, ARGS(V(x.value), V(y.value)))));
}
RValue<Float4> Exp(RValue<Float4> v)
{
RR_DEBUG_INFO_UPDATE_LOC();
auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::exp, { T(Float4::getType()) });
auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::exp, { T(Float4::type()) });
return RValue<Float4>(V(jit->builder->CreateCall(func, V(v.value))));
}
RValue<Float4> Log(RValue<Float4> v)
{
RR_DEBUG_INFO_UPDATE_LOC();
auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::log, { T(Float4::getType()) });
auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::log, { T(Float4::type()) });
return RValue<Float4>(V(jit->builder->CreateCall(func, V(v.value))));
}
RValue<Float4> Exp2(RValue<Float4> v)
{
RR_DEBUG_INFO_UPDATE_LOC();
auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::exp2, { T(Float4::getType()) });
auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::exp2, { T(Float4::type()) });
return RValue<Float4>(V(jit->builder->CreateCall(func, V(v.value))));
}
RValue<Float4> Log2(RValue<Float4> v)
{
RR_DEBUG_INFO_UPDATE_LOC();
auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::log2, { T(Float4::getType()) });
auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::log2, { T(Float4::type()) });
return RValue<Float4>(V(jit->builder->CreateCall(func, V(v.value))));
}
RValue<UInt> Ctlz(RValue<UInt> v, bool isZeroUndef)
{
RR_DEBUG_INFO_UPDATE_LOC();
auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::ctlz, { T(UInt::getType()) });
auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::ctlz, { T(UInt::type()) });
return RValue<UInt>(V(jit->builder->CreateCall2(func, ARGS(
V(v.value),
isZeroUndef ? ::llvm::ConstantInt::getTrue(jit->context) : ::llvm::ConstantInt::getFalse(jit->context)))));
......@@ -3395,7 +3395,7 @@ RValue<UInt> Ctlz(RValue<UInt> v, bool isZeroUndef)
RValue<UInt4> Ctlz(RValue<UInt4> v, bool isZeroUndef)
{
RR_DEBUG_INFO_UPDATE_LOC();
auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::ctlz, { T(UInt4::getType()) });
auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::ctlz, { T(UInt4::type()) });
return RValue<UInt4>(V(jit->builder->CreateCall2(func, ARGS(
V(v.value),
isZeroUndef ? ::llvm::ConstantInt::getTrue(jit->context) : ::llvm::ConstantInt::getFalse(jit->context)))));
......@@ -3404,7 +3404,7 @@ RValue<UInt4> Ctlz(RValue<UInt4> v, bool isZeroUndef)
RValue<UInt> Cttz(RValue<UInt> v, bool isZeroUndef)
{
RR_DEBUG_INFO_UPDATE_LOC();
auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::cttz, { T(UInt::getType()) });
auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::cttz, { T(UInt::type()) });
return RValue<UInt>(V(jit->builder->CreateCall2(func, ARGS(
V(v.value),
isZeroUndef ? ::llvm::ConstantInt::getTrue(jit->context) : ::llvm::ConstantInt::getFalse(jit->context)))));
......@@ -3413,7 +3413,7 @@ RValue<UInt> Cttz(RValue<UInt> v, bool isZeroUndef)
RValue<UInt4> Cttz(RValue<UInt4> v, bool isZeroUndef)
{
RR_DEBUG_INFO_UPDATE_LOC();
auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::cttz, { T(UInt4::getType()) });
auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::cttz, { T(UInt4::type()) });
return RValue<UInt4>(V(jit->builder->CreateCall2(func, ARGS(
V(v.value),
isZeroUndef ? ::llvm::ConstantInt::getTrue(jit->context) : ::llvm::ConstantInt::getFalse(jit->context)))));
......@@ -3439,9 +3439,9 @@ RValue<UInt> MaxAtomic(RValue<Pointer<UInt>> x, RValue<UInt> y, std::memory_orde
return RValue<UInt>(Nucleus::createAtomicUMax(x.value, y.value, memoryOrder));
}
Type *Float4::getType()
Type *Float4::type()
{
return T(llvm::VectorType::get(T(Float::getType()), 4));
return T(llvm::VectorType::get(T(Float::type()), 4));
}
RValue<Long> Ticks()
......@@ -3458,7 +3458,7 @@ RValue<Pointer<Byte>> ConstantPointer(void const *ptr)
// Note: this should work for 32-bit pointers as well because 'inttoptr'
// is defined to truncate (and zero extend) if necessary.
auto ptrAsInt = ::llvm::ConstantInt::get(::llvm::Type::getInt64Ty(jit->context), reinterpret_cast<uintptr_t>(ptr));
return RValue<Pointer<Byte>>(V(jit->builder->CreateIntToPtr(ptrAsInt, T(Pointer<Byte>::getType()))));
return RValue<Pointer<Byte>>(V(jit->builder->CreateIntToPtr(ptrAsInt, T(Pointer<Byte>::type()))));
}
RValue<Pointer<Byte>> ConstantData(void const *data, size_t size)
......@@ -3520,9 +3520,9 @@ RValue<Float> rcpss(RValue<Float> val)
{
llvm::Function *rcpss = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::x86_sse_rcp_ss);
Value *vector = Nucleus::createInsertElement(V(llvm::UndefValue::get(T(Float4::getType()))), val.value, 0);
Value *vector = Nucleus::createInsertElement(V(llvm::UndefValue::get(T(Float4::type()))), val.value, 0);
return RValue<Float>(Nucleus::createExtractElement(V(jit->builder->CreateCall(rcpss, ARGS(V(vector)))), Float::getType(), 0));
return RValue<Float>(Nucleus::createExtractElement(V(jit->builder->CreateCall(rcpss, ARGS(V(vector)))), Float::type(), 0));
}
RValue<Float> sqrtss(RValue<Float> val)
......@@ -3535,9 +3535,9 @@ RValue<Float> rsqrtss(RValue<Float> val)
{
llvm::Function *rsqrtss = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::x86_sse_rsqrt_ss);
Value *vector = Nucleus::createInsertElement(V(llvm::UndefValue::get(T(Float4::getType()))), val.value, 0);
Value *vector = Nucleus::createInsertElement(V(llvm::UndefValue::get(T(Float4::type()))), val.value, 0);
return RValue<Float>(Nucleus::createExtractElement(V(jit->builder->CreateCall(rsqrtss, ARGS(V(vector)))), Float::getType(), 0));
return RValue<Float>(Nucleus::createExtractElement(V(jit->builder->CreateCall(rsqrtss, ARGS(V(vector)))), Float::type(), 0));
}
RValue<Float4> rcpps(RValue<Float4> val)
......@@ -3579,10 +3579,10 @@ RValue<Float> roundss(RValue<Float> val, unsigned char imm)
{
llvm::Function *roundss = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::x86_sse41_round_ss);
Value *undef = V(llvm::UndefValue::get(T(Float4::getType())));
Value *undef = V(llvm::UndefValue::get(T(Float4::type())));
Value *vector = Nucleus::createInsertElement(undef, val.value, 0);
return RValue<Float>(Nucleus::createExtractElement(V(jit->builder->CreateCall3(roundss, ARGS(V(undef), V(vector), V(Nucleus::createConstantInt(imm))))), Float::getType(), 0));
return RValue<Float>(Nucleus::createExtractElement(V(jit->builder->CreateCall3(roundss, ARGS(V(undef), V(vector), V(Nucleus::createConstantInt(imm))))), Float::type(), 0));
}
RValue<Float> floorss(RValue<Float> val)
......@@ -3722,22 +3722,22 @@ RValue<Short4> pminsw(RValue<Short4> x, RValue<Short4> y)
RValue<Short4> pcmpgtw(RValue<Short4> x, RValue<Short4> y)
{
return As<Short4>(V(lowerPCMP(llvm::ICmpInst::ICMP_SGT, V(x.value), V(y.value), T(Short4::getType()))));
return As<Short4>(V(lowerPCMP(llvm::ICmpInst::ICMP_SGT, V(x.value), V(y.value), T(Short4::type()))));
}
RValue<Short4> pcmpeqw(RValue<Short4> x, RValue<Short4> y)
{
return As<Short4>(V(lowerPCMP(llvm::ICmpInst::ICMP_EQ, V(x.value), V(y.value), T(Short4::getType()))));
return As<Short4>(V(lowerPCMP(llvm::ICmpInst::ICMP_EQ, V(x.value), V(y.value), T(Short4::type()))));
}
RValue<Byte8> pcmpgtb(RValue<SByte8> x, RValue<SByte8> y)
{
return As<Byte8>(V(lowerPCMP(llvm::ICmpInst::ICMP_SGT, V(x.value), V(y.value), T(Byte8::getType()))));
return As<Byte8>(V(lowerPCMP(llvm::ICmpInst::ICMP_SGT, V(x.value), V(y.value), T(Byte8::type()))));
}
RValue<Byte8> pcmpeqb(RValue<Byte8> x, RValue<Byte8> y)
{
return As<Byte8>(V(lowerPCMP(llvm::ICmpInst::ICMP_EQ, V(x.value), V(y.value), T(Byte8::getType()))));
return As<Byte8>(V(lowerPCMP(llvm::ICmpInst::ICMP_EQ, V(x.value), V(y.value), T(Byte8::type()))));
}
RValue<Short4> packssdw(RValue<Int2> x, RValue<Int2> y)
......@@ -3947,22 +3947,22 @@ RValue<Int> pmovmskb(RValue<Byte8> x)
RValue<Int4> pmovzxbd(RValue<Byte16> x)
{
return RValue<Int4>(V(lowerPMOV(V(x.value), T(Int4::getType()), false)));
return RValue<Int4>(V(lowerPMOV(V(x.value), T(Int4::type()), false)));
}
RValue<Int4> pmovsxbd(RValue<SByte16> x)
{
return RValue<Int4>(V(lowerPMOV(V(x.value), T(Int4::getType()), true)));
return RValue<Int4>(V(lowerPMOV(V(x.value), T(Int4::type()), true)));
}
RValue<Int4> pmovzxwd(RValue<UShort8> x)
{
return RValue<Int4>(V(lowerPMOV(V(x.value), T(Int4::getType()), false)));
return RValue<Int4>(V(lowerPMOV(V(x.value), T(Int4::type()), false)));
}
RValue<Int4> pmovsxwd(RValue<Short8> x)
{
return RValue<Int4>(V(lowerPMOV(V(x.value), T(Int4::getType()), true)));
return RValue<Int4>(V(lowerPMOV(V(x.value), T(Int4::type()), true)));
}
} // namespace x86
......
src/Reactor/Reactor.cpp
......@@ -251,21 +251,21 @@ Byte::Byte(Argument<Byte> argument)
Byte::Byte(RValue<Int> cast)
{
Value *integer = Nucleus::createTrunc(cast.value, Byte::getType());
Value *integer = Nucleus::createTrunc(cast.value, Byte::type());
storeValue(integer);
}
Byte::Byte(RValue<UInt> cast)
{
Value *integer = Nucleus::createTrunc(cast.value, Byte::getType());
Value *integer = Nucleus::createTrunc(cast.value, Byte::type());
storeValue(integer);
}
Byte::Byte(RValue<UShort> cast)
{
Value *integer = Nucleus::createTrunc(cast.value, Byte::getType());
Value *integer = Nucleus::createTrunc(cast.value, Byte::type());
storeValue(integer);
}
......@@ -508,14 +508,14 @@ SByte::SByte(Argument<SByte> argument)
SByte::SByte(RValue<Int> cast)
{
Value *integer = Nucleus::createTrunc(cast.value, SByte::getType());
Value *integer = Nucleus::createTrunc(cast.value, SByte::type());
storeValue(integer);
}
SByte::SByte(RValue<Short> cast)
{
Value *integer = Nucleus::createTrunc(cast.value, SByte::getType());
Value *integer = Nucleus::createTrunc(cast.value, SByte::type());
storeValue(integer);
}
......@@ -753,7 +753,7 @@ Short::Short(Argument<Short> argument)
Short::Short(RValue<Int> cast)
{
Value *integer = Nucleus::createTrunc(cast.value, Short::getType());
Value *integer = Nucleus::createTrunc(cast.value, Short::type());
storeValue(integer);
}
......@@ -991,14 +991,14 @@ UShort::UShort(Argument<UShort> argument)
UShort::UShort(RValue<UInt> cast)
{
Value *integer = Nucleus::createTrunc(cast.value, UShort::getType());
Value *integer = Nucleus::createTrunc(cast.value, UShort::type());
storeValue(integer);
}
UShort::UShort(RValue<Int> cast)
{
Value *integer = Nucleus::createTrunc(cast.value, UShort::getType());
Value *integer = Nucleus::createTrunc(cast.value, UShort::type());
storeValue(integer);
}
......@@ -1231,7 +1231,7 @@ RValue<Bool> operator==(RValue<UShort> lhs, RValue<UShort> rhs)
Byte4::Byte4(RValue<Byte8> cast)
{
storeValue(Nucleus::createBitCast(cast.value, getType()));
storeValue(Nucleus::createBitCast(cast.value, type()));
}
Byte4::Byte4(RValue<UShort4> cast)
......@@ -1293,7 +1293,7 @@ RValue<Byte4> Byte4::operator=(const Byte4 &rhs)
Byte8::Byte8(uint8_t x0, uint8_t x1, uint8_t x2, uint8_t x3, uint8_t x4, uint8_t x5, uint8_t x6, uint8_t x7)
{
int64_t constantVector[8] = { x0, x1, x2, x3, x4, x5, x6, x7 };
storeValue(Nucleus::createConstantVector(constantVector, getType()));
storeValue(Nucleus::createConstantVector(constantVector, type()));
}
Byte8::Byte8(RValue<Byte8> rhs)
......@@ -1507,9 +1507,9 @@ RValue<Short4> UnpackHigh(RValue<Byte8> x, RValue<Byte8> y)
SByte8::SByte8(uint8_t x0, uint8_t x1, uint8_t x2, uint8_t x3, uint8_t x4, uint8_t x5, uint8_t x6, uint8_t x7)
{
int64_t constantVector[8] = { x0, x1, x2, x3, x4, x5, x6, x7 };
Value *vector = Nucleus::createConstantVector(constantVector, getType());
Value *vector = Nucleus::createConstantVector(constantVector, type());
storeValue(Nucleus::createBitCast(vector, getType()));
storeValue(Nucleus::createBitCast(vector, type()));
}
SByte8::SByte8(RValue<SByte8> rhs)
......@@ -1748,18 +1748,18 @@ RValue<Byte16> Swizzle(RValue<Byte16> x, uint64_t select)
Short2::Short2(RValue<Short4> cast)
{
storeValue(Nucleus::createBitCast(cast.value, getType()));
storeValue(Nucleus::createBitCast(cast.value, type()));
}
UShort2::UShort2(RValue<UShort4> cast)
{
storeValue(Nucleus::createBitCast(cast.value, getType()));
storeValue(Nucleus::createBitCast(cast.value, type()));
}
Short4::Short4(RValue<Int> cast)
{
Value *vector = loadValue();
Value *element = Nucleus::createTrunc(cast.value, Short::getType());
Value *element = Nucleus::createTrunc(cast.value, Short::type());
Value *insert = Nucleus::createInsertElement(vector, element, 0);
Value *swizzle = Swizzle(RValue<Short4>(insert), 0x0000).value;
......@@ -1773,13 +1773,13 @@ Short4::Short4(RValue<Int> cast)
Short4::Short4(short xyzw)
{
int64_t constantVector[4] = { xyzw, xyzw, xyzw, xyzw };
storeValue(Nucleus::createConstantVector(constantVector, getType()));
storeValue(Nucleus::createConstantVector(constantVector, type()));
}
Short4::Short4(short x, short y, short z, short w)
{
int64_t constantVector[4] = { x, y, z, w };
storeValue(Nucleus::createConstantVector(constantVector, getType()));
storeValue(Nucleus::createConstantVector(constantVector, type()));
}
Short4::Short4(RValue<Short4> rhs)
......@@ -2010,7 +2010,7 @@ RValue<Short4> Insert(RValue<Short4> val, RValue<Short> element, int i)
RValue<Short> Extract(RValue<Short4> val, int i)
{
return RValue<Short>(Nucleus::createExtractElement(val.value, Short::getType(), i));
return RValue<Short>(Nucleus::createExtractElement(val.value, Short::type(), i));
}
UShort4::UShort4(RValue<Int4> cast)
......@@ -2021,13 +2021,13 @@ UShort4::UShort4(RValue<Int4> cast)
UShort4::UShort4(unsigned short xyzw)
{
int64_t constantVector[4] = { xyzw, xyzw, xyzw, xyzw };
storeValue(Nucleus::createConstantVector(constantVector, getType()));
storeValue(Nucleus::createConstantVector(constantVector, type()));
}
UShort4::UShort4(unsigned short x, unsigned short y, unsigned short z, unsigned short w)
{
int64_t constantVector[4] = { x, y, z, w };
storeValue(Nucleus::createConstantVector(constantVector, getType()));
storeValue(Nucleus::createConstantVector(constantVector, type()));
}
UShort4::UShort4(RValue<UShort4> rhs)
......@@ -2158,13 +2158,13 @@ RValue<UShort4> operator~(RValue<UShort4> val)
Short8::Short8(short c)
{
int64_t constantVector[8] = { c, c, c, c, c, c, c, c };
storeValue(Nucleus::createConstantVector(constantVector, getType()));
storeValue(Nucleus::createConstantVector(constantVector, type()));
}
Short8::Short8(short c0, short c1, short c2, short c3, short c4, short c5, short c6, short c7)
{
int64_t constantVector[8] = { c0, c1, c2, c3, c4, c5, c6, c7 };
storeValue(Nucleus::createConstantVector(constantVector, getType()));
storeValue(Nucleus::createConstantVector(constantVector, type()));
}
Short8::Short8(RValue<Short8> rhs)
......@@ -2229,13 +2229,13 @@ RValue<Int4> Abs(RValue<Int4> x)
UShort8::UShort8(unsigned short c)
{
int64_t constantVector[8] = { c, c, c, c, c, c, c, c };
storeValue(Nucleus::createConstantVector(constantVector, getType()));
storeValue(Nucleus::createConstantVector(constantVector, type()));
}
UShort8::UShort8(unsigned short c0, unsigned short c1, unsigned short c2, unsigned short c3, unsigned short c4, unsigned short c5, unsigned short c6, unsigned short c7)
{
int64_t constantVector[8] = { c0, c1, c2, c3, c4, c5, c6, c7 };
storeValue(Nucleus::createConstantVector(constantVector, getType()));
storeValue(Nucleus::createConstantVector(constantVector, type()));
}
UShort8::UShort8(RValue<UShort8> rhs)
......@@ -2328,28 +2328,28 @@ Int::Int(Argument<Int> argument)
Int::Int(RValue<Byte> cast)
{
Value *integer = Nucleus::createZExt(cast.value, Int::getType());
Value *integer = Nucleus::createZExt(cast.value, Int::type());
storeValue(integer);
}
Int::Int(RValue<SByte> cast)
{
Value *integer = Nucleus::createSExt(cast.value, Int::getType());
Value *integer = Nucleus::createSExt(cast.value, Int::type());
storeValue(integer);
}
Int::Int(RValue<Short> cast)
{
Value *integer = Nucleus::createSExt(cast.value, Int::getType());
Value *integer = Nucleus::createSExt(cast.value, Int::type());
storeValue(integer);
}
Int::Int(RValue<UShort> cast)
{
Value *integer = Nucleus::createZExt(cast.value, Int::getType());
Value *integer = Nucleus::createZExt(cast.value, Int::type());
storeValue(integer);
}
......@@ -2361,14 +2361,14 @@ Int::Int(RValue<Int2> cast)
Int::Int(RValue<Long> cast)
{
Value *integer = Nucleus::createTrunc(cast.value, Int::getType());
Value *integer = Nucleus::createTrunc(cast.value, Int::type());
storeValue(integer);
}
Int::Int(RValue<Float> cast)
{
Value *integer = Nucleus::createFPToSI(cast.value, Int::getType());
Value *integer = Nucleus::createFPToSI(cast.value, Int::type());
storeValue(integer);
}
......@@ -2625,14 +2625,14 @@ RValue<Int> Clamp(RValue<Int> x, RValue<Int> min, RValue<Int> max)
Long::Long(RValue<Int> cast)
{
Value *integer = Nucleus::createSExt(cast.value, Long::getType());
Value *integer = Nucleus::createSExt(cast.value, Long::type());
storeValue(integer);
}
Long::Long(RValue<UInt> cast)
{
Value *integer = Nucleus::createZExt(cast.value, Long::getType());
Value *integer = Nucleus::createZExt(cast.value, Long::type());
storeValue(integer);
}
......@@ -2747,14 +2747,14 @@ UInt::UInt(Argument<UInt> argument)
UInt::UInt(RValue<UShort> cast)
{
Value *integer = Nucleus::createZExt(cast.value, UInt::getType());
Value *integer = Nucleus::createZExt(cast.value, UInt::type());
storeValue(integer);
}
UInt::UInt(RValue<Long> cast)
{
Value *integer = Nucleus::createTrunc(cast.value, UInt::getType());
Value *integer = Nucleus::createTrunc(cast.value, UInt::type());
storeValue(integer);
}
......@@ -3016,13 +3016,13 @@ RValue<Bool> operator==(RValue<UInt> lhs, RValue<UInt> rhs)
Int2::Int2(RValue<Int4> cast)
{
storeValue(Nucleus::createBitCast(cast.value, getType()));
storeValue(Nucleus::createBitCast(cast.value, type()));
}
Int2::Int2(int x, int y)
{
int64_t constantVector[2] = { x, y };
storeValue(Nucleus::createConstantVector(constantVector, getType()));
storeValue(Nucleus::createConstantVector(constantVector, type()));
}
Int2::Int2(RValue<Int2> rhs)
......@@ -3047,7 +3047,7 @@ Int2::Int2(RValue<Int> lo, RValue<Int> hi)
int shuffle[4] = { 0, 4, 1, 5 };
Value *packed = Nucleus::createShuffleVector(Int4(lo).loadValue(), Int4(hi).loadValue(), shuffle);
storeValue(Nucleus::createBitCast(packed, Int2::getType()));
storeValue(Nucleus::createBitCast(packed, Int2::type()));
}
RValue<Int2> Int2::operator=(RValue<Int2> rhs)
......@@ -3195,7 +3195,7 @@ RValue<Short4> UnpackHigh(RValue<Int2> x, RValue<Int2> y)
RValue<Int> Extract(RValue<Int2> val, int i)
{
return RValue<Int>(Nucleus::createExtractElement(val.value, Int::getType(), i));
return RValue<Int>(Nucleus::createExtractElement(val.value, Int::type(), i));
}
RValue<Int2> Insert(RValue<Int2> val, RValue<Int> element, int i)
......@@ -3206,7 +3206,7 @@ RValue<Int2> Insert(RValue<Int2> val, RValue<Int> element, int i)
UInt2::UInt2(unsigned int x, unsigned int y)
{
int64_t constantVector[2] = { x, y };
storeValue(Nucleus::createConstantVector(constantVector, getType()));
storeValue(Nucleus::createConstantVector(constantVector, type()));
}
UInt2::UInt2(RValue<UInt2> rhs)
......@@ -3356,7 +3356,7 @@ RValue<UInt2> operator~(RValue<UInt2> val)
RValue<UInt> Extract(RValue<UInt2> val, int i)
{
return RValue<UInt>(Nucleus::createExtractElement(val.value, UInt::getType(), i));
return RValue<UInt>(Nucleus::createExtractElement(val.value, UInt::type(), i));
}
RValue<UInt2> Insert(RValue<UInt2> val, RValue<UInt> element, int i)
......@@ -3372,7 +3372,7 @@ Int4::Int4()
Int4::Int4(RValue<Float4> cast)
: XYZW(this)
{
Value *xyzw = Nucleus::createFPToSI(cast.value, Int4::getType());
Value *xyzw = Nucleus::createFPToSI(cast.value, Int4::type());
storeValue(xyzw);
}
......@@ -3404,7 +3404,7 @@ Int4::Int4(int x, int y, int z, int w)
void Int4::constant(int x, int y, int z, int w)
{
int64_t constantVector[4] = { x, y, z, w };
storeValue(Nucleus::createConstantVector(constantVector, getType()));
storeValue(Nucleus::createConstantVector(constantVector, type()));
}
Int4::Int4(RValue<Int4> rhs)
......@@ -3608,7 +3608,7 @@ RValue<Int4> operator~(RValue<Int4> val)
RValue<Int> Extract(RValue<Int4> x, int i)
{
return RValue<Int>(Nucleus::createExtractElement(x.value, Int::getType(), i));
return RValue<Int>(Nucleus::createExtractElement(x.value, Int::type(), i));
}
RValue<Int4> Insert(RValue<Int4> x, RValue<Int> element, int i)
......@@ -3658,7 +3658,7 @@ UInt4::UInt4(int x, int y, int z, int w)
void UInt4::constant(int x, int y, int z, int w)
{
int64_t constantVector[4] = { x, y, z, w };
storeValue(Nucleus::createConstantVector(constantVector, getType()));
storeValue(Nucleus::createConstantVector(constantVector, type()));
}
UInt4::UInt4(RValue<UInt4> rhs)
......@@ -3862,7 +3862,7 @@ RValue<UInt4> operator~(RValue<UInt4> val)
RValue<UInt> Extract(RValue<UInt4> x, int i)
{
return RValue<UInt>(Nucleus::createExtractElement(x.value, Int::getType(), i));
return RValue<UInt>(Nucleus::createExtractElement(x.value, Int::type(), i));
}
RValue<UInt4> Insert(RValue<UInt4> x, RValue<UInt> element, int i)
......@@ -3910,7 +3910,7 @@ Half::Half(RValue<Float> cast)
Float::Float(RValue<Int> cast)
{
Value *integer = Nucleus::createSIToFP(cast.value, Float::getType());
Value *integer = Nucleus::createSIToFP(cast.value, Float::type());
storeValue(integer);
}
......@@ -4133,14 +4133,14 @@ RValue<Float> Min(RValue<Float> x, RValue<Float> y)
Float2::Float2(RValue<Float4> cast)
{
storeValue(Nucleus::createBitCast(cast.value, getType()));
storeValue(Nucleus::createBitCast(cast.value, type()));
}
Float4::Float4(RValue<Byte4> cast)
: XYZW(this)
{
Value *a = Int4(cast).loadValue();
Value *xyzw = Nucleus::createSIToFP(a, Float4::getType());
Value *xyzw = Nucleus::createSIToFP(a, Float4::type());
storeValue(xyzw);
}
......@@ -4149,7 +4149,7 @@ Float4::Float4(RValue<SByte4> cast)
: XYZW(this)
{
Value *a = Int4(cast).loadValue();
Value *xyzw = Nucleus::createSIToFP(a, Float4::getType());
Value *xyzw = Nucleus::createSIToFP(a, Float4::type());
storeValue(xyzw);
}
......@@ -4158,20 +4158,20 @@ Float4::Float4(RValue<Short4> cast)
: XYZW(this)
{
Int4 c(cast);
storeValue(Nucleus::createSIToFP(RValue<Int4>(c).value, Float4::getType()));
storeValue(Nucleus::createSIToFP(RValue<Int4>(c).value, Float4::type()));
}
Float4::Float4(RValue<UShort4> cast)
: XYZW(this)
{
Int4 c(cast);
storeValue(Nucleus::createSIToFP(RValue<Int4>(c).value, Float4::getType()));
storeValue(Nucleus::createSIToFP(RValue<Int4>(c).value, Float4::type()));
}
Float4::Float4(RValue<Int4> cast)
: XYZW(this)
{
Value *xyzw = Nucleus::createSIToFP(cast.value, Float4::getType());
Value *xyzw = Nucleus::createSIToFP(cast.value, Float4::type());
storeValue(xyzw);
}
......@@ -4220,7 +4220,7 @@ Float4 Float4::infinity()
constexpr double inf = std::numeric_limits<double>::infinity();
double constantVector[4] = { inf, inf, inf, inf };
result.storeValue(Nucleus::createConstantVector(constantVector, getType()));
result.storeValue(Nucleus::createConstantVector(constantVector, type()));
return result;
}
......@@ -4231,7 +4231,7 @@ void Float4::constant(float x, float y, float z, float w)
ASSERT(std::isfinite(x) && std::isfinite(y) && std::isfinite(z) && std::isfinite(w));
double constantVector[4] = { x, y, z, w };
storeValue(Nucleus::createConstantVector(constantVector, getType()));
storeValue(Nucleus::createConstantVector(constantVector, type()));
}
Float4::Float4(RValue<Float4> rhs)
......@@ -4367,9 +4367,9 @@ RValue<Float4> operator-(RValue<Float4> val)
RValue<Float4> Abs(RValue<Float4> x)
{
// TODO: Optimize.
Value *vector = Nucleus::createBitCast(x.value, Int4::getType());
Value *vector = Nucleus::createBitCast(x.value, Int4::type());
int64_t constantVector[4] = { 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF };
Value *result = Nucleus::createAnd(vector, Nucleus::createConstantVector(constantVector, Int4::getType()));
Value *result = Nucleus::createAnd(vector, Nucleus::createConstantVector(constantVector, Int4::type()));
return As<Float4>(result);
}
......@@ -4381,7 +4381,7 @@ RValue<Float4> Insert(RValue<Float4> x, RValue<Float> element, int i)
RValue<Float> Extract(RValue<Float4> x, int i)
{
return RValue<Float>(Nucleus::createExtractElement(x.value, Float::getType(), i));
return RValue<Float>(Nucleus::createExtractElement(x.value, Float::type(), i));
}
RValue<Float4> Swizzle(RValue<Float4> x, uint16_t select)
......@@ -4444,12 +4444,12 @@ RValue<Pointer<Byte>> operator+(RValue<Pointer<Byte>> lhs, int offset)
RValue<Pointer<Byte>> operator+(RValue<Pointer<Byte>> lhs, RValue<Int> offset)
{
return RValue<Pointer<Byte>>(Nucleus::createGEP(lhs.value, Byte::getType(), offset.value, false));
return RValue<Pointer<Byte>>(Nucleus::createGEP(lhs.value, Byte::type(), offset.value, false));
}
RValue<Pointer<Byte>> operator+(RValue<Pointer<Byte>> lhs, RValue<UInt> offset)
{
return RValue<Pointer<Byte>>(Nucleus::createGEP(lhs.value, Byte::getType(), offset.value, true));
return RValue<Pointer<Byte>>(Nucleus::createGEP(lhs.value, Byte::type(), offset.value, true));
}
RValue<Pointer<Byte>> operator+=(Pointer<Byte> &lhs, int offset)
......@@ -4512,12 +4512,12 @@ void branch(RValue<Bool> cmp, BasicBlock *bodyBB, BasicBlock *endBB)
RValue<Float4> MaskedLoad(RValue<Pointer<Float4>> base, RValue<Int4> mask, unsigned int alignment, bool zeroMaskedLanes /* = false */)
{
return RValue<Float4>(Nucleus::createMaskedLoad(base.value, Float::getType(), mask.value, alignment, zeroMaskedLanes));
return RValue<Float4>(Nucleus::createMaskedLoad(base.value, Float::type(), mask.value, alignment, zeroMaskedLanes));
}
RValue<Int4> MaskedLoad(RValue<Pointer<Int4>> base, RValue<Int4> mask, unsigned int alignment, bool zeroMaskedLanes /* = false */)
{
return RValue<Int4>(Nucleus::createMaskedLoad(base.value, Int::getType(), mask.value, alignment, zeroMaskedLanes));
return RValue<Int4>(Nucleus::createMaskedLoad(base.value, Int::type(), mask.value, alignment, zeroMaskedLanes));
}
void MaskedStore(RValue<Pointer<Float4>> base, RValue<Float4> val, RValue<Int4> mask, unsigned int alignment)
......@@ -4611,7 +4611,7 @@ static std::vector<Value *> extractAll(Value *vec, int n)
// toInt returns all the integer values in vals extended to a printf-required storage value
static std::vector<Value *> toInt(const std::vector<Value *> &vals, bool isSigned)
{
auto storageTy = Nucleus::getPrintfStorageType(Int::getType());
auto storageTy = Nucleus::getPrintfStorageType(Int::type());
std::vector<Value *> elements;
elements.reserve(vals.size());
for(auto v : vals)
......@@ -4631,7 +4631,7 @@ static std::vector<Value *> toInt(const std::vector<Value *> &vals, bool isSigne
// toFloat returns all the float values in vals extended to extended to a printf-required storage value
static std::vector<Value *> toFloat(const std::vector<Value *> &vals)
{
auto storageTy = Nucleus::getPrintfStorageType(Float::getType());
auto storageTy = Nucleus::getPrintfStorageType(Float::type());
std::vector<Value *> elements;
elements.reserve(vals.size());
for(auto v : vals)
......
src/Reactor/Reactor.hpp
......@@ -90,12 +90,7 @@ class Float4;
class Void
{
public:
static Type *getType();
static bool isVoid()
{
return true;
}
static Type *type();
};
template<class T>
......@@ -150,11 +145,6 @@ public:
RValue<Pointer<T>> operator&();
static bool isVoid()
{
return false;
}
// self() returns the this pointer to this LValue<T> object.
// This function exists because operator&() is overloaded.
inline LValue<T> *self() { return this; }
......@@ -281,7 +271,7 @@ public:
RValue<Bool> operator=(const Bool &rhs);
RValue<Bool> operator=(const Reference<Bool> &rhs);
static Type *getType();
static Type *type();
};
RValue<Bool> operator!(RValue<Bool> val);
......@@ -311,7 +301,7 @@ public:
RValue<Byte> operator=(const Byte &rhs);
RValue<Byte> operator=(const Reference<Byte> &rhs);
static Type *getType();
static Type *type();
};
RValue<Byte> operator+(RValue<Byte> lhs, RValue<Byte> rhs);
......@@ -367,7 +357,7 @@ public:
RValue<SByte> operator=(const SByte &rhs);
RValue<SByte> operator=(const Reference<SByte> &rhs);
static Type *getType();
static Type *type();
};
RValue<SByte> operator+(RValue<SByte> lhs, RValue<SByte> rhs);
......@@ -422,7 +412,7 @@ public:
RValue<Short> operator=(const Short &rhs);
RValue<Short> operator=(const Reference<Short> &rhs);
static Type *getType();
static Type *type();
};
RValue<Short> operator+(RValue<Short> lhs, RValue<Short> rhs);
......@@ -478,7 +468,7 @@ public:
RValue<UShort> operator=(const UShort &rhs);
RValue<UShort> operator=(const Reference<UShort> &rhs);
static Type *getType();
static Type *type();
};
RValue<UShort> operator+(RValue<UShort> lhs, RValue<UShort> rhs);
......@@ -534,7 +524,7 @@ public:
RValue<Byte4> operator=(const Byte4 &rhs);
// RValue<Byte4> operator=(const Reference<Byte4> &rhs);
static Type *getType();
static Type *type();
};
// RValue<Byte4> operator+(RValue<Byte4> lhs, RValue<Byte4> rhs);
......@@ -578,7 +568,7 @@ public:
// RValue<SByte4> operator=(const SByte4 &rhs);
// RValue<SByte4> operator=(const Reference<SByte4> &rhs);
static Type *getType();
static Type *type();
};
// RValue<SByte4> operator+(RValue<SByte4> lhs, RValue<SByte4> rhs);
......@@ -622,7 +612,7 @@ public:
RValue<Byte8> operator=(const Byte8 &rhs);
RValue<Byte8> operator=(const Reference<Byte8> &rhs);
static Type *getType();
static Type *type();
};
RValue<Byte8> operator+(RValue<Byte8> lhs, RValue<Byte8> rhs);
......@@ -677,7 +667,7 @@ public:
RValue<SByte8> operator=(const SByte8 &rhs);
RValue<SByte8> operator=(const Reference<SByte8> &rhs);
static Type *getType();
static Type *type();
};
RValue<SByte8> operator+(RValue<SByte8> lhs, RValue<SByte8> rhs);
......@@ -728,7 +718,7 @@ public:
RValue<Byte16> operator=(const Byte16 &rhs);
RValue<Byte16> operator=(const Reference<Byte16> &rhs);
static Type *getType();
static Type *type();
};
// RValue<Byte16> operator+(RValue<Byte16> lhs, RValue<Byte16> rhs);
......@@ -773,7 +763,7 @@ public:
// RValue<SByte16> operator=(const SByte16 &rhs);
// RValue<SByte16> operator=(const Reference<SByte16> &rhs);
static Type *getType();
static Type *type();
};
// RValue<SByte16> operator+(RValue<SByte16> lhs, RValue<SByte16> rhs);
......@@ -809,7 +799,7 @@ class Short2 : public LValue<Short2>
public:
explicit Short2(RValue<Short4> cast);
static Type *getType();
static Type *type();
};
class UShort2 : public LValue<UShort2>
......@@ -817,7 +807,7 @@ class UShort2 : public LValue<UShort2>
public:
explicit UShort2(RValue<UShort4> cast);
static Type *getType();
static Type *type();
};
class Short4 : public LValue<Short4>
......@@ -845,7 +835,7 @@ public:
RValue<Short4> operator=(const UShort4 &rhs);
RValue<Short4> operator=(const Reference<UShort4> &rhs);
static Type *getType();
static Type *type();
};
RValue<Short4> operator+(RValue<Short4> lhs, RValue<Short4> rhs);
......@@ -922,7 +912,7 @@ public:
RValue<UShort4> operator=(const Short4 &rhs);
RValue<UShort4> operator=(const Reference<Short4> &rhs);
static Type *getType();
static Type *type();
};
RValue<UShort4> operator+(RValue<UShort4> lhs, RValue<UShort4> rhs);
......@@ -975,7 +965,7 @@ public:
RValue<Short8> operator=(const Short8 &rhs);
RValue<Short8> operator=(const Reference<Short8> &rhs);
static Type *getType();
static Type *type();
};
RValue<Short8> operator+(RValue<Short8> lhs, RValue<Short8> rhs);
......@@ -1033,7 +1023,7 @@ public:
RValue<UShort8> operator=(const UShort8 &rhs);
RValue<UShort8> operator=(const Reference<UShort8> &rhs);
static Type *getType();
static Type *type();
};
RValue<UShort8> operator+(RValue<UShort8> lhs, RValue<UShort8> rhs);
......@@ -1105,7 +1095,7 @@ public:
RValue<Int> operator=(const Reference<Int> &rhs);
RValue<Int> operator=(const Reference<UInt> &rhs);
static Type *getType();
static Type *type();
};
RValue<Int> operator+(RValue<Int> lhs, RValue<Int> rhs);
......@@ -1175,7 +1165,7 @@ public:
// RValue<Long> operator=(const ULong &rhs);
// RValue<Long> operator=(const Reference<ULong> &rhs);
static Type *getType();
static Type *type();
};
RValue<Long> operator+(RValue<Long> lhs, RValue<Long> rhs);
......@@ -1242,7 +1232,7 @@ public:
RValue<UInt> operator=(const Reference<UInt> &rhs);
RValue<UInt> operator=(const Reference<Int> &rhs);
static Type *getType();
static Type *type();
};
RValue<UInt> operator+(RValue<UInt> lhs, RValue<UInt> rhs);
......@@ -1314,7 +1304,7 @@ public:
RValue<Int2> operator=(const Int2 &rhs);
RValue<Int2> operator=(const Reference<Int2> &rhs);
static Type *getType();
static Type *type();
};
RValue<Int2> operator+(RValue<Int2> lhs, RValue<Int2> rhs);
......@@ -1370,7 +1360,7 @@ public:
RValue<UInt2> operator=(const UInt2 &rhs);
RValue<UInt2> operator=(const Reference<UInt2> &rhs);
static Type *getType();
static Type *type();
};
RValue<UInt2> operator+(RValue<UInt2> lhs, RValue<UInt2> rhs);
......@@ -1887,7 +1877,7 @@ public:
RValue<Int4> operator=(const Int4 &rhs);
RValue<Int4> operator=(const Reference<Int4> &rhs);
static Type *getType();
static Type *type();
private:
void constant(int x, int y, int z, int w);
......@@ -1990,7 +1980,7 @@ public:
RValue<UInt4> operator=(const UInt4 &rhs);
RValue<UInt4> operator=(const Reference<UInt4> &rhs);
static Type *getType();
static Type *type();
private:
void constant(int x, int y, int z, int w);
......@@ -2060,7 +2050,7 @@ class Half : public LValue<Half>
public:
explicit Half(RValue<Float> cast);
static Type *getType();
static Type *type();
};
class Float : public LValue<Float>
......@@ -2090,7 +2080,7 @@ public:
static Float infinity();
static Type *getType();
static Type *type();
};
RValue<Float> operator+(RValue<Float> lhs, RValue<Float> rhs);
......@@ -2182,7 +2172,7 @@ public:
// template<int T>
// RValue<Float2> operator=(const SwizzleMask1<T> &rhs);
static Type *getType();
static Type *type();
};
// RValue<Float2> operator+(RValue<Float2> lhs, RValue<Float2> rhs);
......@@ -2254,7 +2244,7 @@ public:
static Float4 infinity();
static Type *getType();
static Type *type();
private:
void constant(float x, float y, float z, float w);
......@@ -2376,7 +2366,7 @@ public:
Pointer(RValue<Pointer<S>> pointerS, int alignment = 1)
: alignment(alignment)
{
Value *pointerT = Nucleus::createBitCast(pointerS.value, Nucleus::getPointerType(T::getType()));
Value *pointerT = Nucleus::createBitCast(pointerS.value, Nucleus::getPointerType(T::type()));
LValue<Pointer<T>>::storeValue(pointerT);
}
......@@ -2385,7 +2375,7 @@ public:
: alignment(alignment)
{
Value *pointerS = pointer.loadValue();
Value *pointerT = Nucleus::createBitCast(pointerS, Nucleus::getPointerType(T::getType()));
Value *pointerT = Nucleus::createBitCast(pointerS, Nucleus::getPointerType(T::type()));
LValue<Pointer<T>>::storeValue(pointerT);
}
......@@ -2408,7 +2398,7 @@ public:
Reference<T> operator[](RValue<Int> index);
Reference<T> operator[](RValue<UInt> index);
static Type *getType();
static Type *type();
private:
const int alignment;
......@@ -2437,7 +2427,7 @@ RValue<Bool> operator==(const Pointer<T> &lhs, const Pointer<T> &rhs)
template<typename T>
RValue<T> Load(RValue<Pointer<T>> pointer, unsigned int alignment, bool atomic, std::memory_order memoryOrder)
{
return RValue<T>(Nucleus::createLoad(pointer.value, T::getType(), false, alignment, atomic, memoryOrder));
return RValue<T>(Nucleus::createLoad(pointer.value, T::type(), false, alignment, atomic, memoryOrder));
}
template<typename T>
......@@ -2460,7 +2450,7 @@ void Scatter(RValue<Pointer<Int>> base, RValue<Int4> val, RValue<Int4> offsets,
template<typename T>
void Store(RValue<T> value, RValue<Pointer<T>> pointer, unsigned int alignment, bool atomic, std::memory_order memoryOrder)
{
Nucleus::createStore(value.value, pointer.value, T::getType(), false, alignment, atomic, memoryOrder);
Nucleus::createStore(value.value, pointer.value, T::type(), false, alignment, atomic, memoryOrder);
}
template<typename T>
......@@ -2602,7 +2592,7 @@ namespace rr {
template<class T>
LValue<T>::LValue(int arraySize)
: Variable(T::getType(), arraySize)
: Variable(T::type(), arraySize)
{
#ifdef ENABLE_RR_DEBUG_INFO
materialize();
......@@ -2680,7 +2670,7 @@ Reference<T>::Reference(Value *pointer, int alignment)
template<class T>
RValue<T> Reference<T>::operator=(RValue<T> rhs) const
{
Nucleus::createStore(rhs.value, address, T::getType(), false, alignment);
Nucleus::createStore(rhs.value, address, T::type(), false, alignment);
return rhs;
}
......@@ -2688,8 +2678,8 @@ RValue<T> Reference<T>::operator=(RValue<T> rhs) const
template<class T>
RValue<T> Reference<T>::operator=(const Reference<T> &ref) const
{
Value *tmp = Nucleus::createLoad(ref.address, T::getType(), false, ref.alignment);
Nucleus::createStore(tmp, address, T::getType(), false, alignment);
Value *tmp = Nucleus::createLoad(ref.address, T::type(), false, ref.alignment);
Nucleus::createStore(tmp, address, T::type(), false, alignment);
return RValue<T>(tmp);
}
......@@ -2703,7 +2693,7 @@ RValue<T> Reference<T>::operator+=(RValue<T> rhs) const
template<class T>
Value *Reference<T>::loadValue() const
{
return Nucleus::createLoad(address, T::getType(), false, alignment);
return Nucleus::createLoad(address, T::type(), false, alignment);
}
template<class T>
......@@ -2724,7 +2714,7 @@ RValue<T>::RValue(const RValue<T> &rvalue)
template<class T>
RValue<T>::RValue(Value *rvalue)
{
assert(Nucleus::createBitCast(rvalue, T::getType()) == rvalue); // Run-time type should match T, so bitcast is no-op.
assert(Nucleus::createBitCast(rvalue, T::type()) == rvalue); // Run-time type should match T, so bitcast is no-op.
value = rvalue;
RR_DEBUG_INFO_EMIT_VAR(value);
......@@ -2974,7 +2964,7 @@ template<class T>
Pointer<T>::Pointer(std::nullptr_t)
: alignment(1)
{
Value *value = Nucleus::createNullPointer(T::getType());
Value *value = Nucleus::createNullPointer(T::type());
LValue<Pointer<T>>::storeValue(value);
}
......@@ -3007,7 +2997,7 @@ RValue<Pointer<T>> Pointer<T>::operator=(const Reference<Pointer<T>> &rhs)
template<class T>
RValue<Pointer<T>> Pointer<T>::operator=(std::nullptr_t)
{
Value *value = Nucleus::createNullPointer(T::getType());
Value *value = Nucleus::createNullPointer(T::type());
LValue<Pointer<T>>::storeValue(value);
return RValue<Pointer<T>>(this);
......@@ -3023,7 +3013,7 @@ template<class T>
Reference<T> Pointer<T>::operator[](int index)
{
RR_DEBUG_INFO_UPDATE_LOC();
Value *element = Nucleus::createGEP(LValue<Pointer<T>>::loadValue(), T::getType(), Nucleus::createConstantInt(index), false);
Value *element = Nucleus::createGEP(LValue<Pointer<T>>::loadValue(), T::type(), Nucleus::createConstantInt(index), false);
return Reference<T>(element, alignment);
}
......@@ -3032,7 +3022,7 @@ template<class T>
Reference<T> Pointer<T>::operator[](unsigned int index)
{
RR_DEBUG_INFO_UPDATE_LOC();
Value *element = Nucleus::createGEP(LValue<Pointer<T>>::loadValue(), T::getType(), Nucleus::createConstantInt(index), true);
Value *element = Nucleus::createGEP(LValue<Pointer<T>>::loadValue(), T::type(), Nucleus::createConstantInt(index), true);
return Reference<T>(element, alignment);
}
......@@ -3041,7 +3031,7 @@ template<class T>
Reference<T> Pointer<T>::operator[](RValue<Int> index)
{
RR_DEBUG_INFO_UPDATE_LOC();
Value *element = Nucleus::createGEP(LValue<Pointer<T>>::loadValue(), T::getType(), index.value, false);
Value *element = Nucleus::createGEP(LValue<Pointer<T>>::loadValue(), T::type(), index.value, false);
return Reference<T>(element, alignment);
}
......@@ -3050,15 +3040,15 @@ template<class T>
Reference<T> Pointer<T>::operator[](RValue<UInt> index)
{
RR_DEBUG_INFO_UPDATE_LOC();
Value *element = Nucleus::createGEP(LValue<Pointer<T>>::loadValue(), T::getType(), index.value, true);
Value *element = Nucleus::createGEP(LValue<Pointer<T>>::loadValue(), T::type(), index.value, true);
return Reference<T>(element, alignment);
}
template<class T>
Type *Pointer<T>::getType()
Type *Pointer<T>::type()
{
return Nucleus::getPointerType(T::getType());
return Nucleus::getPointerType(T::type());
}
template<class T, int S>
......@@ -3070,7 +3060,7 @@ Array<T, S>::Array(int size)
template<class T, int S>
Reference<T> Array<T, S>::operator[](int index)
{
assert(index < this->arraySize);
assert(index < Variable::arraySize);
Value *element = LValue<T>::getElementPointer(Nucleus::createConstantInt(index), false);
return Reference<T>(element);
......@@ -3079,7 +3069,7 @@ Reference<T> Array<T, S>::operator[](int index)
template<class T, int S>
Reference<T> Array<T, S>::operator[](unsigned int index)
{
assert(index < static_cast<unsigned int>(this->arraySize));
assert(index < static_cast<unsigned int>(Variable::arraySize));
Value *element = LValue<T>::getElementPointer(Nucleus::createConstantInt(index), true);
return Reference<T>(element);
......@@ -3165,16 +3155,16 @@ Function<Return(Arguments...)>::Function()
{
core = new Nucleus();
Type *types[] = { Arguments::getType()... };
Type *types[] = { Arguments::type()... };
for(Type *type : types)
{
if(type != Void::getType())
if(type != Void::type())
{
arguments.push_back(type);
}
}
Nucleus::createFunction(Return::getType(), arguments);
Nucleus::createFunction(Return::type(), arguments);
}
template<typename Return, typename... Arguments>
......@@ -3213,7 +3203,7 @@ template<class T, class S>
RValue<T> ReinterpretCast(RValue<S> val)
{
RR_DEBUG_INFO_UPDATE_LOC();
return RValue<T>(Nucleus::createBitCast(val.value, T::getType()));
return RValue<T>(Nucleus::createBitCast(val.value, T::type()));
}
template<class T, class S>
......@@ -3222,7 +3212,7 @@ RValue<T> ReinterpretCast(const LValue<S> &var)
RR_DEBUG_INFO_UPDATE_LOC();
Value *val = var.loadValue();
return RValue<T>(Nucleus::createBitCast(val, T::getType()));
return RValue<T>(Nucleus::createBitCast(val, T::type()));
}
template<class T, class S>
......@@ -3235,7 +3225,7 @@ template<class T>
RValue<T> As(Value *val)
{
RR_DEBUG_INFO_UPDATE_LOC();
return RValue<T>(Nucleus::createBitCast(val, T::getType()));
return RValue<T>(Nucleus::createBitCast(val, T::type()));
}
template<class T, class S>
......@@ -3275,18 +3265,18 @@ public:
{
return RValue<RReturn>(rr::Call(
ConstantPointer(reinterpret_cast<void *>(fptr)),
RReturn::getType(),
RReturn::type(),
{ ValueOf(args)... },
{ CToReactorT<Arguments>::getType()... }));
{ CToReactorT<Arguments>::type()... }));
}
static inline RReturn Call(Pointer<Byte> fptr, CToReactorT<Arguments>... args)
{
return RValue<RReturn>(rr::Call(
fptr,
RReturn::getType(),
RReturn::type(),
{ ValueOf(args)... },
{ CToReactorT<Arguments>::getType()... }));
{ CToReactorT<Arguments>::type()... }));
}
};
......@@ -3297,17 +3287,17 @@ public:
static inline void Call(void(fptr)(Arguments...), CToReactorT<Arguments>... args)
{
rr::Call(ConstantPointer(reinterpret_cast<void *>(fptr)),
Void::getType(),
Void::type(),
{ ValueOf(args)... },
{ CToReactorT<Arguments>::getType()... });
{ CToReactorT<Arguments>::type()... });
}
static inline void Call(Pointer<Byte> fptr, CToReactorT<Arguments>... args)
{
rr::Call(fptr,
Void::getType(),
Void::type(),
{ ValueOf(args)... },
{ CToReactorT<Arguments>::getType()... });
{ CToReactorT<Arguments>::type()... });
}
};
......
src/Reactor/SubzeroReactor.cpp
......@@ -165,7 +165,7 @@ Ice::Variable *Call(Ice::Cfg *function, Ice::CfgNode *basicBlock, Return(fptr)(C
{
static_assert(sizeof...(CArgs) == sizeof...(RArgs), "Expected number of args don't match");
Ice::Type retTy = T(rr::CToReactorT<Return>::getType());
Ice::Type retTy = T(rr::CToReactorT<Return>::type());
std::vector<Ice::Operand *> iceArgs{ std::forward<RArgs>(args)... };
return Call(function, basicBlock, retTy, reinterpret_cast<void const *>(fptr), iceArgs, false);
}
......@@ -2165,42 +2165,42 @@ Value *Nucleus::createConstantString(const char *v)
return V(IceConstantData(v, strlen(v) + 1));
}
Type *Void::getType()
Type *Void::type()
{
return T(Ice::IceType_void);
}
Type *Bool::getType()
Type *Bool::type()
{
return T(Ice::IceType_i1);
}
Type *Byte::getType()
Type *Byte::type()
{
return T(Ice::IceType_i8);
}
Type *SByte::getType()
Type *SByte::type()
{
return T(Ice::IceType_i8);
}
Type *Short::getType()
Type *Short::type()
{
return T(Ice::IceType_i16);
}
Type *UShort::getType()
Type *UShort::type()
{
return T(Ice::IceType_i16);
}
Type *Byte4::getType()
Type *Byte4::type()
{
return T(Type_v4i8);
}
Type *SByte4::getType()
Type *SByte4::type()
{
return T(Type_v4i8);
}
......@@ -2213,7 +2213,7 @@ RValue<Byte> SaturateUnsigned(RValue<Short> x)
RValue<Byte> Extract(RValue<Byte8> val, int i)
{
return RValue<Byte>(Nucleus::createExtractElement(val.value, Byte::getType(), i));
return RValue<Byte>(Nucleus::createExtractElement(val.value, Byte::type(), i));
}
RValue<Byte8> Insert(RValue<Byte8> val, RValue<Byte> element, int i)
......@@ -2287,7 +2287,7 @@ RValue<Byte8> SubSat(RValue<Byte8> x, RValue<Byte8> y)
RValue<SByte> Extract(RValue<SByte8> val, int i)
{
RR_DEBUG_INFO_UPDATE_LOC();
return RValue<SByte>(Nucleus::createExtractElement(val.value, SByte::getType(), i));
return RValue<SByte>(Nucleus::createExtractElement(val.value, SByte::type(), i));
}
RValue<SByte8> Insert(RValue<SByte8> val, RValue<SByte> element, int i)
......@@ -2359,7 +2359,7 @@ RValue<Byte8> CmpEQ(RValue<Byte8> x, RValue<Byte8> y)
return RValue<Byte8>(Nucleus::createICmpEQ(x.value, y.value));
}
Type *Byte8::getType()
Type *Byte8::type()
{
return T(Type_v8i8);
}
......@@ -2475,27 +2475,27 @@ RValue<Byte8> CmpEQ(RValue<SByte8> x, RValue<SByte8> y)
return RValue<Byte8>(Nucleus::createICmpEQ(x.value, y.value));
}
Type *SByte8::getType()
Type *SByte8::type()
{
return T(Type_v8i8);
}
Type *Byte16::getType()
Type *Byte16::type()
{
return T(Ice::IceType_v16i8);
}
Type *SByte16::getType()
Type *SByte16::type()
{
return T(Ice::IceType_v16i8);
}
Type *Short2::getType()
Type *Short2::type()
{
return T(Type_v2i16);
}
Type *UShort2::getType()
Type *UShort2::type()
{
return T(Type_v2i16);
}
......@@ -2503,11 +2503,11 @@ Type *UShort2::getType()
Short4::Short4(RValue<Int4> cast)
{
int select[8] = { 0, 2, 4, 6, 0, 2, 4, 6 };
Value *short8 = Nucleus::createBitCast(cast.value, Short8::getType());
Value *short8 = Nucleus::createBitCast(cast.value, Short8::type());
Value *packed = Nucleus::createShuffleVector(short8, short8, select);
Value *int2 = RValue<Int2>(Int2(As<Int4>(packed))).value;
Value *short4 = Nucleus::createBitCast(int2, Short4::getType());
Value *short4 = Nucleus::createBitCast(int2, Short4::type());
storeValue(short4);
}
......@@ -2776,7 +2776,7 @@ RValue<Short4> CmpEQ(RValue<Short4> x, RValue<Short4> y)
return RValue<Short4>(Nucleus::createICmpEQ(x.value, y.value));
}
Type *Short4::getType()
Type *Short4::type()
{
return T(Type_v4i16);
}
......@@ -2811,7 +2811,7 @@ UShort4::UShort4(RValue<Float4> cast, bool saturate)
RValue<UShort> Extract(RValue<UShort4> val, int i)
{
return RValue<UShort>(Nucleus::createExtractElement(val.value, UShort::getType(), i));
return RValue<UShort>(Nucleus::createExtractElement(val.value, UShort::type(), i));
}
RValue<UShort4> Insert(RValue<UShort4> val, RValue<UShort> element, int i)
......@@ -3027,7 +3027,7 @@ RValue<UShort4> Average(RValue<UShort4> x, RValue<UShort4> y)
return UShort4(0);
}
Type *UShort4::getType()
Type *UShort4::type()
{
return T(Type_v4i16);
}
......@@ -3035,7 +3035,7 @@ Type *UShort4::getType()
RValue<Short> Extract(RValue<Short8> val, int i)
{
RR_DEBUG_INFO_UPDATE_LOC();
return RValue<Short>(Nucleus::createExtractElement(val.value, Short::getType(), i));
return RValue<Short>(Nucleus::createExtractElement(val.value, Short::type(), i));
}
RValue<Short8> Insert(RValue<Short8> val, RValue<Short> element, int i)
......@@ -3104,7 +3104,7 @@ RValue<Short8> MulHigh(RValue<Short8> x, RValue<Short8> y)
return Short8(0);
}
Type *Short8::getType()
Type *Short8::type()
{
return T(Ice::IceType_v8i16);
}
......@@ -3112,7 +3112,7 @@ Type *Short8::getType()
RValue<UShort> Extract(RValue<UShort8> val, int i)
{
RR_DEBUG_INFO_UPDATE_LOC();
return RValue<UShort>(Nucleus::createExtractElement(val.value, UShort::getType(), i));
return RValue<UShort>(Nucleus::createExtractElement(val.value, UShort::type(), i));
}
RValue<UShort8> Insert(RValue<UShort8> val, RValue<UShort> element, int i)
......@@ -3174,7 +3174,7 @@ RValue<UShort8> MulHigh(RValue<UShort8> x, RValue<UShort8> y)
return UShort8(0);
}
Type *UShort8::getType()
Type *UShort8::type()
{
return T(Ice::IceType_v8i16);
}
......@@ -3230,12 +3230,12 @@ RValue<Int> RoundInt(RValue<Float> cast)
}
}
Type *Int::getType()
Type *Int::type()
{
return T(Ice::IceType_i32);
}
Type *Long::getType()
Type *Long::type()
{
return T(Ice::IceType_i64);
}
......@@ -3293,21 +3293,21 @@ const UInt &operator--(UInt &val) // Pre-decrement
// ASSERT(false && "UNIMPLEMENTED"); return RValue<UInt>(V(nullptr));
// }
Type *UInt::getType()
Type *UInt::type()
{
return T(Ice::IceType_i32);
}
// Int2::Int2(RValue<Int> cast)
// {
// Value *extend = Nucleus::createZExt(cast.value, Long::getType());
// Value *vector = Nucleus::createBitCast(extend, Int2::getType());
// Value *extend = Nucleus::createZExt(cast.value, Long::type());
// Value *vector = Nucleus::createBitCast(extend, Int2::type());
//
// Constant *shuffle[2];
// shuffle[0] = Nucleus::createConstantInt(0);
// shuffle[1] = Nucleus::createConstantInt(0);
//
// Value *replicate = Nucleus::createShuffleVector(vector, UndefValue::get(Int2::getType()), Nucleus::createConstantVector(shuffle, 2));
// Value *replicate = Nucleus::createShuffleVector(vector, UndefValue::get(Int2::type()), Nucleus::createConstantVector(shuffle, 2));
//
// storeValue(replicate);
// }
......@@ -3346,7 +3346,7 @@ RValue<Int2> operator>>(RValue<Int2> lhs, unsigned char rhs)
}
}
Type *Int2::getType()
Type *Int2::type()
{
return T(Type_v2i32);
}
......@@ -3385,7 +3385,7 @@ RValue<UInt2> operator>>(RValue<UInt2> lhs, unsigned char rhs)
}
}
Type *UInt2::getType()
Type *UInt2::type()
{
return T(Type_v2i32);
}
......@@ -3394,19 +3394,19 @@ Int4::Int4(RValue<Byte4> cast)
: XYZW(this)
{
RR_DEBUG_INFO_UPDATE_LOC();
Value *x = Nucleus::createBitCast(cast.value, Int::getType());
Value *x = Nucleus::createBitCast(cast.value, Int::type());
Value *a = Nucleus::createInsertElement(loadValue(), x, 0);
Value *e;
int swizzle[16] = { 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23 };
Value *b = Nucleus::createBitCast(a, Byte16::getType());
Value *c = Nucleus::createShuffleVector(b, Nucleus::createNullValue(Byte16::getType()), swizzle);
Value *b = Nucleus::createBitCast(a, Byte16::type());
Value *c = Nucleus::createShuffleVector(b, Nucleus::createNullValue(Byte16::type()), swizzle);
int swizzle2[8] = { 0, 8, 1, 9, 2, 10, 3, 11 };
Value *d = Nucleus::createBitCast(c, Short8::getType());
e = Nucleus::createShuffleVector(d, Nucleus::createNullValue(Short8::getType()), swizzle2);
Value *d = Nucleus::createBitCast(c, Short8::type());
e = Nucleus::createShuffleVector(d, Nucleus::createNullValue(Short8::type()), swizzle2);
Value *f = Nucleus::createBitCast(e, Int4::getType());
Value *f = Nucleus::createBitCast(e, Int4::type());
storeValue(f);
}
......@@ -3414,15 +3414,15 @@ Int4::Int4(RValue<SByte4> cast)
: XYZW(this)
{
RR_DEBUG_INFO_UPDATE_LOC();
Value *x = Nucleus::createBitCast(cast.value, Int::getType());
Value *x = Nucleus::createBitCast(cast.value, Int::type());
Value *a = Nucleus::createInsertElement(loadValue(), x, 0);
int swizzle[16] = { 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7 };
Value *b = Nucleus::createBitCast(a, Byte16::getType());
Value *b = Nucleus::createBitCast(a, Byte16::type());
Value *c = Nucleus::createShuffleVector(b, b, swizzle);
int swizzle2[8] = { 0, 0, 1, 1, 2, 2, 3, 3 };
Value *d = Nucleus::createBitCast(c, Short8::getType());
Value *d = Nucleus::createBitCast(c, Short8::type());
Value *e = Nucleus::createShuffleVector(d, d, swizzle2);
*this = As<Int4>(e) >> 24;
......@@ -3444,7 +3444,7 @@ Int4::Int4(RValue<UShort4> cast)
RR_DEBUG_INFO_UPDATE_LOC();
int swizzle[8] = { 0, 8, 1, 9, 2, 10, 3, 11 };
Value *c = Nucleus::createShuffleVector(cast.value, Short8(0, 0, 0, 0, 0, 0, 0, 0).loadValue(), swizzle);
Value *d = Nucleus::createBitCast(c, Int4::getType());
Value *d = Nucleus::createBitCast(c, Int4::type());
storeValue(d);
}
......@@ -3452,7 +3452,7 @@ Int4::Int4(RValue<Int> rhs)
: XYZW(this)
{
RR_DEBUG_INFO_UPDATE_LOC();
Value *vector = Nucleus::createBitCast(rhs.value, Int4::getType());
Value *vector = Nucleus::createBitCast(rhs.value, Int4::type());
int swizzle[4] = { 0, 0, 0, 0 };
Value *replicate = Nucleus::createShuffleVector(vector, vector, swizzle);
......@@ -3662,7 +3662,7 @@ RValue<Int> SignMask(RValue<Int4> x)
}
}
Type *Int4::getType()
Type *Int4::type()
{
return T(Ice::IceType_v4i32);
}
......@@ -3689,7 +3689,7 @@ UInt4::UInt4(RValue<UInt> rhs)
: XYZW(this)
{
RR_DEBUG_INFO_UPDATE_LOC();
Value *vector = Nucleus::createBitCast(rhs.value, UInt4::getType());
Value *vector = Nucleus::createBitCast(rhs.value, UInt4::type());
int swizzle[4] = { 0, 0, 0, 0 };
Value *replicate = Nucleus::createShuffleVector(vector, vector, swizzle);
......@@ -3799,12 +3799,12 @@ RValue<UInt4> Min(RValue<UInt4> x, RValue<UInt4> y)
return RValue<UInt4>(V(result));
}
Type *UInt4::getType()
Type *UInt4::type()
{
return T(Ice::IceType_v4i32);
}
Type *Half::getType()
Type *Half::type()
{
return T(Ice::IceType_i16);
}
......@@ -3864,12 +3864,12 @@ RValue<Float> Ceil(RValue<Float> x)
return Float4(Ceil(Float4(x))).x;
}
Type *Float::getType()
Type *Float::type()
{
return T(Ice::IceType_f32);
}
Type *Float2::getType()
Type *Float2::type()
{
return T(Type_v2f32);
}
......@@ -3878,7 +3878,7 @@ Float4::Float4(RValue<Float> rhs)
: XYZW(this)
{
RR_DEBUG_INFO_UPDATE_LOC();
Value *vector = Nucleus::createBitCast(rhs.value, Float4::getType());
Value *vector = Nucleus::createBitCast(rhs.value, Float4::type());
int swizzle[4] = { 0, 0, 0, 0 };
Value *replicate = Nucleus::createShuffleVector(vector, vector, swizzle);
......@@ -4155,7 +4155,7 @@ RValue<Float4> Ceil(RValue<Float4> x)
}
}
Type *Float4::getType()
Type *Float4::type()
{
return T(Ice::IceType_v4f32);
}
......
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