[Beignet] [PATCH 2/2] GBE: Add some missing constant expression cases.
Zhigang Gong
zhigang.gong at linux.intel.com
Thu Dec 4 01:46:01 PST 2014
Please ignore this version, there is a typo. I already sent the version 2.
On Thu, Dec 04, 2014 at 05:22:00PM +0800, Zhigang Gong wrote:
> From: Zhigang Gong <zhigang.gong at linux.intel.com>
>
> Major for two types of constant expression cases:
> 1. The destination is a vector.
> 2. Some missing operators.
>
> Signed-off-by: Zhigang Gong <zhigang.gong at linux.intel.com>
> ---
> backend/src/ir/context.hpp | 4 +-
> backend/src/ir/immediate.cpp | 34 +++++++++++++++--
> backend/src/ir/immediate.hpp | 70 +++++++++++++++++++++++++++++++++--
> backend/src/llvm/llvm_gen_backend.cpp | 40 +++++++++++++++++++-
> 4 files changed, 136 insertions(+), 12 deletions(-)
>
> diff --git a/backend/src/ir/context.hpp b/backend/src/ir/context.hpp
> index 485d558..cf5109d 100644
> --- a/backend/src/ir/context.hpp
> +++ b/backend/src/ir/context.hpp
> @@ -74,11 +74,11 @@ namespace ir {
> return fn->newImmediate(imm);
> }
> /*! Create a new immediate value */
> - INLINE ImmediateIndex newImmediate(vector<ImmediateIndex>indexVector) {
> + INLINE ImmediateIndex newImmediate(vector<ImmediateIndex>indexVector, Type dstType) {
> vector<const Immediate*> immVector;
> for( uint32_t i = 0; i < indexVector.size(); i++)
> immVector.push_back(&fn->getImmediate(indexVector[i]));
> - const Immediate imm(immVector);
> + const Immediate imm(immVector, dstType);
> return fn->newImmediate(imm);
> }
> /*! Create an integer immediate value */
> diff --git a/backend/src/ir/immediate.cpp b/backend/src/ir/immediate.cpp
> index 7d26925..1aac9bc 100644
> --- a/backend/src/ir/immediate.cpp
> +++ b/backend/src/ir/immediate.cpp
> @@ -132,7 +132,7 @@ using namespace ir;
> }
>
> Immediate Immediate::less (const Immediate &left, const Immediate &right) {
> - GBE_ASSERT(left.getType() > TYPE_BOOL && left.getType() <= TYPE_U64);
> + GBE_ASSERT(left.getType() > TYPE_BOOL && left.getType() <= TYPE_DOUBLE);
> switch (left.getType()) {
> default:
> GBE_ASSERT(0);
> @@ -149,6 +149,30 @@ using namespace ir;
> }
> }
>
> + Immediate Immediate::extract (const Immediate &left, const Immediate &right, Type dstType) {
> + GBE_ASSERT(left.getType() > TYPE_BOOL && left.getType() <= TYPE_DOUBLE);
> + GBE_ASSERT(dstType == left.getType());
> + uint32_t index = right.getIntegerValue();
> + GBE_ASSERT(index >= 0 && index < left.getElemNum());
> + if (left.type != IMM_TYPE_COMP) {
> + switch (left.getType()) {
> + default:
> + GBE_ASSERT(0);
> + case TYPE_BOOL: return Immediate(left.data.b[index]);
> + case TYPE_S8: return Immediate(left.data.s8[index]);
> + case TYPE_U8: return Immediate(left.data.u8[index]);
> + case TYPE_S16: return Immediate(left.data.s16[index]);
> + case TYPE_U16: return Immediate(left.data.u16[index]);
> + case TYPE_S32: return Immediate(left.data.s32[index]);
> + case TYPE_U32: return Immediate(left.data.u32[index]);
> + case TYPE_S64: return Immediate(left.data.s64[index]);
> + case TYPE_U64: return Immediate(left.data.u64[index]);
> + case TYPE_FLOAT: return Immediate(left.data.f32[index]);
> + case TYPE_DOUBLE: return Immediate(left.data.f64[index]);
> + }
> + } else
> + return *left.data.immVec[index];
> + }
>
> Immediate::Immediate(ImmOpCode op, const Immediate &left, const Immediate &right, Type dstType) {
> switch (op) {
> @@ -180,7 +204,7 @@ using namespace ir;
> case IMM_LSHR:
> {
> if (left.getElemNum() == 1)
> - lshr(left, right);
> + *this = lshr(left, right);
> else {
> GBE_ASSERT(right.getIntegerValue() <= (left.getElemNum() * left.getTypeSize() * 8));
> GBE_ASSERT(right.getIntegerValue() % (left.getTypeSize() * 8) == 0);
> @@ -216,16 +240,17 @@ using namespace ir;
> case IMM_OLT: *this = less(left, right); break;
> case IMM_OGT: *this = left > right; break;
> case IMM_ORD: *this = (left == left) && (right == right); break;
> + case IMM_EXTRACT: *this = extract(left, right, dstType); break;
> }
> // If the dst type is large int, we will not change the imm type to large int.
> GBE_ASSERT(type == (ImmType)dstType || dstType == TYPE_LARGE_INT || dstType == TYPE_BOOL);
> }
>
> - Immediate::Immediate(const vector<const Immediate*> immVec) {
> + Immediate::Immediate(const vector<const Immediate*> immVec, Type dstType) {
> if (immVec.size() == 1) {
> *this = *immVec[0];
> } else if (!(immVec[0]->isCompType()) && immVec[0]->elemNum == 1) {
> - this->type = immVec[0]->type;
> + this->type = (ImmType)dstType;
> this->elemNum = immVec.size();
> if (immVec[0]->getTypeSize() * immVec.size() < 8)
> this->data.p = &this->defaultData;
> @@ -238,6 +263,7 @@ using namespace ir;
> p += immVec[i]->getTypeSize();
> }
> } else {
> + GBE_ASSERT(0);
> this->type = IMM_TYPE_COMP;
> if (immVec.size() * sizeof(Immediate*) < 8)
> this->data.p = &this->defaultData;
> diff --git a/backend/src/ir/immediate.hpp b/backend/src/ir/immediate.hpp
> index 1f18a4c..7b6ba34 100644
> --- a/backend/src/ir/immediate.hpp
> +++ b/backend/src/ir/immediate.hpp
> @@ -56,7 +56,11 @@ namespace ir {
> IMM_FPTOUI,
> IMM_FPTOSI,
> IMM_SITOFP,
> - IMM_UITOFP
> + IMM_UITOFP,
> + IMM_EXTRACT,
> + IMM_SEXT,
> + IMM_ZEXT,
> + IMM_FPEXT
> } ImmOpCode;
>
> typedef enum {
> @@ -158,7 +162,7 @@ namespace ir {
> DECL_CONSTRUCTOR(double, f64, TYPE_DOUBLE, elemNum)
> #undef DECL_CONSTRUCTOR
>
> - Immediate(const vector<const Immediate*> immVec);
> + Immediate(const vector<const Immediate*> immVec, Type dstType);
>
> INLINE int64_t getIntegerValue(void) const {
> switch (type) {
> @@ -176,6 +180,22 @@ namespace ir {
> }
> }
>
> + INLINE uint64_t getUnsignedIntegerValue(void) const {
> + switch (type) {
> + default:
> + GBE_ASSERT(0 && "Invalid immediate type.\n");
> + case TYPE_BOOL: return *data.b;
> + case TYPE_S8: return *data.s8;
> + case TYPE_U8: return *data.u8;
> + case TYPE_S16: return *data.s16;
> + case TYPE_U16: return *data.u16;
> + case TYPE_S32: return *data.s32;
> + case TYPE_U32: return *data.u32;
> + case TYPE_S64: return *data.s64;
> + case TYPE_U64: return *data.u64;
> + }
> + }
> +
> INLINE float getFloatValue(void) const {
> GBE_ASSERT(type == IMM_TYPE_FLOAT);
> return *data.f32;
> @@ -208,13 +228,54 @@ namespace ir {
> copy(other, 0, 1);
> break;
> case IMM_BITCAST:
> - *this = other;
> - type = (ImmType)dstType;
> + if (other.type != IMM_TYPE_COMP) {
> + *this = other;
> + type = (ImmType)dstType;
> + } else {
> + vector<const Immediate*> immVec;
> + for(uint32_t i = 0; i < other.getElemNum(); i++)
> + immVec.push_back(other.data.immVec[i]);
> + *this = Immediate(immVec, dstType);
> + }
> break;
> case IMM_FPTOUI: *this = Immediate((uint32_t)*other.data.f32); break;
> case IMM_FPTOSI: *this = Immediate((int32_t)*other.data.f32); break;
> case IMM_UITOFP: *this = Immediate((float)*other.data.u32); break;
> case IMM_SITOFP: *this = Immediate((float)*other.data.s32); break;
> + case IMM_SEXT:
> + {
> + int64_t value = other.getIntegerValue();
> + if (other.getType() == TYPE_BOOL)
> + value = -value;
> + switch (dstType) {
> + default:
> + GBE_ASSERT(0 && "Illegal sext constant expression");
> + case TYPE_S8: *this = Immediate((int8_t)value); break;
> + case TYPE_S16: *this = Immediate((int16_t)value); break;
> + case TYPE_S32: *this = Immediate((int32_t)value); break;
> + case TYPE_S64: *this = Immediate((int64_t)value); break;
> + }
> + }
> + case IMM_ZEXT:
> + {
> + uint64_t value = other.getUnsignedIntegerValue();
> + switch (dstType) {
> + default:
> + GBE_ASSERT(0 && "Illegal sext constant expression");
> + case TYPE_U8: *this = Immediate((uint8_t)value); break;
> + case TYPE_U16: *this = Immediate((uint16_t)value); break;
> + case TYPE_U32: *this = Immediate((uint32_t)value); break;
> + case TYPE_U64: *this = Immediate((uint64_t)value); break;
> + }
> + break;
> + }
> + case IMM_FPEXT:
> + {
> + GBE_ASSERT(other.getType() == TYPE_FLOAT && dstType == TYPE_DOUBLE);
> + double value = other.getFloatValue();
> + *this = Immediate(value);
> + break;
> + }
> }
> }
>
> @@ -265,6 +326,7 @@ namespace ir {
> Immediate operator>> (const Immediate &) const;
> static Immediate lshr (const Immediate &left, const Immediate &right);
> static Immediate less (const Immediate &left, const Immediate &right);
> + static Immediate extract (const Immediate &left, const Immediate &right, Type dstType);
>
> void copy(const Immediate &other, int32_t offset, uint32_t num);
> GBE_CLASS(Immediate);
> diff --git a/backend/src/llvm/llvm_gen_backend.cpp b/backend/src/llvm/llvm_gen_backend.cpp
> index c7ecc44..60ecc06 100644
> --- a/backend/src/llvm/llvm_gen_backend.cpp
> +++ b/backend/src/llvm/llvm_gen_backend.cpp
> @@ -902,7 +902,7 @@ namespace gbe
> vector<ir::ImmediateIndex> immVector;
> for (uint32_t i = 0; i < cv->getNumOperands(); i++)
> immVector.push_back(processConstantImmIndex(cv->getOperand(i)));
> - return ctx.newImmediate(immVector);
> + return ctx.newImmediate(immVector, getType(ctx, cv->getType()->getElementType()));
> }
> }
>
> @@ -1045,11 +1045,25 @@ namespace gbe
>
> if (dyn_cast<ConstantExpr>(CPV)) {
> ConstantExpr *ce = dyn_cast<ConstantExpr>(CPV);
> +
> + if (!isScalarType(ce->getType())) {
> + VectorType *vecType = cast<VectorType>(ce->getType());
> + GBE_ASSERT(ce->getOpcode() == Instruction::BitCast);
> + GBE_ASSERT(isScalarType(vecType->getElementType()));
> + ir::Type elemType = getType(ctx, vecType->getElementType());
> +
> + const ir::ImmediateIndex immIndex = processConstantImmIndex(ce->getOperand(0), -1);
> + const ir::Immediate imm = ctx.getImmediate(immIndex);
> + GBE_ASSERT(vecType->getNumElements() == imm.getElemNum() &&
> + getTypeByteSize(unit, vecType->getElementType()) == imm.getTypeSize());
> + return ctx.processImm(ir::IMM_BITCAST, immIndex, elemType);
> + }
> ir::Type type = getType(ctx, ce->getType());
> switch (ce->getOpcode()) {
> default:
> ce->dump();
> GBE_ASSERT(0 && "unsupported ce opcode.\n");
> + case Instruction::FPTrunc:
> case Instruction::Trunc:
> {
> const ir::ImmediateIndex immIndex = processConstantImmIndex(ce->getOperand(0), -1);
> @@ -1063,9 +1077,12 @@ namespace gbe
> return ctx.processImm(ir::IMM_BITCAST, immIndex, type);
> }
> case Instruction::FPToUI:
> - case Instruction::FPToSI:
> + case Insttruction::FPToSI:
> case Instruction::SIToFP:
> case Instruction::UIToFP:
> + case Instruction::SExt:
> + case Instruction::ZExt:
> + case Instruction::FPExt:
> {
> const ir::ImmediateIndex immIndex = processConstantImmIndex(ce->getOperand(0), -1);
> switch (ce->getOpcode()) {
> @@ -1075,15 +1092,26 @@ namespace gbe
> case Instruction::FPToSI: return ctx.processImm(ir::IMM_FPTOSI, immIndex, type);
> case Instruction::SIToFP: return ctx.processImm(ir::IMM_SITOFP, immIndex, type);
> case Instruction::UIToFP: return ctx.processImm(ir::IMM_UITOFP, immIndex, type);
> + case Instruction::SExt: return ctx.processImm(ir::IMM_SEXT, immIndex, type);
> + case Instruction::ZExt: return ctx.processImm(ir::IMM_ZEXT, immIndex, type);
> + case Instruction::FPExt: return ctx.processImm(ir::IMM_FPEXT, immIndex, type);
> }
> }
> +
> + case Instruction::ExtractElement:
> case Instruction::FCmp:
> case Instruction::ICmp:
> + case Instruction::FAdd:
> case Instruction::Add:
> case Instruction::Sub:
> + case Instruction::FSub:
> case Instruction::Mul:
> + case Instruction::FMul:
> case Instruction::SDiv:
> + case Instruction::UDiv:
> + case Instruction::FDiv:
> case Instruction::SRem:
> + case Instruction::FRem:
> case Instruction::Shl:
> case Instruction::AShr:
> case Instruction::LShr:
> @@ -1096,15 +1124,23 @@ namespace gbe
> default:
> //ce->dump();
> GBE_ASSERTM(0, "Unsupported constant expression.\n");
> +
> + case Instruction::ExtractElement:
> + return ctx.processImm(ir::IMM_EXTRACT, lhs, rhs, type);
> case Instruction::Add:
> + case Instruction::FAdd:
> return ctx.processImm(ir::IMM_ADD, lhs, rhs, type);
> + case Instruction::FSub:
> case Instruction::Sub:
> return ctx.processImm(ir::IMM_SUB, lhs, rhs, type);
> case Instruction::Mul:
> + case Instruction::FMul:
> return ctx.processImm(ir::IMM_MUL, lhs, rhs, type);
> case Instruction::SDiv:
> + case Instruction::FDiv:
> return ctx.processImm(ir::IMM_DIV, lhs, rhs, type);
> case Instruction::SRem:
> + case Instruction::FRem:
> return ctx.processImm(ir::IMM_REM, lhs, rhs, type);
> case Instruction::Shl:
> return ctx.processImm(ir::IMM_SHL, lhs, rhs, type);
> --
> 1.8.3.2
>
> _______________________________________________
> Beignet mailing list
> Beignet at lists.freedesktop.org
> http://lists.freedesktop.org/mailman/listinfo/beignet
More information about the Beignet
mailing list