Skip to content

S
swiftshader
Commit 8be6c7bb by Nicolas Capens Committed by Nicolas Capens
Options

Emulate vector shift by immediate intrinsics.

Bug b/37496338 Change-Id: I01e4aaf49e86d9c2f11647a0e84bf1ee388a90cf Reviewed-on: https://swiftshader-review.googlesource.com/10931Tested-by: 's avatarNicolas Capens <nicolascapens@google.com> Reviewed-by: 's avatarAlexis Hétu <sugoi@google.com> Reviewed-by: 's avatarNicolas Capens <nicolascapens@google.com>
parent 070d9f4d
Showing with 270 additions and 8 deletions
src/Reactor/SubzeroReactor.cpp
...@@ -3249,13 +3249,39 @@ namespace sw ...@@ -3249,13 +3249,39 @@ namespace sw
RValue<Short4> operator<<(RValue<Short4> lhs, unsigned char rhs) RValue<Short4> operator<<(RValue<Short4> lhs, unsigned char rhs)
{ {
if(emulateIntrinsics)
{
Short4 result;
result = Insert(result, Extract(lhs, 0) << Short(rhs), 0);
result = Insert(result, Extract(lhs, 1) << Short(rhs), 1);
result = Insert(result, Extract(lhs, 2) << Short(rhs), 2);
result = Insert(result, Extract(lhs, 3) << Short(rhs), 3);
return result;
}
else
{
return RValue<Short4>(Nucleus::createShl(lhs.value, V(::context->getConstantInt32(rhs)))); return RValue<Short4>(Nucleus::createShl(lhs.value, V(::context->getConstantInt32(rhs))));
} }
}
RValue<Short4> operator>>(RValue<Short4> lhs, unsigned char rhs) RValue<Short4> operator>>(RValue<Short4> lhs, unsigned char rhs)
{ {
if(emulateIntrinsics)
{
Short4 result;
result = Insert(result, Extract(lhs, 0) >> Short(rhs), 0);
result = Insert(result, Extract(lhs, 1) >> Short(rhs), 1);
result = Insert(result, Extract(lhs, 2) >> Short(rhs), 2);
result = Insert(result, Extract(lhs, 3) >> Short(rhs), 3);
return result;
}
else
{
return RValue<Short4>(Nucleus::createAShr(lhs.value, V(::context->getConstantInt32(rhs)))); return RValue<Short4>(Nucleus::createAShr(lhs.value, V(::context->getConstantInt32(rhs))));
} }
}
RValue<Short4> operator+=(Short4 &lhs, RValue<Short4> rhs) RValue<Short4> operator+=(Short4 &lhs, RValue<Short4> rhs)
{ {
...@@ -3622,15 +3648,51 @@ namespace sw ...@@ -3622,15 +3648,51 @@ namespace sw
return RValue<UShort4>(Nucleus::createXor(lhs.value, rhs.value)); return RValue<UShort4>(Nucleus::createXor(lhs.value, rhs.value));
} }
RValue<UShort> Extract(RValue<UShort4> val, int i)
{
return RValue<UShort>(Nucleus::createExtractElement(val.value, UShort::getType(), i));
}
RValue<UShort4> Insert(RValue<UShort4> val, RValue<UShort> element, int i)
{
return RValue<UShort4>(Nucleus::createInsertElement(val.value, element.value, i));
}
RValue<UShort4> operator<<(RValue<UShort4> lhs, unsigned char rhs) RValue<UShort4> operator<<(RValue<UShort4> lhs, unsigned char rhs)
{ {
if(emulateIntrinsics)
{
UShort4 result;
result = Insert(result, Extract(lhs, 0) << UShort(rhs), 0);
result = Insert(result, Extract(lhs, 1) << UShort(rhs), 1);
result = Insert(result, Extract(lhs, 2) << UShort(rhs), 2);
result = Insert(result, Extract(lhs, 3) << UShort(rhs), 3);
return result;
}
else
{
return RValue<UShort4>(Nucleus::createShl(lhs.value, V(::context->getConstantInt32(rhs)))); return RValue<UShort4>(Nucleus::createShl(lhs.value, V(::context->getConstantInt32(rhs))));
} }
}
RValue<UShort4> operator>>(RValue<UShort4> lhs, unsigned char rhs) RValue<UShort4> operator>>(RValue<UShort4> lhs, unsigned char rhs)
{ {
if(emulateIntrinsics)
{
UShort4 result;
result = Insert(result, Extract(lhs, 0) >> UShort(rhs), 0);
result = Insert(result, Extract(lhs, 1) >> UShort(rhs), 1);
result = Insert(result, Extract(lhs, 2) >> UShort(rhs), 2);
result = Insert(result, Extract(lhs, 3) >> UShort(rhs), 3);
return result;
}
else
{
return RValue<UShort4>(Nucleus::createLShr(lhs.value, V(::context->getConstantInt32(rhs)))); return RValue<UShort4>(Nucleus::createLShr(lhs.value, V(::context->getConstantInt32(rhs))));
} }
}
RValue<UShort4> operator<<=(UShort4 &lhs, unsigned char rhs) RValue<UShort4> operator<<=(UShort4 &lhs, unsigned char rhs)
{ {
...@@ -3776,15 +3838,59 @@ namespace sw ...@@ -3776,15 +3838,59 @@ namespace sw
return RValue<Short8>(Nucleus::createAnd(lhs.value, rhs.value)); return RValue<Short8>(Nucleus::createAnd(lhs.value, rhs.value));
} }
RValue<Short> Extract(RValue<Short8> val, int i)
{
return RValue<Short>(Nucleus::createExtractElement(val.value, Short::getType(), i));
}
RValue<Short8> Insert(RValue<Short8> val, RValue<Short> element, int i)
{
return RValue<Short8>(Nucleus::createInsertElement(val.value, element.value, i));
}
RValue<Short8> operator<<(RValue<Short8> lhs, unsigned char rhs) RValue<Short8> operator<<(RValue<Short8> lhs, unsigned char rhs)
{ {
if(emulateIntrinsics)
{
Short8 result;
result = Insert(result, Extract(lhs, 0) << Short(rhs), 0);
result = Insert(result, Extract(lhs, 1) << Short(rhs), 1);
result = Insert(result, Extract(lhs, 2) << Short(rhs), 2);
result = Insert(result, Extract(lhs, 3) << Short(rhs), 3);
result = Insert(result, Extract(lhs, 4) << Short(rhs), 4);
result = Insert(result, Extract(lhs, 5) << Short(rhs), 5);
result = Insert(result, Extract(lhs, 6) << Short(rhs), 6);
result = Insert(result, Extract(lhs, 7) << Short(rhs), 7);
return result;
}
else
{
return RValue<Short8>(Nucleus::createShl(lhs.value, V(::context->getConstantInt32(rhs)))); return RValue<Short8>(Nucleus::createShl(lhs.value, V(::context->getConstantInt32(rhs))));
} }
}
RValue<Short8> operator>>(RValue<Short8> lhs, unsigned char rhs) RValue<Short8> operator>>(RValue<Short8> lhs, unsigned char rhs)
{ {
if(emulateIntrinsics)
{
Short8 result;
result = Insert(result, Extract(lhs, 0) >> Short(rhs), 0);
result = Insert(result, Extract(lhs, 1) >> Short(rhs), 1);
result = Insert(result, Extract(lhs, 2) >> Short(rhs), 2);
result = Insert(result, Extract(lhs, 3) >> Short(rhs), 3);
result = Insert(result, Extract(lhs, 4) >> Short(rhs), 4);
result = Insert(result, Extract(lhs, 5) >> Short(rhs), 5);
result = Insert(result, Extract(lhs, 6) >> Short(rhs), 6);
result = Insert(result, Extract(lhs, 7) >> Short(rhs), 7);
return result;
}
else
{
return RValue<Short8>(Nucleus::createAShr(lhs.value, V(::context->getConstantInt32(rhs)))); return RValue<Short8>(Nucleus::createAShr(lhs.value, V(::context->getConstantInt32(rhs))));
} }
}
RValue<Int4> MulAdd(RValue<Short8> x, RValue<Short8> y) RValue<Int4> MulAdd(RValue<Short8> x, RValue<Short8> y)
{ {
...@@ -3866,15 +3972,59 @@ namespace sw ...@@ -3866,15 +3972,59 @@ namespace sw
return RValue<UShort8>(Nucleus::createAnd(lhs.value, rhs.value)); return RValue<UShort8>(Nucleus::createAnd(lhs.value, rhs.value));
} }
RValue<UShort> Extract(RValue<UShort8> val, int i)
{
return RValue<UShort>(Nucleus::createExtractElement(val.value, UShort::getType(), i));
}
RValue<UShort8> Insert(RValue<UShort8> val, RValue<UShort> element, int i)
{
return RValue<UShort8>(Nucleus::createInsertElement(val.value, element.value, i));
}
RValue<UShort8> operator<<(RValue<UShort8> lhs, unsigned char rhs) RValue<UShort8> operator<<(RValue<UShort8> lhs, unsigned char rhs)
{ {
if(emulateIntrinsics)
{
UShort8 result;
result = Insert(result, Extract(lhs, 0) << UShort(rhs), 0);
result = Insert(result, Extract(lhs, 1) << UShort(rhs), 1);
result = Insert(result, Extract(lhs, 2) << UShort(rhs), 2);
result = Insert(result, Extract(lhs, 3) << UShort(rhs), 3);
result = Insert(result, Extract(lhs, 4) << UShort(rhs), 4);
result = Insert(result, Extract(lhs, 5) << UShort(rhs), 5);
result = Insert(result, Extract(lhs, 6) << UShort(rhs), 6);
result = Insert(result, Extract(lhs, 7) << UShort(rhs), 7);
return result;
}
else
{
return RValue<UShort8>(Nucleus::createShl(lhs.value, V(::context->getConstantInt32(rhs)))); return RValue<UShort8>(Nucleus::createShl(lhs.value, V(::context->getConstantInt32(rhs))));
} }
}
RValue<UShort8> operator>>(RValue<UShort8> lhs, unsigned char rhs) RValue<UShort8> operator>>(RValue<UShort8> lhs, unsigned char rhs)
{ {
if(emulateIntrinsics)
{
UShort8 result;
result = Insert(result, Extract(lhs, 0) >> UShort(rhs), 0);
result = Insert(result, Extract(lhs, 1) >> UShort(rhs), 1);
result = Insert(result, Extract(lhs, 2) >> UShort(rhs), 2);
result = Insert(result, Extract(lhs, 3) >> UShort(rhs), 3);
result = Insert(result, Extract(lhs, 4) >> UShort(rhs), 4);
result = Insert(result, Extract(lhs, 5) >> UShort(rhs), 5);
result = Insert(result, Extract(lhs, 6) >> UShort(rhs), 6);
result = Insert(result, Extract(lhs, 7) >> UShort(rhs), 7);
return result;
}
else
{
return RValue<UShort8>(Nucleus::createLShr(lhs.value, V(::context->getConstantInt32(rhs)))); return RValue<UShort8>(Nucleus::createLShr(lhs.value, V(::context->getConstantInt32(rhs))));
} }
}
RValue<UShort8> operator+(RValue<UShort8> lhs, RValue<UShort8> rhs) RValue<UShort8> operator+(RValue<UShort8> lhs, RValue<UShort8> rhs)
{ {
...@@ -4788,13 +4938,35 @@ namespace sw ...@@ -4788,13 +4938,35 @@ namespace sw
RValue<Int2> operator<<(RValue<Int2> lhs, unsigned char rhs) RValue<Int2> operator<<(RValue<Int2> lhs, unsigned char rhs)
{ {
if(emulateIntrinsics)
{
Int2 result;
result = Insert(result, Extract(lhs, 0) << Int(rhs), 0);
result = Insert(result, Extract(lhs, 1) << Int(rhs), 1);
return result;
}
else
{
return RValue<Int2>(Nucleus::createShl(lhs.value, V(::context->getConstantInt32(rhs)))); return RValue<Int2>(Nucleus::createShl(lhs.value, V(::context->getConstantInt32(rhs))));
} }
}
RValue<Int2> operator>>(RValue<Int2> lhs, unsigned char rhs) RValue<Int2> operator>>(RValue<Int2> lhs, unsigned char rhs)
{ {
if(emulateIntrinsics)
{
Int2 result;
result = Insert(result, Extract(lhs, 0) >> Int(rhs), 0);
result = Insert(result, Extract(lhs, 1) >> Int(rhs), 1);
return result;
}
else
{
return RValue<Int2>(Nucleus::createAShr(lhs.value, V(::context->getConstantInt32(rhs)))); return RValue<Int2>(Nucleus::createAShr(lhs.value, V(::context->getConstantInt32(rhs))));
} }
}
RValue<Int2> operator+=(Int2 &lhs, RValue<Int2> rhs) RValue<Int2> operator+=(Int2 &lhs, RValue<Int2> rhs)
{ {
...@@ -4975,15 +5147,47 @@ namespace sw ...@@ -4975,15 +5147,47 @@ namespace sw
return RValue<UInt2>(Nucleus::createXor(lhs.value, rhs.value)); return RValue<UInt2>(Nucleus::createXor(lhs.value, rhs.value));
} }
RValue<UInt> Extract(RValue<UInt2> val, int i)
{
return RValue<UInt>(Nucleus::createExtractElement(val.value, UInt::getType(), i));
}
RValue<UInt2> Insert(RValue<UInt2> val, RValue<UInt> element, int i)
{
return RValue<UInt2>(Nucleus::createInsertElement(val.value, element.value, i));
}
RValue<UInt2> operator<<(RValue<UInt2> lhs, unsigned char rhs) RValue<UInt2> operator<<(RValue<UInt2> lhs, unsigned char rhs)
{ {
if(emulateIntrinsics)
{
UInt2 result;
result = Insert(result, Extract(lhs, 0) << UInt(rhs), 0);
result = Insert(result, Extract(lhs, 1) << UInt(rhs), 1);
return result;
}
else
{
return RValue<UInt2>(Nucleus::createShl(lhs.value, V(::context->getConstantInt32(rhs)))); return RValue<UInt2>(Nucleus::createShl(lhs.value, V(::context->getConstantInt32(rhs))));
} }
}
RValue<UInt2> operator>>(RValue<UInt2> lhs, unsigned char rhs) RValue<UInt2> operator>>(RValue<UInt2> lhs, unsigned char rhs)
{ {
if(emulateIntrinsics)
{
UInt2 result;
result = Insert(result, Extract(lhs, 0) >> UInt(rhs), 0);
result = Insert(result, Extract(lhs, 1) >> UInt(rhs), 1);
return result;
}
else
{
return RValue<UInt2>(Nucleus::createLShr(lhs.value, V(::context->getConstantInt32(rhs)))); return RValue<UInt2>(Nucleus::createLShr(lhs.value, V(::context->getConstantInt32(rhs))));
} }
}
RValue<UInt2> operator+=(UInt2 &lhs, RValue<UInt2> rhs) RValue<UInt2> operator+=(UInt2 &lhs, RValue<UInt2> rhs)
{ {
...@@ -5078,18 +5282,15 @@ namespace sw ...@@ -5078,18 +5282,15 @@ namespace sw
Value *x = Nucleus::createBitCast(cast.value, Int::getType()); Value *x = Nucleus::createBitCast(cast.value, Int::getType());
Value *a = Nucleus::createInsertElement(loadValue(), x, 0); Value *a = Nucleus::createInsertElement(loadValue(), x, 0);
Value *e;
int swizzle[16] = {0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7}; 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::getType());
Value *c = Nucleus::createShuffleVector(b, b, swizzle); Value *c = Nucleus::createShuffleVector(b, b, swizzle);
int swizzle2[8] = {0, 0, 1, 1, 2, 2, 3, 3}; int swizzle2[8] = {0, 0, 1, 1, 2, 2, 3, 3};
Value *d = Nucleus::createBitCast(c, Short8::getType()); Value *d = Nucleus::createBitCast(c, Short8::getType());
e = Nucleus::createShuffleVector(d, d, swizzle2); Value *e = Nucleus::createShuffleVector(d, d, swizzle2);
Value *f = Nucleus::createBitCast(e, Int4::getType()); *this = As<Int4>(e) >> 24;
Value *g = Nucleus::createAShr(f, V(::context->getConstantInt32(24)));
storeValue(g);
} }
Int4::Int4(RValue<Float4> cast) Int4::Int4(RValue<Float4> cast)
...@@ -5103,9 +5304,8 @@ namespace sw ...@@ -5103,9 +5304,8 @@ namespace sw
{ {
int swizzle[8] = {0, 0, 1, 1, 2, 2, 3, 3}; int swizzle[8] = {0, 0, 1, 1, 2, 2, 3, 3};
Value *c = Nucleus::createShuffleVector(cast.value, cast.value, swizzle); Value *c = Nucleus::createShuffleVector(cast.value, cast.value, swizzle);
Value *d = Nucleus::createBitCast(c, Int4::getType());
Value *e = Nucleus::createAShr(d, V(::context->getConstantInt32(16))); *this = As<Int4>(c) >> 16;
storeValue(e);
} }
Int4::Int4(RValue<UShort4> cast) Int4::Int4(RValue<UShort4> cast)
...@@ -5269,13 +5469,39 @@ namespace sw ...@@ -5269,13 +5469,39 @@ namespace sw
RValue<Int4> operator<<(RValue<Int4> lhs, unsigned char rhs) RValue<Int4> operator<<(RValue<Int4> lhs, unsigned char rhs)
{ {
if(emulateIntrinsics)
{
Int4 result;
result = Insert(result, Extract(lhs, 0) << Int(rhs), 0);
result = Insert(result, Extract(lhs, 1) << Int(rhs), 1);
result = Insert(result, Extract(lhs, 2) << Int(rhs), 2);
result = Insert(result, Extract(lhs, 3) << Int(rhs), 3);
return result;
}
else
{
return RValue<Int4>(Nucleus::createShl(lhs.value, V(::context->getConstantInt32(rhs)))); return RValue<Int4>(Nucleus::createShl(lhs.value, V(::context->getConstantInt32(rhs))));
} }
}
RValue<Int4> operator>>(RValue<Int4> lhs, unsigned char rhs) RValue<Int4> operator>>(RValue<Int4> lhs, unsigned char rhs)
{ {
if(emulateIntrinsics)
{
Int4 result;
result = Insert(result, Extract(lhs, 0) >> Int(rhs), 0);
result = Insert(result, Extract(lhs, 1) >> Int(rhs), 1);
result = Insert(result, Extract(lhs, 2) >> Int(rhs), 2);
result = Insert(result, Extract(lhs, 3) >> Int(rhs), 3);
return result;
}
else
{
return RValue<Int4>(Nucleus::createAShr(lhs.value, V(::context->getConstantInt32(rhs)))); return RValue<Int4>(Nucleus::createAShr(lhs.value, V(::context->getConstantInt32(rhs))));
} }
}
RValue<Int4> operator<<(RValue<Int4> lhs, RValue<Int4> rhs) RValue<Int4> operator<<(RValue<Int4> lhs, RValue<Int4> rhs)
{ {
...@@ -5620,15 +5846,51 @@ namespace sw ...@@ -5620,15 +5846,51 @@ namespace sw
return RValue<UInt4>(Nucleus::createXor(lhs.value, rhs.value)); return RValue<UInt4>(Nucleus::createXor(lhs.value, rhs.value));
} }
RValue<UInt> Extract(RValue<UInt4> x, int i)
{
return RValue<UInt>(Nucleus::createExtractElement(x.value, UInt::getType(), i));
}
RValue<UInt4> Insert(RValue<UInt4> x, RValue<UInt> element, int i)
{
return RValue<UInt4>(Nucleus::createInsertElement(x.value, element.value, i));
}
RValue<UInt4> operator<<(RValue<UInt4> lhs, unsigned char rhs) RValue<UInt4> operator<<(RValue<UInt4> lhs, unsigned char rhs)
{ {
if(emulateIntrinsics)
{
UInt4 result;
result = Insert(result, Extract(lhs, 0) << UInt(rhs), 0);
result = Insert(result, Extract(lhs, 1) << UInt(rhs), 1);
result = Insert(result, Extract(lhs, 2) << UInt(rhs), 2);
result = Insert(result, Extract(lhs, 3) << UInt(rhs), 3);
return result;
}
else
{
return RValue<UInt4>(Nucleus::createShl(lhs.value, V(::context->getConstantInt32(rhs)))); return RValue<UInt4>(Nucleus::createShl(lhs.value, V(::context->getConstantInt32(rhs))));
} }
}
RValue<UInt4> operator>>(RValue<UInt4> lhs, unsigned char rhs) RValue<UInt4> operator>>(RValue<UInt4> lhs, unsigned char rhs)
{ {
if(emulateIntrinsics)
{
UInt4 result;
result = Insert(result, Extract(lhs, 0) >> UInt(rhs), 0);
result = Insert(result, Extract(lhs, 1) >> UInt(rhs), 1);
result = Insert(result, Extract(lhs, 2) >> UInt(rhs), 2);
result = Insert(result, Extract(lhs, 3) >> UInt(rhs), 3);
return result;
}
else
{
return RValue<UInt4>(Nucleus::createLShr(lhs.value, V(::context->getConstantInt32(rhs)))); return RValue<UInt4>(Nucleus::createLShr(lhs.value, V(::context->getConstantInt32(rhs))));
} }
}
RValue<UInt4> operator<<(RValue<UInt4> lhs, RValue<UInt4> rhs) RValue<UInt4> operator<<(RValue<UInt4> lhs, RValue<UInt4> rhs)
{ {
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment