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: Antonio Maiorano <amaiorano@google.com>
Tested-by: Nicolas Capens <nicolascapens@google.com>
Kokoro-Result: kokoro <noreply+kokoro@google.com>
diff --git a/src/Reactor/Coroutine.hpp b/src/Reactor/Coroutine.hpp
index cd8763c..05d9204 100644
--- a/src/Reactor/Coroutine.hpp
+++ b/src/Reactor/Coroutine.hpp
@@ -157,16 +157,16 @@
{
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>
diff --git a/src/Reactor/LLVMReactor.cpp b/src/Reactor/LLVMReactor.cpp
index 4d232bf..e76e653 100644
--- a/src/Reactor/LLVMReactor.cpp
+++ b/src/Reactor/LLVMReactor.cpp
@@ -537,12 +537,12 @@
// 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 @@
{
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 @@
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 @@
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 @@
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 @@
// 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 @@
// 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::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 @@
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 @@
#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 @@
//#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 @@
#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 @@
#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 @@
#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 @@
#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 @@
{
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 @@
#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 @@
#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 @@
#endif
}
-Type *UShort4::getType()
+Type *UShort4::type()
{
return T(Type_v4i16);
}
@@ -2258,9 +2258,9 @@
#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 @@
#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 @@
#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 @@
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 @@
//#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 @@
#endif
}
-Type *Int2::getType()
+Type *Int2::type()
{
return T(Type_v2i32);
}
@@ -2483,7 +2483,7 @@
#endif
}
-Type *UInt2::getType()
+Type *UInt2::type()
{
return T(Type_v2i32);
}
@@ -2501,12 +2501,12 @@
#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 @@
#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> 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 @@
#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 @@
#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> 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 @@
}
}
-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 @@
}
}
-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 @@
#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 @@
{
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 @@
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 @@
{
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> 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<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<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<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 @@
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 @@
// 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 @@
{
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 @@
{
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 @@
{
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> 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<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
diff --git a/src/Reactor/Reactor.cpp b/src/Reactor/Reactor.cpp
index dc8d960..de85b03 100644
--- a/src/Reactor/Reactor.cpp
+++ b/src/Reactor/Reactor.cpp
@@ -251,21 +251,21 @@
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(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(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(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 @@
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 @@
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 @@
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 @@
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(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<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(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 @@
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 @@
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(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<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 @@
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(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 @@
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 @@
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<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 @@
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<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(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 @@
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<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 @@
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<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 @@
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 @@
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 @@
: 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 @@
: 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 @@
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 @@
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> 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<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, 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 @@
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 @@
// 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 @@
// 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)
diff --git a/src/Reactor/Reactor.hpp b/src/Reactor/Reactor.hpp
index 9a99c30..f9b986d 100644
--- a/src/Reactor/Reactor.hpp
+++ b/src/Reactor/Reactor.hpp
@@ -90,12 +90,7 @@
class Void
{
public:
- static Type *getType();
-
- static bool isVoid()
- {
- return true;
- }
+ static Type *type();
};
template<class T>
@@ -150,11 +145,6 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
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 @@
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 @@
// 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 @@
public:
explicit Short2(RValue<Short4> cast);
- static Type *getType();
+ static Type *type();
};
class UShort2 : public LValue<UShort2>
@@ -817,7 +807,7 @@
public:
explicit UShort2(RValue<UShort4> cast);
- static Type *getType();
+ static Type *type();
};
class Short4 : public LValue<Short4>
@@ -845,7 +835,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
public:
explicit Half(RValue<Float> cast);
- static Type *getType();
+ static Type *type();
};
class Float : public LValue<Float>
@@ -2090,7 +2080,7 @@
static Float infinity();
- static Type *getType();
+ static Type *type();
};
RValue<Float> operator+(RValue<Float> lhs, RValue<Float> rhs);
@@ -2182,7 +2172,7 @@
// 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 @@
static Float4 infinity();
- static Type *getType();
+ static Type *type();
private:
void constant(float x, float y, float z, float w);
@@ -2376,7 +2366,7 @@
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 @@
: 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
{
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 @@
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 @@
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 @@
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 @@
{
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 @@
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()... });
}
};
diff --git a/src/Reactor/SubzeroReactor.cpp b/src/Reactor/SubzeroReactor.cpp
index 1a4a666..16ff015 100644
--- a/src/Reactor/SubzeroReactor.cpp
+++ b/src/Reactor/SubzeroReactor.cpp
@@ -165,7 +165,7 @@
{
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 @@
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> 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<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 @@
return RValue<Byte8>(Nucleus::createICmpEQ(x.value, y.value));
}
-Type *Byte8::getType()
+Type *Byte8::type()
{
return T(Type_v8i8);
}
@@ -2475,27 +2475,27 @@
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 @@
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 @@
return RValue<Short4>(Nucleus::createICmpEQ(x.value, y.value));
}
-Type *Short4::getType()
+Type *Short4::type()
{
return T(Type_v4i16);
}
@@ -2811,7 +2811,7 @@
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 @@
return UShort4(0);
}
-Type *UShort4::getType()
+Type *UShort4::type()
{
return T(Type_v4i16);
}
@@ -3035,7 +3035,7 @@
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 @@
return Short8(0);
}
-Type *Short8::getType()
+Type *Short8::type()
{
return T(Ice::IceType_v8i16);
}
@@ -3112,7 +3112,7 @@
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 @@
return UShort8(0);
}
-Type *UShort8::getType()
+Type *UShort8::type()
{
return T(Ice::IceType_v8i16);
}
@@ -3230,12 +3230,12 @@
}
}
-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 @@
// 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 @@
}
}
-Type *Int2::getType()
+Type *Int2::type()
{
return T(Type_v2i32);
}
@@ -3385,7 +3385,7 @@
}
}
-Type *UInt2::getType()
+Type *UInt2::type()
{
return T(Type_v2i32);
}
@@ -3394,19 +3394,19 @@
: 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 @@
: 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 @@
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 @@
: 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 @@
}
}
-Type *Int4::getType()
+Type *Int4::type()
{
return T(Ice::IceType_v4i32);
}
@@ -3689,7 +3689,7 @@
: 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 @@
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 @@
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 @@
: 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 @@
}
}
-Type *Float4::getType()
+Type *Float4::type()
{
return T(Ice::IceType_v4f32);
}
