Mesa (master): swr/rast: SIMD16 builder - cleanup naming (simd2 -> simd16)
Tim Rowley
torowley at kemper.freedesktop.org
Wed Jan 10 15:44:59 UTC 2018
Module: Mesa
Branch: master
Commit: e14b48e00e56b59de4bb916be994756295d7b685
URL: http://cgit.freedesktop.org/mesa/mesa/commit/?id=e14b48e00e56b59de4bb916be994756295d7b685
Author: Tim Rowley <timothy.o.rowley at intel.com>
Date: Tue Dec 19 13:39:09 2017 -0600
swr/rast: SIMD16 builder - cleanup naming (simd2 -> simd16)
Reviewed-by: Bruce Cherniak <bruce.cherniak at intel.com>
---
.../drivers/swr/rasterizer/jitter/builder.cpp | 76 +++++-----
.../drivers/swr/rasterizer/jitter/builder.h | 45 +++---
.../drivers/swr/rasterizer/jitter/builder_misc.cpp | 133 ++++++++--------
.../drivers/swr/rasterizer/jitter/builder_misc.h | 50 +++---
.../drivers/swr/rasterizer/jitter/fetch_jit.cpp | 168 +++++++++++----------
5 files changed, 239 insertions(+), 233 deletions(-)
diff --git a/src/gallium/drivers/swr/rasterizer/jitter/builder.cpp b/src/gallium/drivers/swr/rasterizer/jitter/builder.cpp
index 4b83a3204c..c46159a35a 100644
--- a/src/gallium/drivers/swr/rasterizer/jitter/builder.cpp
+++ b/src/gallium/drivers/swr/rasterizer/jitter/builder.cpp
@@ -40,52 +40,56 @@ namespace SwrJit
Builder::Builder(JitManager *pJitMgr)
: mpJitMgr(pJitMgr)
{
+ SWR_ASSERT(pJitMgr->mVWidth == 8);
+
mVWidth = pJitMgr->mVWidth;
-#if USE_SIMD16_BUILDER
- mVWidth2 = pJitMgr->mVWidth * 2;
-#endif
+ mVWidth16 = pJitMgr->mVWidth * 2;
mpIRBuilder = &pJitMgr->mBuilder;
- mVoidTy = Type::getVoidTy(pJitMgr->mContext);
- mFP16Ty = Type::getHalfTy(pJitMgr->mContext);
- mFP32Ty = Type::getFloatTy(pJitMgr->mContext);
- mFP32PtrTy = PointerType::get(mFP32Ty, 0);
- mDoubleTy = Type::getDoubleTy(pJitMgr->mContext);
- mInt1Ty = Type::getInt1Ty(pJitMgr->mContext);
- mInt8Ty = Type::getInt8Ty(pJitMgr->mContext);
- mInt16Ty = Type::getInt16Ty(pJitMgr->mContext);
- mInt32Ty = Type::getInt32Ty(pJitMgr->mContext);
- mInt8PtrTy = PointerType::get(mInt8Ty, 0);
+ // Built in types: scalar
+
+ mVoidTy = Type::getVoidTy(pJitMgr->mContext);
+ mFP16Ty = Type::getHalfTy(pJitMgr->mContext);
+ mFP32Ty = Type::getFloatTy(pJitMgr->mContext);
+ mFP32PtrTy = PointerType::get(mFP32Ty, 0);
+ mDoubleTy = Type::getDoubleTy(pJitMgr->mContext);
+ mInt1Ty = Type::getInt1Ty(pJitMgr->mContext);
+ mInt8Ty = Type::getInt8Ty(pJitMgr->mContext);
+ mInt16Ty = Type::getInt16Ty(pJitMgr->mContext);
+ mInt32Ty = Type::getInt32Ty(pJitMgr->mContext);
+ mInt8PtrTy = PointerType::get(mInt8Ty, 0);
mInt16PtrTy = PointerType::get(mInt16Ty, 0);
mInt32PtrTy = PointerType::get(mInt32Ty, 0);
- mInt64Ty = Type::getInt64Ty(pJitMgr->mContext);
- mSimdInt1Ty = VectorType::get(mInt1Ty, mVWidth);
- mSimdInt16Ty = VectorType::get(mInt16Ty, mVWidth);
- mSimdInt32Ty = VectorType::get(mInt32Ty, mVWidth);
- mSimdInt64Ty = VectorType::get(mInt64Ty, mVWidth);
- mSimdFP16Ty = VectorType::get(mFP16Ty, mVWidth);
- mSimdFP32Ty = VectorType::get(mFP32Ty, mVWidth);
- mSimdVectorTy = ArrayType::get(mSimdFP32Ty, 4);
+ mInt64Ty = Type::getInt64Ty(pJitMgr->mContext);
+
+ // Built in types: simd8
+
+ mSimdInt1Ty = VectorType::get(mInt1Ty, mVWidth);
+ mSimdInt16Ty = VectorType::get(mInt16Ty, mVWidth);
+ mSimdInt32Ty = VectorType::get(mInt32Ty, mVWidth);
+ mSimdInt64Ty = VectorType::get(mInt64Ty, mVWidth);
+ mSimdFP16Ty = VectorType::get(mFP16Ty, mVWidth);
+ mSimdFP32Ty = VectorType::get(mFP32Ty, mVWidth);
+ mSimdVectorTy = ArrayType::get(mSimdFP32Ty, 4);
mSimdVectorTRTy = ArrayType::get(mSimdFP32Ty, 5);
-#if USE_SIMD16_BUILDER
- mSimd2Int1Ty = VectorType::get(mInt1Ty, mVWidth2);
- mSimd2Int16Ty = VectorType::get(mInt16Ty, mVWidth2);
- mSimd2Int32Ty = VectorType::get(mInt32Ty, mVWidth2);
- mSimd2Int64Ty = VectorType::get(mInt64Ty, mVWidth2);
- mSimd2FP16Ty = VectorType::get(mFP16Ty, mVWidth2);
- mSimd2FP32Ty = VectorType::get(mFP32Ty, mVWidth2);
- mSimd2VectorTy = ArrayType::get(mSimd2FP32Ty, 4);
- mSimd2VectorTRTy = ArrayType::get(mSimd2FP32Ty, 5);
-#endif
+
+ // Built in types: simd16
+
+ mSimd16Int1Ty = VectorType::get(mInt1Ty, mVWidth16);
+ mSimd16Int16Ty = VectorType::get(mInt16Ty, mVWidth16);
+ mSimd16Int32Ty = VectorType::get(mInt32Ty, mVWidth16);
+ mSimd16Int64Ty = VectorType::get(mInt64Ty, mVWidth16);
+ mSimd16FP16Ty = VectorType::get(mFP16Ty, mVWidth16);
+ mSimd16FP32Ty = VectorType::get(mFP32Ty, mVWidth16);
+ mSimd16VectorTy = ArrayType::get(mSimd16FP32Ty, 4);
+ mSimd16VectorTRTy = ArrayType::get(mSimd16FP32Ty, 5);
if (sizeof(uint32_t*) == 4)
{
mIntPtrTy = mInt32Ty;
mSimdIntPtrTy = mSimdInt32Ty;
-#if USE_SIMD16_BUILDER
- mSimd2IntPtrTy = mSimd2Int32Ty;
-#endif
+ mSimd16IntPtrTy = mSimd16Int32Ty;
}
else
{
@@ -93,9 +97,7 @@ namespace SwrJit
mIntPtrTy = mInt64Ty;
mSimdIntPtrTy = mSimdInt64Ty;
-#if USE_SIMD16_BUILDER
- mSimd2IntPtrTy = mSimd2Int64Ty;
-#endif
+ mSimd16IntPtrTy = mSimd16Int64Ty;
}
}
}
diff --git a/src/gallium/drivers/swr/rasterizer/jitter/builder.h b/src/gallium/drivers/swr/rasterizer/jitter/builder.h
index c6ab64e06e..288c5d9ecd 100644
--- a/src/gallium/drivers/swr/rasterizer/jitter/builder.h
+++ b/src/gallium/drivers/swr/rasterizer/jitter/builder.h
@@ -32,26 +32,23 @@
#include "JitManager.h"
#include "common/formats.h"
-#define USE_SIMD16_BUILDER 0
-
namespace SwrJit
{
using namespace llvm;
struct Builder
{
Builder(JitManager *pJitMgr);
- IRBuilder<>* IRB() { return mpIRBuilder; };
- JitManager* JM() { return mpJitMgr; }
+ IRBuilder<> *IRB() { return mpIRBuilder; };
+ JitManager *JM() { return mpJitMgr; }
+
+ JitManager *mpJitMgr;
+ IRBuilder<> *mpIRBuilder;
- JitManager* mpJitMgr;
- IRBuilder<>* mpIRBuilder;
+ uint32_t mVWidth; // vector width simd8
+ uint32_t mVWidth16; // vector width simd16
- uint32_t mVWidth;
-#if USE_SIMD16_BUILDER
- uint32_t mVWidth2;
-#endif
+ // Built in types: scalar
- // Built in types.
Type* mVoidTy;
Type* mInt1Ty;
Type* mInt8Ty;
@@ -66,6 +63,9 @@ namespace SwrJit
Type* mInt8PtrTy;
Type* mInt16PtrTy;
Type* mInt32PtrTy;
+
+ // Built in types: simd8
+
Type* mSimdFP16Ty;
Type* mSimdFP32Ty;
Type* mSimdInt1Ty;
@@ -75,17 +75,18 @@ namespace SwrJit
Type* mSimdIntPtrTy;
Type* mSimdVectorTy;
Type* mSimdVectorTRTy;
-#if USE_SIMD16_BUILDER
- Type* mSimd2FP16Ty;
- Type* mSimd2FP32Ty;
- Type* mSimd2Int1Ty;
- Type* mSimd2Int16Ty;
- Type* mSimd2Int32Ty;
- Type* mSimd2Int64Ty;
- Type* mSimd2IntPtrTy;
- Type* mSimd2VectorTy;
- Type* mSimd2VectorTRTy;
-#endif
+
+ // Built in types: simd16
+
+ Type* mSimd16FP16Ty;
+ Type* mSimd16FP32Ty;
+ Type* mSimd16Int1Ty;
+ Type* mSimd16Int16Ty;
+ Type* mSimd16Int32Ty;
+ Type* mSimd16Int64Ty;
+ Type* mSimd16IntPtrTy;
+ Type* mSimd16VectorTy;
+ Type* mSimd16VectorTRTy;
#include "gen_builder.hpp"
#include "gen_builder_x86.hpp"
diff --git a/src/gallium/drivers/swr/rasterizer/jitter/builder_misc.cpp b/src/gallium/drivers/swr/rasterizer/jitter/builder_misc.cpp
index 0774889af1..92b07a5bfc 100644
--- a/src/gallium/drivers/swr/rasterizer/jitter/builder_misc.cpp
+++ b/src/gallium/drivers/swr/rasterizer/jitter/builder_misc.cpp
@@ -196,56 +196,59 @@ namespace SwrJit
return ConstantVector::getSplat(mVWidth, cast<ConstantInt>(C(i)));
}
- Value *Builder::VIMMED1(uint32_t i)
+ Value *Builder::VIMMED1_16(int i)
{
- return ConstantVector::getSplat(mVWidth, cast<ConstantInt>(C(i)));
+ return ConstantVector::getSplat(mVWidth16, cast<ConstantInt>(C(i)));
}
- Value *Builder::VIMMED1(float i)
+ Value *Builder::VIMMED1(uint32_t i)
{
- return ConstantVector::getSplat(mVWidth, cast<ConstantFP>(C(i)));
+ return ConstantVector::getSplat(mVWidth, cast<ConstantInt>(C(i)));
}
- Value *Builder::VIMMED1(bool i)
+ Value *Builder::VIMMED1_16(uint32_t i)
{
- return ConstantVector::getSplat(mVWidth, cast<ConstantInt>(C(i)));
+ return ConstantVector::getSplat(mVWidth16, cast<ConstantInt>(C(i)));
}
-#if USE_SIMD16_BUILDER
- Value *Builder::VIMMED2_1(int i)
+ Value *Builder::VIMMED1(float i)
{
- return ConstantVector::getSplat(mVWidth2, cast<ConstantInt>(C(i)));
+ return ConstantVector::getSplat(mVWidth, cast<ConstantFP>(C(i)));
}
- Value *Builder::VIMMED2_1(uint32_t i)
+ Value *Builder::VIMMED1_16(float i)
{
- return ConstantVector::getSplat(mVWidth2, cast<ConstantInt>(C(i)));
+ return ConstantVector::getSplat(mVWidth16, cast<ConstantFP>(C(i)));
}
- Value *Builder::VIMMED2_1(float i)
+ Value *Builder::VIMMED1(bool i)
{
- return ConstantVector::getSplat(mVWidth2, cast<ConstantFP>(C(i)));
+ return ConstantVector::getSplat(mVWidth, cast<ConstantInt>(C(i)));
}
- Value *Builder::VIMMED2_1(bool i)
+ Value *Builder::VIMMED1_16(bool i)
{
- return ConstantVector::getSplat(mVWidth2, cast<ConstantInt>(C(i)));
+ return ConstantVector::getSplat(mVWidth16, cast<ConstantInt>(C(i)));
}
-#endif
Value *Builder::VUNDEF_IPTR()
{
return UndefValue::get(VectorType::get(mInt32PtrTy,mVWidth));
}
+ Value *Builder::VUNDEF(Type* t)
+ {
+ return UndefValue::get(VectorType::get(t, mVWidth));
+ }
+
Value *Builder::VUNDEF_I()
{
return UndefValue::get(VectorType::get(mInt32Ty, mVWidth));
}
- Value *Builder::VUNDEF(Type *ty, uint32_t size)
+ Value *Builder::VUNDEF_I_16()
{
- return UndefValue::get(VectorType::get(ty, size));
+ return UndefValue::get(VectorType::get(mInt32Ty, mVWidth16));
}
Value *Builder::VUNDEF_F()
@@ -253,21 +256,14 @@ namespace SwrJit
return UndefValue::get(VectorType::get(mFP32Ty, mVWidth));
}
-#if USE_SIMD16_BUILDER
- Value *Builder::VUNDEF2_F()
- {
- return UndefValue::get(VectorType::get(mFP32Ty, mVWidth2));
- }
-
- Value *Builder::VUNDEF2_I()
+ Value *Builder::VUNDEF_F_16()
{
- return UndefValue::get(VectorType::get(mInt32Ty, mVWidth2));
+ return UndefValue::get(VectorType::get(mFP32Ty, mVWidth16));
}
-#endif
- Value *Builder::VUNDEF(Type* t)
+ Value *Builder::VUNDEF(Type *ty, uint32_t size)
{
- return UndefValue::get(VectorType::get(t, mVWidth));
+ return UndefValue::get(VectorType::get(ty, size));
}
Value *Builder::VBROADCAST(Value *src)
@@ -281,8 +277,7 @@ namespace SwrJit
return VECTOR_SPLAT(mVWidth, src);
}
-#if USE_SIMD16_BUILDER
- Value *Builder::VBROADCAST2(Value *src)
+ Value *Builder::VBROADCAST_16(Value *src)
{
// check if src is already a vector
if (src->getType()->isVectorTy())
@@ -290,10 +285,9 @@ namespace SwrJit
return src;
}
- return VECTOR_SPLAT(mVWidth2, src);
+ return VECTOR_SPLAT(mVWidth16, src);
}
-#endif
uint32_t Builder::IMMED(Value* v)
{
SWR_ASSERT(isa<ConstantInt>(v));
@@ -632,18 +626,18 @@ namespace SwrJit
Value *val = LOAD(validAddress);
vGather = VINSERT(vGather,val,C(i));
}
+
STACKRESTORE(pStack);
}
return vGather;
}
-#if USE_SIMD16_BUILDER
Value *Builder::GATHERPS_16(Value *vSrc, Value *pBase, Value *vIndices, Value *vMask, uint8_t scale)
{
- Value *vGather = VUNDEF2_F();
+ Value *vGather = VUNDEF_F_16();
- // use avx512 gather instruction if available
+ // use AVX512F gather instruction if available
if (JM()->mArch.AVX512F())
{
// force mask to <N-bit Integer>, required by vgather2
@@ -653,25 +647,24 @@ namespace SwrJit
}
else
{
- Value *src0 = EXTRACT2(vSrc, 0);
- Value *src1 = EXTRACT2(vSrc, 1);
+ Value *src0 = EXTRACT_16(vSrc, 0);
+ Value *src1 = EXTRACT_16(vSrc, 1);
- Value *indices0 = EXTRACT2(vIndices, 0);
- Value *indices1 = EXTRACT2(vIndices, 1);
+ Value *indices0 = EXTRACT_16(vIndices, 0);
+ Value *indices1 = EXTRACT_16(vIndices, 1);
- Value *mask0 = EXTRACT2(vMask, 0);
- Value *mask1 = EXTRACT2(vMask, 1);
+ Value *mask0 = EXTRACT_16(vMask, 0);
+ Value *mask1 = EXTRACT_16(vMask, 1);
Value *gather0 = GATHERPS(src0, pBase, indices0, mask0, scale);
Value *gather1 = GATHERPS(src1, pBase, indices1, mask1, scale);
- vGather = JOIN2(gather0, gather1);
+ vGather = JOIN_16(gather0, gather1);
}
return vGather;
}
-#endif
//////////////////////////////////////////////////////////////////////////
/// @brief Generate a masked gather operation in LLVM IR. If not
/// supported on the underlying platform, emulate it with loads
@@ -718,15 +711,15 @@ namespace SwrJit
STACKRESTORE(pStack);
}
+
return vGather;
}
-#if USE_SIMD16_BUILDER
Value *Builder::GATHERDD_16(Value *vSrc, Value *pBase, Value *vIndices, Value *vMask, uint8_t scale)
{
- Value *vGather = VUNDEF2_F();
+ Value *vGather = VUNDEF_I_16();
- // use avx512 gather instruction if available
+ // use AVX512F gather instruction if available
if (JM()->mArch.AVX512F())
{
// force mask to <N-bit Integer>, required by vgather2
@@ -736,25 +729,24 @@ namespace SwrJit
}
else
{
- Value *src0 = EXTRACT2(vSrc, 0);
- Value *src1 = EXTRACT2(vSrc, 1);
+ Value *src0 = EXTRACT_16(vSrc, 0);
+ Value *src1 = EXTRACT_16(vSrc, 1);
- Value *indices0 = EXTRACT2(vIndices, 0);
- Value *indices1 = EXTRACT2(vIndices, 1);
+ Value *indices0 = EXTRACT_16(vIndices, 0);
+ Value *indices1 = EXTRACT_16(vIndices, 1);
- Value *mask0 = EXTRACT2(vMask, 0);
- Value *mask1 = EXTRACT2(vMask, 1);
+ Value *mask0 = EXTRACT_16(vMask, 0);
+ Value *mask1 = EXTRACT_16(vMask, 1);
Value *gather0 = GATHERDD(src0, pBase, indices0, mask0, scale);
Value *gather1 = GATHERDD(src1, pBase, indices1, mask1, scale);
- vGather = JOIN2(gather0, gather1);
+ vGather = JOIN_16(gather0, gather1);
}
return vGather;
}
-#endif
//////////////////////////////////////////////////////////////////////////
/// @brief Generate a masked gather operation in LLVM IR. If not
/// supported on the underlying platform, emulate it with loads
@@ -804,21 +796,22 @@ namespace SwrJit
return vGather;
}
-#if USE_SIMD16_BUILDER
- Value *Builder::EXTRACT2(Value *x, uint32_t imm)
+ Value *Builder::EXTRACT_16(Value *x, uint32_t imm)
{
if (imm == 0)
- return VSHUFFLE(x, UndefValue::get(x->getType()), {0, 1, 2, 3, 4, 5, 6, 7});
+ {
+ return VSHUFFLE(x, UndefValue::get(x->getType()), { 0, 1, 2, 3, 4, 5, 6, 7 });
+ }
else
- return VSHUFFLE(x, UndefValue::get(x->getType()), {8, 9, 10, 11, 12, 13, 14, 15});
+ {
+ return VSHUFFLE(x, UndefValue::get(x->getType()), { 8, 9, 10, 11, 12, 13, 14, 15 });
+ }
}
- Value *Builder::JOIN2(Value *a, Value *b)
+ Value *Builder::JOIN_16(Value *a, Value *b)
{
- return VSHUFFLE(a, b,
- {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15});
+ return VSHUFFLE(a, b, { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 });
}
-#endif
//////////////////////////////////////////////////////////////////////////
/// @brief convert x86 <N x float> mask to llvm <N x i1> mask
@@ -828,14 +821,12 @@ namespace SwrJit
return ICMP_SLT(src, VIMMED1(0));
}
-#if USE_SIMD16_BUILDER
- Value *Builder::MASK2(Value *vmask)
+ Value *Builder::MASK_16(Value *vmask)
{
- Value *src = BITCAST(vmask, mSimd2Int32Ty);
- return ICMP_SLT(src, VIMMED2_1(0));
+ Value *src = BITCAST(vmask, mSimd16Int32Ty);
+ return ICMP_SLT(src, VIMMED1_16(0));
}
-#endif
//////////////////////////////////////////////////////////////////////////
/// @brief convert llvm <N x i1> mask to x86 <N x i32> mask
Value *Builder::VMASK(Value *mask)
@@ -843,13 +834,11 @@ namespace SwrJit
return S_EXT(mask, mSimdInt32Ty);
}
-#if USE_SIMD16_BUILDER
- Value *Builder::VMASK2(Value *mask)
+ Value *Builder::VMASK_16(Value *mask)
{
- return S_EXT(mask, mSimd2Int32Ty);
+ return S_EXT(mask, mSimd16Int32Ty);
}
-#endif
//////////////////////////////////////////////////////////////////////////
/// @brief Generate a VPSHUFB operation in LLVM IR. If not
/// supported on the underlying platform, emulate it
diff --git a/src/gallium/drivers/swr/rasterizer/jitter/builder_misc.h b/src/gallium/drivers/swr/rasterizer/jitter/builder_misc.h
index 646ed0efb2..16ff693c6e 100644
--- a/src/gallium/drivers/swr/rasterizer/jitter/builder_misc.h
+++ b/src/gallium/drivers/swr/rasterizer/jitter/builder_misc.h
@@ -50,29 +50,34 @@ Constant *C(const std::initializer_list<Ty> &constList)
}
Constant *PRED(bool pred);
+
Value *VIMMED1(int i);
+Value *VIMMED1_16(int i);
+
Value *VIMMED1(uint32_t i);
+Value *VIMMED1_16(uint32_t i);
+
Value *VIMMED1(float i);
+Value *VIMMED1_16(float i);
+
Value *VIMMED1(bool i);
-#if USE_SIMD16_BUILDER
-Value *VIMMED2_1(int i);
-Value *VIMMED2_1(uint32_t i);
-Value *VIMMED2_1(float i);
-Value *VIMMED2_1(bool i);
-#endif
+Value *VIMMED1_16(bool i);
+
Value *VUNDEF(Type* t);
+
Value *VUNDEF_F();
+Value *VUNDEF_F_16();
+
Value *VUNDEF_I();
-#if USE_SIMD16_BUILDER
-Value *VUNDEF2_F();
-Value *VUNDEF2_I();
-#endif
+Value *VUNDEF_I_16();
+
Value *VUNDEF(Type* ty, uint32_t size);
+
Value *VUNDEF_IPTR();
+
Value *VBROADCAST(Value *src);
-#if USE_SIMD16_BUILDER
-Value *VBROADCAST2(Value *src);
-#endif
+Value *VBROADCAST_16(Value *src);
+
Value *VRCP(Value *va);
Value *VPLANEPS(Value* vA, Value* vB, Value* vC, Value* &vX, Value* &vY);
@@ -105,21 +110,18 @@ Value *VCMPPS_GT(Value* a, Value* b) { return VCMPPS(a, b, C((uint8_t)_CMP_GT
Value *VCMPPS_NOTNAN(Value* a, Value* b){ return VCMPPS(a, b, C((uint8_t)_CMP_ORD_Q)); }
Value *MASK(Value *vmask);
+Value *MASK_16(Value *vmask);
+
Value *VMASK(Value *mask);
-#if USE_SIMD16_BUILDER
-Value *MASK2(Value *vmask);
-Value *VMASK2(Value *mask);
-#endif
+Value *VMASK_16(Value *mask);
//////////////////////////////////////////////////////////////////////////
/// @brief functions that build IR to call x86 intrinsics directly, or
/// emulate them with other instructions if not available on the host
//////////////////////////////////////////////////////////////////////////
-#if USE_SIMD16_BUILDER
-Value *EXTRACT2(Value *x, uint32_t imm);
-Value *JOIN2(Value *a, Value *b);
-#endif
+Value *EXTRACT_16(Value *x, uint32_t imm);
+Value *JOIN_16(Value *a, Value *b);
Value *MASKLOADD(Value* src, Value* mask);
@@ -127,16 +129,14 @@ void Gather4(const SWR_FORMAT format, Value* pSrcBase, Value* byteOffsets,
Value* mask, Value* vGatherComponents[], bool bPackedOutput);
Value *GATHERPS(Value *src, Value *pBase, Value *indices, Value *mask, uint8_t scale = 1);
-#if USE_SIMD16_BUILDER
Value *GATHERPS_16(Value *src, Value *pBase, Value *indices, Value *mask, uint8_t scale = 1);
-#endif
+
void GATHER4PS(const SWR_FORMAT_INFO &info, Value* pSrcBase, Value* byteOffsets,
Value* mask, Value* vGatherComponents[], bool bPackedOutput);
Value *GATHERDD(Value* src, Value* pBase, Value* indices, Value* mask, uint8_t scale = 1);
-#if USE_SIMD16_BUILDER
Value *GATHERDD_16(Value *src, Value *pBase, Value *indices, Value *mask, uint8_t scale = 1);
-#endif
+
void GATHER4DD(const SWR_FORMAT_INFO &info, Value* pSrcBase, Value* byteOffsets,
Value* mask, Value* vGatherComponents[], bool bPackedOutput);
diff --git a/src/gallium/drivers/swr/rasterizer/jitter/fetch_jit.cpp b/src/gallium/drivers/swr/rasterizer/jitter/fetch_jit.cpp
index aa911b58f3..c7605046c3 100644
--- a/src/gallium/drivers/swr/rasterizer/jitter/fetch_jit.cpp
+++ b/src/gallium/drivers/swr/rasterizer/jitter/fetch_jit.cpp
@@ -49,6 +49,11 @@ enum ConversionType
CONVERT_SFIXED,
};
+#if USE_SIMD16_SHADERS
+#define USE_SIMD16_GATHERS 0
+#define USE_SIMD16_BUILDER 0
+#endif
+
//////////////////////////////////////////////////////////////////////////
/// Interface to Jitting a fetch shader
//////////////////////////////////////////////////////////////////////////
@@ -101,7 +106,6 @@ struct FetchJit : public Builder
void JitLoadVertices(const FETCH_COMPILE_STATE &fetchState, Value* streams, Value* vIndices, Value* pVtxOut);
#if USE_SIMD16_SHADERS
-#define USE_SIMD16_GATHERS 0
#if USE_SIMD16_GATHERS
void JitGatherVertices(const FETCH_COMPILE_STATE &fetchState, Value *streams, Value *vIndices, Value *vIndices2, Value *pVtxOut, bool useVertexID2);
@@ -150,7 +154,7 @@ Function* FetchJit::Create(const FETCH_COMPILE_STATE& fetchState)
pVtxOut = GEP(pVtxOut, C(0));
#if USE_SIMD16_SHADERS
#if 0// USE_SIMD16_BUILDER
- pVtxOut = BITCAST(pVtxOut, PointerType::get(VectorType::get(mFP32Ty, mVWidth2), 0));
+ pVtxOut = BITCAST(pVtxOut, PointerType::get(VectorType::get(mFP32Ty, mVWidth16), 0));
#else
pVtxOut = BITCAST(pVtxOut, PointerType::get(VectorType::get(mFP32Ty, mVWidth), 0));
#endif
@@ -841,7 +845,7 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
Value* curInstance = LOAD(mpFetchInfo, {0, SWR_FETCH_CONTEXT_CurInstance});
#if USE_SIMD16_GATHERS
#if USE_SIMD16_BUILDER
- Value* vBaseVertex16 = VBROADCAST2(LOAD(mpFetchInfo, { 0, SWR_FETCH_CONTEXT_BaseVertex }));
+ Value* vBaseVertex16 = VBROADCAST_16(LOAD(mpFetchInfo, { 0, SWR_FETCH_CONTEXT_BaseVertex }));
#else
Value* vBaseVertex = VBROADCAST(LOAD(mpFetchInfo, { 0, SWR_FETCH_CONTEXT_BaseVertex }));
#endif
@@ -872,7 +876,7 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
Value *stride = LOAD(streams, {ied.StreamIndex, SWR_VERTEX_BUFFER_STATE_pitch});
#if USE_SIMD16_GATHERS
#if USE_SIMD16_BUILDER
- Value *vStride16 = VBROADCAST2(stride);
+ Value *vStride16 = VBROADCAST_16(stride);
#else
Value *vStride = VBROADCAST(stride);
#endif
@@ -908,7 +912,7 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
Value *startOffset;
#if USE_SIMD16_GATHERS
#if USE_SIMD16_BUILDER
- Value *vInstanceStride16 = VIMMED2_1(0);
+ Value *vInstanceStride16 = VIMMED1_16(0);
#else
Value *vInstanceStride = VIMMED1(0);
#endif
@@ -932,7 +936,7 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
#if USE_SIMD16_GATHERS
#if USE_SIMD16_BUILDER
- vCurIndices16 = VBROADCAST2(calcInstance);
+ vCurIndices16 = VBROADCAST_16(calcInstance);
#else
vCurIndices = VBROADCAST(calcInstance);
vCurIndices2 = VBROADCAST(calcInstance);
@@ -949,7 +953,7 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
Value* stepRate = C(ied.InstanceAdvancementState);
#if USE_SIMD16_GATHERS
#if USE_SIMD16_BUILDER
- vInstanceStride16 = VBROADCAST2(MUL(curInstance, stepRate));
+ vInstanceStride16 = VBROADCAST_16(MUL(curInstance, stepRate));
#else
vInstanceStride = VBROADCAST(MUL(curInstance, stepRate));
#endif
@@ -960,7 +964,7 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
// offset indices by baseVertex
#if USE_SIMD16_GATHERS
#if USE_SIMD16_BUILDER
- Value *vIndices16 = JOIN2(vIndices, vIndices2);
+ Value *vIndices16 = JOIN_16(vIndices, vIndices2);
vCurIndices16 = ADD(vIndices16, vBaseVertex16);
#else
@@ -979,7 +983,7 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
// offset indices by baseVertex
#if USE_SIMD16_GATHERS
#if USE_SIMD16_BUILDER
- Value *vIndices16 = JOIN2(vIndices, vIndices2);
+ Value *vIndices16 = JOIN_16(vIndices, vIndices2);
vCurIndices16 = ADD(vIndices16, vBaseVertex16);
#else
@@ -1019,9 +1023,9 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
partialInboundsSize = LOAD(partialInboundsSize);
#if USE_SIMD16_GATHERS
#if USE_SIMD16_BUILDER
- Value *vPartialVertexSize = VBROADCAST2(partialInboundsSize);
- Value *vBpp = VBROADCAST2(C(info.Bpp));
- Value *vAlignmentOffsets = VBROADCAST2(C(ied.AlignedByteOffset));
+ Value *vPartialVertexSize = VBROADCAST_16(partialInboundsSize);
+ Value *vBpp = VBROADCAST_16(C(info.Bpp));
+ Value *vAlignmentOffsets = VBROADCAST_16(C(ied.AlignedByteOffset));
#else
Value *vPartialVertexSize = VBROADCAST(partialInboundsSize);
Value *vBpp = VBROADCAST(C(info.Bpp));
@@ -1039,11 +1043,11 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
#if USE_SIMD16_GATHERS
#if USE_SIMD16_BUILDER
// override cur indices with 0 if pitch is 0
- Value *pZeroPitchMask16 = ICMP_EQ(vStride16, VIMMED2_1(0));
- vCurIndices16 = SELECT(pZeroPitchMask16, VIMMED2_1(0), vCurIndices16);
+ Value *pZeroPitchMask16 = ICMP_EQ(vStride16, VIMMED1_16(0));
+ vCurIndices16 = SELECT(pZeroPitchMask16, VIMMED1_16(0), vCurIndices16);
// are vertices partially OOB?
- Value *vMaxVertex16 = VBROADCAST2(maxVertex);
+ Value *vMaxVertex16 = VBROADCAST_16(maxVertex);
Value *vPartialOOBMask = ICMP_EQ(vCurIndices16, vMaxVertex16);
// are vertices fully in bounds?
@@ -1054,7 +1058,7 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
if (fetchState.bPartialVertexBuffer)
{
// are vertices below minVertex limit?
- Value *vMinVertex16 = VBROADCAST2(minVertex);
+ Value *vMinVertex16 = VBROADCAST_16(minVertex);
Value *vMinGatherMask16 = ICMP_UGE(vCurIndices16, vMinVertex16);
// only fetch lanes that pass both tests
@@ -1079,11 +1083,11 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
// TODO: remove the following simd8 interop stuff once all code paths are fully widened to SIMD16..
- Value *vGatherMask = EXTRACT2(vGatherMask16, 0);
- Value *vGatherMask2 = EXTRACT2(vGatherMask16, 1);
+ Value *vGatherMask = EXTRACT_16(vGatherMask16, 0);
+ Value *vGatherMask2 = EXTRACT_16(vGatherMask16, 1);
- Value *vOffsets = EXTRACT2(vOffsets16, 0);
- Value *vOffsets2 = EXTRACT2(vOffsets16, 1);
+ Value *vOffsets = EXTRACT_16(vOffsets16, 0);
+ Value *vOffsets2 = EXTRACT_16(vOffsets16, 1);
#else
// override cur indices with 0 if pitch is 0
Value* pZeroPitchMask = ICMP_EQ(vStride, VIMMED1(0));
@@ -1198,7 +1202,7 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
{
#if USE_SIMD16_BUILDER
// pack adjacent pairs of SIMD8s into SIMD16s
- pVtxSrc2[currentVertexElement] = JOIN2(pResults[c], pResults2[c]);
+ pVtxSrc2[currentVertexElement] = JOIN_16(pResults[c], pResults2[c]);
#else
vVertexElements[currentVertexElement] = pResults[c];
@@ -1211,7 +1215,7 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
{
#if USE_SIMD16_BUILDER
// store SIMD16s
- Value *pVtxOut2 = BITCAST(pVtxOut, PointerType::get(VectorType::get(mFP32Ty, mVWidth2), 0));
+ Value *pVtxOut2 = BITCAST(pVtxOut, PointerType::get(VectorType::get(mFP32Ty, mVWidth16), 0));
StoreVertexElements2(pVtxOut2, outputElt, 4, pVtxSrc2);
@@ -1254,7 +1258,7 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
#if USE_SIMD16_GATHERS
Value *gatherSrc2 = VIMMED1(0.0f);
#if USE_SIMD16_BUILDER
- Value *gatherSrc16 = VIMMED2_1(0.0f);
+ Value *gatherSrc16 = VIMMED1_16(0.0f);
#endif
#endif
@@ -1282,7 +1286,7 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
}
else
{
- gatherResult[0] = VUNDEF2_I();
+ gatherResult[0] = VUNDEF_I_16();
}
// if we have at least one component out of z or w to fetch
@@ -1300,7 +1304,7 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
}
else
{
- gatherResult[1] = VUNDEF2_I();
+ gatherResult[1] = VUNDEF_I_16();
}
#else
@@ -1347,7 +1351,7 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
if (compMask)
{
#if USE_SIMD16_BUILDER
- Value *pVtxOut2 = BITCAST(pVtxOut, PointerType::get(VectorType::get(mFP32Ty, mVWidth2), 0));
+ Value *pVtxOut2 = BITCAST(pVtxOut, PointerType::get(VectorType::get(mFP32Ty, mVWidth16), 0));
Shuffle16bpcArgs args = std::forward_as_tuple(gatherResult, pVtxOut2, Instruction::CastOps::FPExt, CONVERT_NONE,
currentVertexElement, outputElt, compMask, compCtrl, pVtxSrc2);
@@ -1432,7 +1436,7 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
#if USE_SIMD16_BUILDER
// pack adjacent pairs of SIMD8s into SIMD16s
- pVtxSrc2[currentVertexElement] = JOIN2(vVertexElements[currentVertexElement],
+ pVtxSrc2[currentVertexElement] = JOIN_16(vVertexElements[currentVertexElement],
vVertexElements2[currentVertexElement]);
#endif
@@ -1449,7 +1453,7 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
#if USE_SIMD16_BUILDER
// pack adjacent pairs of SIMD8s into SIMD16s
- pVtxSrc2[currentVertexElement] = JOIN2(vVertexElements[currentVertexElement],
+ pVtxSrc2[currentVertexElement] = JOIN_16(vVertexElements[currentVertexElement],
vVertexElements2[currentVertexElement]);
#endif
@@ -1461,7 +1465,7 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
{
#if USE_SIMD16_BUILDER
// store SIMD16s
- Value *pVtxOut2 = BITCAST(pVtxOut, PointerType::get(VectorType::get(mFP32Ty, mVWidth2), 0));
+ Value *pVtxOut2 = BITCAST(pVtxOut, PointerType::get(VectorType::get(mFP32Ty, mVWidth16), 0));
StoreVertexElements2(pVtxOut2, outputElt, 4, pVtxSrc2);
@@ -1553,7 +1557,7 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
#if USE_SIMD16_BUILDER
// pack adjacent pairs of SIMD8s into SIMD16s
- pVtxSrc2[currentVertexElement] = JOIN2(pGather, pGather2);
+ pVtxSrc2[currentVertexElement] = JOIN_16(pGather, pGather2);
#else
vVertexElements[currentVertexElement] = pGather;
@@ -1579,7 +1583,7 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
{
#if USE_SIMD16_BUILDER
// store SIMD16s
- Value *pVtxOut2 = BITCAST(pVtxOut, PointerType::get(VectorType::get(mFP32Ty, mVWidth2), 0));
+ Value *pVtxOut2 = BITCAST(pVtxOut, PointerType::get(VectorType::get(mFP32Ty, mVWidth16), 0));
StoreVertexElements2(pVtxOut2, outputElt, 4, pVtxSrc2);
@@ -1692,7 +1696,7 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
#if USE_SIMD16_GATHERS
Value* gatherSrc2 = VIMMED1(0);
#if USE_SIMD16_BUILDER
- Value *gatherSrc16 = VIMMED2_1(0);
+ Value *gatherSrc16 = VIMMED1_16(0);
#endif
#endif
@@ -1722,7 +1726,7 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
#endif
#if USE_SIMD16_BUILDER
- Value *pVtxOut2 = BITCAST(pVtxOut, PointerType::get(VectorType::get(mFP32Ty, mVWidth2), 0));
+ Value *pVtxOut2 = BITCAST(pVtxOut, PointerType::get(VectorType::get(mFP32Ty, mVWidth16), 0));
Shuffle8bpcArgs args = std::forward_as_tuple(gatherResult, pVtxOut2, extendCastType, conversionType,
currentVertexElement, outputElt, compMask, compCtrl, pVtxSrc2, info.swizzle);
@@ -1776,7 +1780,7 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
}
else
{
- gatherResult[0] = VUNDEF2_I();
+ gatherResult[0] = VUNDEF_I_16();
}
// if we have at least one component out of z or w to fetch
@@ -1794,7 +1798,7 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
}
else
{
- gatherResult[1] = VUNDEF2_I();
+ gatherResult[1] = VUNDEF_I_16();
}
#else
@@ -1841,7 +1845,7 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
if (compMask)
{
#if USE_SIMD16_BUILDER
- Value *pVtxOut2 = BITCAST(pVtxOut, PointerType::get(VectorType::get(mFP32Ty, mVWidth2), 0));
+ Value *pVtxOut2 = BITCAST(pVtxOut, PointerType::get(VectorType::get(mFP32Ty, mVWidth16), 0));
Shuffle16bpcArgs args = std::forward_as_tuple(gatherResult, pVtxOut2, extendCastType, conversionType,
currentVertexElement, outputElt, compMask, compCtrl, pVtxSrc2);
@@ -1914,15 +1918,15 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
if (conversionType == CONVERT_USCALED)
{
- pGather = UI_TO_FP(pGather, mSimd2FP32Ty);
+ pGather = UI_TO_FP(pGather, mSimd16FP32Ty);
}
else if (conversionType == CONVERT_SSCALED)
{
- pGather = SI_TO_FP(pGather, mSimd2FP32Ty);
+ pGather = SI_TO_FP(pGather, mSimd16FP32Ty);
}
else if (conversionType == CONVERT_SFIXED)
{
- pGather = FMUL(SI_TO_FP(pGather, mSimd2FP32Ty), VBROADCAST2(C(1 / 65536.0f)));
+ pGather = FMUL(SI_TO_FP(pGather, mSimd16FP32Ty), VBROADCAST_16(C(1 / 65536.0f)));
}
#else
@@ -2008,7 +2012,7 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
#if USE_SIMD16_GATHERS
#if USE_SIMD16_BUILDER
// store SIMD16s
- Value *pVtxOut2 = BITCAST(pVtxOut, PointerType::get(VectorType::get(mFP32Ty, mVWidth2), 0));
+ Value *pVtxOut2 = BITCAST(pVtxOut, PointerType::get(VectorType::get(mFP32Ty, mVWidth16), 0));
StoreVertexElements2(pVtxOut2, outputElt, 4, pVtxSrc2);
@@ -2043,7 +2047,7 @@ void FetchJit::JitGatherVertices(const FETCH_COMPILE_STATE &fetchState,
#if USE_SIMD16_GATHERS
#if USE_SIMD16_BUILDER
// store SIMD16s
- Value *pVtxOut2 = BITCAST(pVtxOut, PointerType::get(VectorType::get(mFP32Ty, mVWidth2), 0));
+ Value *pVtxOut2 = BITCAST(pVtxOut, PointerType::get(VectorType::get(mFP32Ty, mVWidth16), 0));
StoreVertexElements2(pVtxOut2, outputElt, currentVertexElement, pVtxSrc2);
@@ -2320,8 +2324,8 @@ void FetchJit::Shuffle8bpcGatherd2(Shuffle8bpcArgs &args)
// SIMD16 PSHUFB isnt part of AVX-512F, so split into SIMD8 for the sake of KNL, for now..
- Value *vGatherResult_lo = EXTRACT2(vGatherResult, 0);
- Value *vGatherResult_hi = EXTRACT2(vGatherResult, 1);
+ Value *vGatherResult_lo = EXTRACT_16(vGatherResult, 0);
+ Value *vGatherResult_hi = EXTRACT_16(vGatherResult, 1);
Value *vShufResult_lo = BITCAST(PSHUFB(BITCAST(vGatherResult_lo, v32x8Ty), vConstMask), vGatherTy);
Value *vShufResult_hi = BITCAST(PSHUFB(BITCAST(vGatherResult_hi, v32x8Ty), vConstMask), vGatherTy);
@@ -2399,7 +2403,7 @@ void FetchJit::Shuffle8bpcGatherd2(Shuffle8bpcArgs &args)
temp_hi = FMUL(CAST(fpCast, temp_hi, mSimdFP32Ty), conversionFactor);
}
- vVertexElements[currentVertexElement] = JOIN2(temp_lo, temp_hi);
+ vVertexElements[currentVertexElement] = JOIN_16(temp_lo, temp_hi);
currentVertexElement += 1;
}
@@ -2480,8 +2484,8 @@ void FetchJit::Shuffle8bpcGatherd2(Shuffle8bpcArgs &args)
break;
}
- Value *vGatherResult_lo = EXTRACT2(vGatherResult, 0);
- Value *vGatherResult_hi = EXTRACT2(vGatherResult, 1);
+ Value *vGatherResult_lo = EXTRACT_16(vGatherResult, 0);
+ Value *vGatherResult_hi = EXTRACT_16(vGatherResult, 1);
Value *temp_lo = BITCAST(PSHUFB(BITCAST(vGatherResult_lo, v32x8Ty), vConstMask), vGatherTy);
Value *temp_hi = BITCAST(PSHUFB(BITCAST(vGatherResult_hi, v32x8Ty), vConstMask), vGatherTy);
@@ -2497,7 +2501,7 @@ void FetchJit::Shuffle8bpcGatherd2(Shuffle8bpcArgs &args)
temp_hi = FMUL(CAST(fpCast, temp_hi, mSimdFP32Ty), conversionFactor);
}
- vVertexElements[currentVertexElement] = JOIN2(temp_lo, temp_hi);
+ vVertexElements[currentVertexElement] = JOIN_16(temp_lo, temp_hi);
currentVertexElement += 1;
}
@@ -2785,8 +2789,8 @@ void FetchJit::Shuffle16bpcGather2(Shuffle16bpcArgs &args)
{
// SIMD16 PSHUFB isnt part of AVX-512F, so split into SIMD8 for the sake of KNL, for now..
- Value *vGatherResult_lo = EXTRACT2(vGatherResult[0], 0);
- Value *vGatherResult_hi = EXTRACT2(vGatherResult[0], 1);
+ Value *vGatherResult_lo = EXTRACT_16(vGatherResult[0], 0);
+ Value *vGatherResult_hi = EXTRACT_16(vGatherResult[0], 1);
Value *vShufResult_lo = BITCAST(PSHUFB(BITCAST(vGatherResult_lo, v32x8Ty), vConstMask), vGatherTy);
Value *vShufResult_hi = BITCAST(PSHUFB(BITCAST(vGatherResult_hi, v32x8Ty), vConstMask), vGatherTy);
@@ -2802,7 +2806,7 @@ void FetchJit::Shuffle16bpcGather2(Shuffle16bpcArgs &args)
// 256i - 0 1 2 3 4 5 6 7
// xxxx xxxx xxxx xxxx yyyy yyyy yyyy yyyy
#if 0
- vi128XY = JOIN2(vi128XY_lo, vi128XY_hi);
+ vi128XY = JOIN_16(vi128XY_lo, vi128XY_hi);
#endif
}
@@ -2812,8 +2816,8 @@ void FetchJit::Shuffle16bpcGather2(Shuffle16bpcArgs &args)
Value *vi128ZW_hi = nullptr;
if (isComponentEnabled(compMask, 2) || isComponentEnabled(compMask, 3))
{
- Value *vGatherResult_lo = EXTRACT2(vGatherResult[1], 0);
- Value *vGatherResult_hi = EXTRACT2(vGatherResult[1], 1);
+ Value *vGatherResult_lo = EXTRACT_16(vGatherResult[1], 0);
+ Value *vGatherResult_hi = EXTRACT_16(vGatherResult[1], 1);
Value *vShufResult_lo = BITCAST(PSHUFB(BITCAST(vGatherResult_lo, v32x8Ty), vConstMask), vGatherTy);
Value *vShufResult_hi = BITCAST(PSHUFB(BITCAST(vGatherResult_hi, v32x8Ty), vConstMask), vGatherTy);
@@ -2821,7 +2825,7 @@ void FetchJit::Shuffle16bpcGather2(Shuffle16bpcArgs &args)
vi128ZW_lo = BITCAST(PERMD(vShufResult_lo, C<int32_t>({ 0, 1, 4, 5, 2, 3, 6, 7 })), v128bitTy);
vi128ZW_hi = BITCAST(PERMD(vShufResult_hi, C<int32_t>({ 0, 1, 4, 5, 2, 3, 6, 7 })), v128bitTy);
#if 0
- vi128ZW = JOIN2(vi128ZW_lo, vi128ZW_hi);
+ vi128ZW = JOIN_16(vi128ZW_lo, vi128ZW_hi);
#endif
}
@@ -2868,7 +2872,7 @@ void FetchJit::Shuffle16bpcGather2(Shuffle16bpcArgs &args)
Value *temp_lo = CVTPH2PS(BITCAST(VEXTRACT(selectedPermute_lo, C(lane)), v8x16Ty));
Value *temp_hi = CVTPH2PS(BITCAST(VEXTRACT(selectedPermute_hi, C(lane)), v8x16Ty));
- vVertexElements[currentVertexElement] = JOIN2(temp_lo, temp_hi);
+ vVertexElements[currentVertexElement] = JOIN_16(temp_lo, temp_hi);
}
else
{
@@ -2883,7 +2887,7 @@ void FetchJit::Shuffle16bpcGather2(Shuffle16bpcArgs &args)
temp_hi = FMUL(CAST(IntToFpCast, temp_hi, mSimdFP32Ty), conversionFactor);
}
- vVertexElements[currentVertexElement] = JOIN2(temp_lo, temp_hi);
+ vVertexElements[currentVertexElement] = JOIN_16(temp_lo, temp_hi);
}
currentVertexElement += 1;
@@ -2960,8 +2964,8 @@ void FetchJit::Shuffle16bpcGather2(Shuffle16bpcArgs &args)
// SIMD16 PSHUFB isnt part of AVX-512F, so split into SIMD8 for the sake of KNL, for now..
- Value *vGatherResult_lo = EXTRACT2(vGatherResult[selectedGather], 0);
- Value *vGatherResult_hi = EXTRACT2(vGatherResult[selectedGather], 1);
+ Value *vGatherResult_lo = EXTRACT_16(vGatherResult[selectedGather], 0);
+ Value *vGatherResult_hi = EXTRACT_16(vGatherResult[selectedGather], 1);
Value *temp_lo = BITCAST(PSHUFB(BITCAST(vGatherResult_lo, v32x8Ty), vConstMask[selectedMask]), vGatherTy);
Value *temp_hi = BITCAST(PSHUFB(BITCAST(vGatherResult_hi, v32x8Ty), vConstMask[selectedMask]), vGatherTy);
@@ -2977,7 +2981,7 @@ void FetchJit::Shuffle16bpcGather2(Shuffle16bpcArgs &args)
temp_hi = FMUL(CAST(fpCast, temp_hi, mSimdFP32Ty), conversionFactor);
}
- vVertexElements[currentVertexElement] = JOIN2(temp_lo, temp_hi);
+ vVertexElements[currentVertexElement] = JOIN_16(temp_lo, temp_hi);
currentVertexElement += 1;
}
@@ -3052,7 +3056,7 @@ void FetchJit::StoreVertexElements2(Value* pVtxOut, const uint32_t outputElt, co
#if FETCH_DUMP_VERTEX
PRINT("vVertexElements[%d]: 0x%x\n", { C(c), vVertexElements[c] });
#endif
- vVertexElements[c] = BITCAST(vVertexElements[c], mSimd2FP32Ty);
+ vVertexElements[c] = BITCAST(vVertexElements[c], mSimd16FP32Ty);
}
#if FETCH_DUMP_VERTEX
else
@@ -3080,14 +3084,18 @@ Value* FetchJit::GenerateCompCtrlVector(const ComponentControl ctrl)
{
switch(ctrl)
{
- case NoStore: return VUNDEF_I();
- case Store0: return VIMMED1(0);
- case Store1Fp: return VIMMED1(1.0f);
- case Store1Int: return VIMMED1(1);
+ case NoStore:
+ return VUNDEF_I();
+ case Store0:
+ return VIMMED1(0);
+ case Store1Fp:
+ return VIMMED1(1.0f);
+ case Store1Int:
+ return VIMMED1(1);
case StoreVertexId:
{
#if USE_SIMD16_SHADERS
- Value* pId;
+ Value *pId;
if (useVertexID2)
{
pId = BITCAST(LOAD(GEP(mpFetchInfo, { 0, SWR_FETCH_CONTEXT_VertexID2 })), mSimdFP32Ty);
@@ -3097,17 +3105,18 @@ Value* FetchJit::GenerateCompCtrlVector(const ComponentControl ctrl)
pId = BITCAST(LOAD(GEP(mpFetchInfo, { 0, SWR_FETCH_CONTEXT_VertexID })), mSimdFP32Ty);
}
#else
- Value* pId = BITCAST(LOAD(GEP(mpFetchInfo, { 0, SWR_FETCH_CONTEXT_VertexID })), mSimdFP32Ty);
+ Value *pId = BITCAST(LOAD(GEP(mpFetchInfo, { 0, SWR_FETCH_CONTEXT_VertexID })), mSimdFP32Ty);
#endif
return pId;
}
case StoreInstanceId:
{
- Value* pId = BITCAST(LOAD(GEP(mpFetchInfo, { 0, SWR_FETCH_CONTEXT_CurInstance })), mFP32Ty);
+ Value *pId = BITCAST(LOAD(GEP(mpFetchInfo, { 0, SWR_FETCH_CONTEXT_CurInstance })), mFP32Ty);
return VBROADCAST(pId);
}
case StoreSrc:
- default: SWR_INVALID("Invalid component control"); return VUNDEF_I();
+ default:
+ SWR_INVALID("Invalid component control"); return VUNDEF_I();
}
}
@@ -3116,26 +3125,31 @@ Value* FetchJit::GenerateCompCtrlVector2(const ComponentControl ctrl)
{
switch (ctrl)
{
- case NoStore: return VUNDEF2_I();
- case Store0: return VIMMED2_1(0);
- case Store1Fp: return VIMMED2_1(1.0f);
- case Store1Int: return VIMMED2_1(1);
+ case NoStore:
+ return VUNDEF_I_16();
+ case Store0:
+ return VIMMED1_16(0);
+ case Store1Fp:
+ return VIMMED1_16(1.0f);
+ case Store1Int:
+ return VIMMED1_16(1);
case StoreVertexId:
{
- Value* pId_lo = BITCAST(LOAD(GEP(mpFetchInfo, { 0, SWR_FETCH_CONTEXT_VertexID })), mSimdFP32Ty);
- Value* pId_hi = BITCAST(LOAD(GEP(mpFetchInfo, { 0, SWR_FETCH_CONTEXT_VertexID2 })), mSimdFP32Ty);
+ Value *pId_lo = BITCAST(LOAD(GEP(mpFetchInfo, { 0, SWR_FETCH_CONTEXT_VertexID })), mSimdFP32Ty);
+ Value *pId_hi = BITCAST(LOAD(GEP(mpFetchInfo, { 0, SWR_FETCH_CONTEXT_VertexID2 })), mSimdFP32Ty);
- Value *pId = JOIN2(pId_lo, pId_hi);
+ Value *pId = JOIN_16(pId_lo, pId_hi);
return pId;
}
case StoreInstanceId:
{
- Value* pId = BITCAST(LOAD(GEP(mpFetchInfo, { 0, SWR_FETCH_CONTEXT_CurInstance })), mFP32Ty);
- return VBROADCAST2(pId);
+ Value *pId = BITCAST(LOAD(GEP(mpFetchInfo, { 0, SWR_FETCH_CONTEXT_CurInstance })), mFP32Ty);
+ return VBROADCAST_16(pId);
}
case StoreSrc:
- default: SWR_INVALID("Invalid component control"); return VUNDEF2_I();
+ default:
+ SWR_INVALID("Invalid component control"); return VUNDEF_I_16();
}
}
More information about the mesa-commit
mailing list