[Beignet] [PATCH] GBE: remove constant expression handling code in gen writer pass.
Zhigang Gong
zhigang.gong at intel.com
Thu Feb 26 20:03:38 PST 2015
All the constant expressions should be expanded in prior to
gen writer pass.
Signed-off-by: Zhigang Gong <zhigang.gong at intel.com>
---
backend/src/llvm/llvm_gen_backend.cpp | 214 +---------------------------------
1 file changed, 1 insertion(+), 213 deletions(-)
diff --git a/backend/src/llvm/llvm_gen_backend.cpp b/backend/src/llvm/llvm_gen_backend.cpp
index de846cb..42b905a 100644
--- a/backend/src/llvm/llvm_gen_backend.cpp
+++ b/backend/src/llvm/llvm_gen_backend.cpp
@@ -570,8 +570,6 @@ namespace gbe
INLINE void newRegister(Value *value, Value *key = NULL, bool uniform = false);
/*! get the register for a llvm::Constant */
ir::Register getConstantRegister(Constant *c, uint32_t index = 0);
- /*! get constant pointer */
- ir::Register getConstantPointerRegister(ConstantExpr *ce, uint32_t index = 0);
/*! Return a valid register from an operand (can use LOADI to make one) */
INLINE ir::Register getRegister(Value *value, uint32_t index = 0);
/*! Create a new immediate from a constant */
@@ -1042,150 +1040,7 @@ namespace gbe
ir::ImmediateIndex GenWriter::processConstantImmIndex(Constant *CPV, int32_t index) {
if (dyn_cast<ConstantExpr>(CPV) == NULL)
return processConstantImmIndexImpl(CPV, index);
-
- 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);
- return ctx.processImm(ir::IMM_TRUNC, immIndex, type);
- }
- case Instruction::BitCast:
- {
- const ir::ImmediateIndex immIndex = processConstantImmIndex(ce->getOperand(0), -1);
- if (type == ir::TYPE_LARGE_INT)
- return immIndex;
- return ctx.processImm(ir::IMM_BITCAST, immIndex, type);
- }
- case Instruction::FPToUI:
- case Instruction::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()) {
- default:
- GBE_ASSERT(0);
- case Instruction::FPToUI: return ctx.processImm(ir::IMM_FPTOUI, immIndex, type);
- 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:
- case Instruction::And:
- case Instruction::Or:
- case Instruction::Xor: {
- const ir::ImmediateIndex lhs = processConstantImmIndex(ce->getOperand(0), -1);
- const ir::ImmediateIndex rhs = processConstantImmIndex(ce->getOperand(1), -1);
- switch (ce->getOpcode()) {
- 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);
- case Instruction::AShr:
- return ctx.processImm(ir::IMM_ASHR, lhs, rhs, type);
- case Instruction::LShr:
- return ctx.processImm(ir::IMM_LSHR, lhs, rhs, type);
- case Instruction::And:
- return ctx.processImm(ir::IMM_AND, lhs, rhs, type);
- case Instruction::Or:
- return ctx.processImm(ir::IMM_OR, lhs, rhs, type);
- case Instruction::Xor:
- return ctx.processImm(ir::IMM_XOR, lhs, rhs, type);
- case Instruction::FCmp:
- case Instruction::ICmp:
- switch (ce->getPredicate()) {
- default:
- NOT_SUPPORTED;
- case ICmpInst::ICMP_EQ:
- case ICmpInst::FCMP_OEQ: return ctx.processImm(ir::IMM_OEQ, lhs, rhs, type);
- case ICmpInst::ICMP_NE:
- case ICmpInst::FCMP_ONE: return ctx.processImm(ir::IMM_ONE, lhs, rhs, type);
- case ICmpInst::ICMP_ULE:
- case ICmpInst::ICMP_SLE:
- case ICmpInst::FCMP_OLE: return ctx.processImm(ir::IMM_OLE, lhs, rhs, type);
- case ICmpInst::ICMP_UGE:
- case ICmpInst::ICMP_SGE:
- case ICmpInst::FCMP_OGE: return ctx.processImm(ir::IMM_OGE, lhs, rhs, type);
- case ICmpInst::ICMP_ULT:
- case ICmpInst::ICMP_SLT:
- case ICmpInst::FCMP_OLT: return ctx.processImm(ir::IMM_OLT, lhs, rhs, type);
- case ICmpInst::ICMP_UGT:
- case ICmpInst::ICMP_SGT:
- case ICmpInst::FCMP_OGT: return ctx.processImm(ir::IMM_OGT, lhs, rhs, type);
- case ICmpInst::FCMP_ORD: return ctx.processImm(ir::IMM_ORD, lhs, rhs, type);
- case ICmpInst::FCMP_TRUE:
- Value *cv = ConstantInt::get(ce->getType(), 1);
- return ctx.newImmediate(cv);
- }
- break;
- }
- break;
- }
- }
- }
+ CPV->dump();
GBE_ASSERT(0 && "unsupported constant.\n");
return ctx.newImmediate((uint32_t)0);
}
@@ -1229,64 +1084,6 @@ namespace gbe
};
}
- ir::Register GenWriter::getConstantPointerRegister(ConstantExpr *expr, uint32_t elemID) {
- Value* val = expr->getOperand(0);
-
- if (expr->isCast()) {
- ir::Register pointer_reg;
- if(isa<ConstantExpr>(val)) {
- // try to get the real pointer register, for case like:
- // store i64 ptrtoint (i8 addrspace(3)* getelementptr inbounds ...
- // in which ptrtoint and getelementptr are ConstantExpr.
- pointer_reg = getConstantPointerRegister(dyn_cast<ConstantExpr>(val), elemID);
- } else {
- pointer_reg = regTranslator.getScalar(val, elemID);
- }
- // if ptrToInt request another type other than 32bit, convert as requested
- ir::Type dstType = getType(ctx, expr->getType());
- ir::Type srcType = getType(ctx, val->getType());
- if(srcType != dstType && dstType != ir::TYPE_S32) {
- ir::Register tmp = ctx.reg(getFamily(dstType));
- ctx.CVT(dstType, srcType, tmp, pointer_reg);
- return tmp;
- }
- return pointer_reg;
- }
- else if (expr->getOpcode() == Instruction::GetElementPtr) {
- uint32_t constantOffset = 0;
-
- Value *pointer = val;
- CompositeType* CompTy = cast<CompositeType>(pointer->getType());
- for(uint32_t op=1; op<expr->getNumOperands(); ++op) {
- int32_t TypeIndex;
- ConstantInt* ConstOP = dyn_cast<ConstantInt>(expr->getOperand(op));
- if (ConstOP == NULL)
- goto error;
- TypeIndex = ConstOP->getZExtValue();
- GBE_ASSERT(TypeIndex >= 0);
- constantOffset += getGEPConstOffset(unit, CompTy, TypeIndex);
- CompTy = dyn_cast<CompositeType>(CompTy->getTypeAtIndex(TypeIndex));
- }
-
- ir::Register pointer_reg;
- if(isa<ConstantExpr>(pointer))
- pointer_reg = getConstantPointerRegister(dyn_cast<ConstantExpr>(pointer), elemID);
- else
- pointer_reg = regTranslator.getScalar(pointer, elemID);
-
- ir::Register offset_reg = ctx.reg(ir::RegisterFamily::FAMILY_DWORD);
- ctx.LOADI(ir::Type::TYPE_S32, offset_reg, ctx.newIntegerImmediate(constantOffset, ir::Type::TYPE_S32));
- ir::Register reg = ctx.reg(ir::RegisterFamily::FAMILY_DWORD);
- ctx.ADD(ir::Type::TYPE_S32, reg, pointer_reg, offset_reg);
- return reg;
- }
-
-error:
- expr->dump();
- GBE_ASSERT(0 && "Unsupported constant expression");
- return regTranslator.getScalar(val, elemID);
- }
-
ir::Register GenWriter::getConstantRegister(Constant *c, uint32_t elemID) {
GBE_ASSERT(c != NULL);
if(isa<GlobalValue>(c)) {
@@ -1309,15 +1106,6 @@ error:
return reg;
}
- if(isa<ConstantExpr>(c)) {
- // Check whether this is a constant drived from a pointer.
- Constant *itC = c;
- while(isa<ConstantExpr>(itC))
- itC = dyn_cast<ConstantExpr>(itC)->getOperand(0);
- if (itC->getType()->isPointerTy())
- return getConstantPointerRegister(dyn_cast<ConstantExpr>(c), elemID);
- }
-
const ir::ImmediateIndex immIndex = this->newImmediate(c, elemID);
const ir::Immediate imm = ctx.getImmediate(immIndex);
const ir::Register reg = ctx.reg(getFamily(imm.getType()));
--
1.9.1
More information about the Beignet
mailing list