| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <ostream> |
| |
| #include "abcdbounds.h" |
| #include "constantfolder.h" |
| #include "opndmap.h" |
| #include "simplifier.h" |
| |
| namespace Jitrino { |
| |
| namespace { |
| bool hasTypeBounds(Type::Tag srcTag, int64 &lb, int64 &ub); |
| int numbitsInType(Type::Tag typetag); |
| } // namespace |
| |
| void AbcdReasons::print(::std::ostream &os) const |
| { |
| assert(facts.size() < 100); |
| StlSet<SsaTmpOpnd *>::const_iterator |
| iter = facts.begin(), |
| end = facts.end(); |
| if (iter != end) { |
| os << "{"; |
| { |
| SsaTmpOpnd *opnd = *iter; |
| opnd->print(os); |
| } |
| for (++iter ; iter != end; ++iter) { |
| SsaTmpOpnd *opnd = *iter; |
| os << " "; |
| opnd->print(os); |
| } |
| os << "}"; |
| } else { |
| os << "NoReasons"; |
| } |
| } |
| |
| PiBound PiBound::add(const PiBound &other, bool is_signed) const { |
| assert(typetag == other.typetag); |
| if (isUndefined()) return *this; |
| if (other.isUndefined()) return other; |
| if ((!isUnknown()) && (!other.isUnknown())) { |
| if (var_part.isEmpty() || other.var_part.isEmpty()) { |
| // if one or no variables, can add |
| ConstInst::ConstValue v1; |
| ConstInst::ConstValue v2; |
| ConstInst::ConstValue res; |
| v1.i8 = const_part; |
| v2.i8 = other.const_part; |
| if (ConstantFolder::foldConstant(typetag, Op_Add, v1, v2, res, is_signed)) { |
| int64 c = (numbitsInType(typetag)==64) ? res.i8 : ((int64)res.i4); |
| if (!var_part.isEmpty()) { |
| return PiBound(typetag, var_multiple, var_part, c); |
| } else if (!other.var_part.isEmpty()) { |
| return PiBound(typetag, other.var_multiple, other.var_part, c); |
| } else |
| return PiBound(typetag, c); |
| } |
| } else if ((!var_part.isEmpty()) && (!other.var_part.isEmpty()) |
| && (var_part == other.var_part)) { |
| // if variables are the same, can add |
| ConstInst::ConstValue v1; |
| ConstInst::ConstValue v2; |
| ConstInst::ConstValue res; |
| v1.i8 = const_part; |
| v2.i8 = other.const_part; |
| if (ConstantFolder::foldConstant(typetag, Op_Add, v1, v2, res, is_signed)) { |
| int64 c = (numbitsInType(typetag)==64) ? res.i8 : ((int64)res.i4); |
| v1.i8 = var_multiple; |
| v2.i8 = other.var_multiple; |
| if (ConstantFolder::foldConstant(typetag, Op_Add, v1, v2, res, is_signed)){ |
| int64 mult = ((numbitsInType(typetag)==64) |
| ? res.i8 |
| : ((int64)res.i4)); |
| return PiBound(typetag, mult, var_part, c); |
| } |
| } |
| } |
| } |
| return getUnknown(); |
| } |
| |
| PiBound PiBound::neg () const { |
| if (isUnknown() || isUndefined()) return *this; |
| ConstInst::ConstValue v1; |
| ConstInst::ConstValue res; |
| v1.i8 = const_part; |
| if (ConstantFolder::foldConstant(typetag, Op_Neg, v1, res)) { |
| int64 c = (numbitsInType(typetag)==64) ? res.i8 : ((int64)res.i4); |
| v1.i8 = var_multiple; |
| if (ConstantFolder::foldConstant(typetag, Op_Neg, v1, res)) { |
| int64 mult = ((numbitsInType(typetag)==64) |
| ? res.i8 |
| : ((int64)res.i4)); |
| return PiBound(typetag, mult, var_part, c); |
| } |
| } |
| return getUnknown(); |
| } |
| |
| PiBound PiBound::abs () const { |
| if (isUnknown() || isUndefined()) return *this; |
| if (var_multiple != 0) return getUnknown(); |
| if (const_part < 0) { |
| int64 newconst_part = -const_part; |
| if (newconst_part == const_part) { //overflow |
| return getUnknown(); |
| } |
| return PiBound(typetag, 0, 0, newconst_part); |
| } |
| return *this; |
| } |
| |
| PiBound PiBound::mul(const PiBound &other, bool is_signed) const { |
| assert(typetag == other.typetag); |
| if (isUndefined()) return other; |
| else if (other.isUndefined()) return *this; |
| else if ((!isUnknown()) && (!other.isUnknown())) { |
| if (var_part.isEmpty() && other.var_part.isEmpty()) { |
| // if no variables, can multiply |
| ConstInst::ConstValue v1; |
| ConstInst::ConstValue v2; |
| ConstInst::ConstValue res; |
| v1.i8 = const_part; |
| v2.i8 = other.const_part; |
| if (ConstantFolder::foldConstant(typetag, Op_Mul, v1, v2, res, is_signed)) { |
| int64 c = (numbitsInType(typetag)==64) ? res.i8 : ((int64)res.i4); |
| return PiBound(typetag, c); |
| } |
| } else if (var_part.isEmpty() != other.var_part.isEmpty()) { |
| // if only 1 variable, can multiply |
| ConstInst::ConstValue v1; |
| ConstInst::ConstValue v2; |
| ConstInst::ConstValue res; |
| v1.i8 = const_part; |
| v2.i8 = other.const_part; |
| if (ConstantFolder::foldConstant(typetag, Op_Mul, v1, v2, res, is_signed)) { |
| int64 c = (numbitsInType(typetag)==64) ? res.i8 : ((int64)res.i4); |
| v1.i8 = var_part.isEmpty() ? other.var_multiple : var_multiple; |
| v2.i8 = var_part.isEmpty() ? const_part : other.const_part; |
| if (ConstantFolder::foldConstant(typetag, Op_Mul, v1, v2, res, is_signed)){ |
| int64 mult = ((numbitsInType(typetag)==64) |
| ? res.i8 |
| : ((int64)res.i4)); |
| return PiBound(typetag, mult, var_part, c); |
| } |
| } |
| } |
| } |
| return getUnknown(); |
| } |
| |
| PiBound |
| PiBound::cast(Type::Tag newtype, bool isLb) const { |
| if (isUnknown()) return PiBound(newtype, true); |
| else if (isUndefined()) return PiBound(newtype, false); |
| else if (var_multiple == 0) { |
| int64 lb, ub; |
| if (hasTypeBounds(newtype, lb, ub)) { |
| if (isLb) { |
| return PiBound(newtype, var_multiple, var_part, |
| ::std::max(const_part, lb)); |
| } else { |
| return PiBound(newtype, var_multiple, var_part, |
| ::std::min(const_part, ub)); |
| } |
| } |
| } |
| return *this; |
| } |
| |
| bool |
| PiBound::isConstant() const |
| { |
| if (isUndefined()) return true; |
| if (isUnknown()) return false; |
| if (var_multiple != 0) return false; |
| return true; |
| } |
| |
| bool |
| PiBound::isNonNegativeConstant() const |
| { |
| if (!isConstant()) return false; |
| return (const_part >= 0); |
| } |
| |
| bool |
| PiBound::isNegativeConstant() const |
| { |
| if (!isConstant()) return false; |
| return (const_part < 0); |
| } |
| |
| |
| PiCondition |
| PiCondition::add(int64 constant) const |
| { |
| return PiCondition(lb.add(PiBound(lb.getType(), constant), true), |
| ub.add(PiBound(ub.getType(), constant), true)); |
| } |
| |
| PiCondition |
| PiCondition::neg() const |
| { |
| return PiCondition(ub.neg(),lb.neg()); |
| } |
| |
| PiCondition |
| PiCondition::mul(int64 constant) const |
| { |
| if (constant < 0) { |
| return PiCondition(ub.mul(PiBound(ub.getType(), constant), true), |
| lb.mul(PiBound(lb.getType(), constant), true)); |
| } else { |
| return PiCondition(lb.mul(PiBound(lb.getType(), constant), true), |
| ub.mul(PiBound(ub.getType(), constant), true)); |
| } |
| } |
| |
| PiCondition |
| PiCondition::cast(Type::Tag newtype) const |
| { |
| return PiCondition(lb.cast(newtype, true),ub.cast(newtype, false)); |
| } |
| |
| // Print routines gathered here |
| |
| ::std::ostream &operator <<(::std::ostream &os, int64 val) |
| { |
| if (((int64)(int)val) == val) { |
| os << (int) val; |
| } else if (val == -val) { |
| os << "-9223372036854775808"; |
| } else { |
| char buf[100]; |
| int idx = 0; |
| bool sign = (val < (int64) 0); |
| if (sign) val = -val; |
| while (val > 0) { |
| buf[idx++] = '0' + ((char)(val%10)); |
| val = val / 10; |
| } |
| if (sign) os << "-"; |
| while (idx > 0) { |
| os << buf[--idx]; |
| } |
| } |
| return os; |
| } |
| |
| void |
| VarBound::print(::std::ostream &os) const |
| { |
| if (isEmpty()) { |
| os << "NULL"; |
| } else { |
| the_var->print(os); |
| } |
| } |
| |
| void |
| ConstBound::print(::std::ostream& os) const |
| { |
| switch (flag) { |
| case Const_PlusInfinity: |
| os << "+inf"; break; |
| case Const_MinusInfinity: |
| os << "-inf"; break; |
| case Const_IsConst: |
| os << (long) the_const; break; |
| case Const_IsNull: |
| assert(0); |
| os << "<<NULLCONST>>"; break; |
| } |
| } |
| |
| |
| void |
| PiBound::print(::std::ostream &os) const |
| { |
| if (isUnknown()) { |
| os << "unknown"; |
| } else if (isUndefined()) { |
| os << "undef"; |
| } else { |
| if (var_multiple) { |
| if (var_multiple != int64(1)) { |
| os << (long) var_multiple; |
| os << "*"; |
| } |
| var_part.print(os); |
| if (const_part > 0) |
| os << "+"; |
| } |
| if (const_part || !var_multiple) { |
| os << (long) const_part; |
| } |
| } |
| } |
| |
| void |
| PiCondition::print(::std::ostream &os) const |
| { |
| os << "["; |
| lb.print(os); |
| os << ","; |
| ub.print(os); |
| os << "]"; |
| } |
| |
| PiCondition PiCondition::typeBounds(Type::Tag dstTag, Type::Tag srcTag) |
| { |
| int64 lb, ub; |
| if (hasTypeBounds(srcTag, lb, ub)) { |
| return PiCondition(PiBound(dstTag, lb), PiBound(dstTag, ub)); |
| } else { |
| return PiCondition(PiBound(dstTag, true), PiBound(dstTag, true)); |
| } |
| } |
| |
| PiCondition PiCondition::convBounds(VarBound convVar) |
| { |
| assert(convVar.the_var != 0); |
| Inst *defInst = convVar.the_var->getInst(); |
| assert(defInst && (defInst->getOpcode() == Op_Conv)); |
| |
| Opnd *srci = defInst->getSrc(0); // the source operand |
| Type::Tag srcType = srci->getType()->tag; |
| Type::Tag instrType = defInst->getType(); |
| PiCondition bounds = PiCondition::typeBounds(instrType, srcType); |
| PiCondition bounds2 = bounds.cast(srcType); |
| return bounds2; |
| } |
| |
| void printPiCondition(const PiCondition *cond, ::std::ostream &os) |
| { |
| cond->print(os); |
| } |
| |
| PiBoundIter |
| VarBound::getPredecessors(bool boundingBelow, bool useReasons, |
| MemoryManager &mm) const |
| { |
| Inst *defInst = the_var ? (the_var->getInst()) : 0; |
| return PiBoundIter(defInst, boundingBelow, useReasons, mm); |
| } |
| |
| bool |
| VarBound::isPhiVar() const { |
| Inst *defInst = the_var->getInst(); |
| return (defInst && (defInst->getOpcode() == Op_Phi)); |
| } |
| |
| bool |
| VarBound::isMinMax(bool isMin) const { |
| Inst *defInst = the_var->getInst(); |
| if (defInst){ |
| if (isMin) |
| return (defInst->getOpcode() == Op_Min); |
| else |
| return (defInst->getOpcode() == Op_Max); |
| } |
| return false; |
| } |
| |
| bool |
| VarBound::isConvVar() const { |
| Inst *defInst = the_var ? the_var->getInst() : 0; |
| return (defInst && (defInst->getOpcode() == Op_Conv)); |
| } |
| |
| VarBound |
| VarBound::getConvSource() const { |
| assert(isConvVar()); |
| Inst *defInst = the_var->getInst(); |
| return defInst->getSrc(0); |
| } |
| |
| // true if type1 includes all values from type2 |
| bool |
| VarBound::typeIncludes(Type::Tag type1, Type::Tag type2) |
| { |
| if (type1 == type2) return true; |
| int64 lb1, lb2, ub1, ub2; |
| bool hasBounds1, hasBounds2; |
| hasBounds1 = hasTypeBounds(type1, lb1, ub1); |
| hasBounds2 = hasTypeBounds(type2, lb2, ub2); |
| if ((!hasBounds1) || (!hasBounds2)) { |
| return false; |
| } else { |
| if ((lb1 <= lb2) && (ub2 <= ub1)) { |
| return true; |
| } else { |
| return false; |
| } |
| } |
| } |
| |
| bool |
| VarBound::convPassesSource() const { |
| assert(isConvVar()); |
| Inst *instr = the_var->getInst(); |
| Opnd *srci = instr->getSrc(0); // the source operand |
| Type::Tag srcType = srci->getType()->tag; |
| Type::Tag dstType = the_var->getType()->tag; |
| Type::Tag instrType = instr->getType(); |
| if (typeIncludes(dstType, instrType) && |
| typeIncludes(instrType, srcType)) { |
| return true; |
| } else { |
| return false; |
| } |
| } |
| |
| bool |
| VarBound::isConvexFunction() const { |
| if (the_var == 0) return false; |
| Inst *the_inst = the_var->getInst(); |
| if(Op_Shr == the_inst->getOpcode()) { |
| Modifier mod = the_inst->getModifier(); |
| assert(mod.hasSignedModifier()); |
| if ((mod.getSignedModifier() == SignedOp) && ConstantFolder::isConstant(the_inst->getSrc(1)) ) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| ConstBound |
| VarBound::getConvexInputBound(bool isLB, ConstBound outputBound, |
| VarBound &inputVar) const |
| { |
| if (outputBound.isKnown()) { |
| Inst *the_inst = the_var->getInst(); |
| switch (the_inst->getOpcode()) { |
| case Op_Shr: { |
| assert(the_inst->getOperation().isSignedModifierSigned()); |
| Opnd *inputOpnd = the_inst->getSrc(0); |
| Opnd *shiftByOp = the_inst->getSrc(1); |
| Inst *shiftByInst = shiftByOp->getInst(); |
| ConstInst *shiftByConstInst = shiftByInst->asConstInst(); |
| if (shiftByConstInst != 0) { |
| U_32 shiftBy; |
| if (shiftByConstInst->getType() == Type::Int32) { |
| shiftBy = (U_32)shiftByConstInst->getValue().i4; |
| } else if (shiftByConstInst->getType() == Type::Int64) { |
| shiftBy = (U_32)shiftByConstInst->getValue().i8; |
| } else { |
| return ConstBound(); |
| } |
| |
| if (outputBound.isKnown()) { |
| Type::Tag typetag = the_inst->getType(); |
| // must be signed |
| switch (typetag) { |
| case Type::Int32: |
| { |
| I_32 bound = outputBound.getInt32(); |
| if (the_inst->getShiftMaskModifier() == ShiftMask_Masked) |
| shiftBy = shiftBy & 31; |
| I_32 input = bound << shiftBy; |
| if (!isLB) { |
| if (shiftBy < 31) { |
| input = input + ((I_32(1) << shiftBy) - 1); |
| } else { |
| input = 0xffffffff; |
| } |
| } |
| if (bound < 0) { |
| input = input | 0x80000000; |
| } else { |
| input = input & 0x7fffffff; |
| } |
| inputVar = VarBound(inputOpnd); |
| return ConstBound(input); |
| } |
| |
| case Type::Int64: |
| { |
| int64 bound = outputBound.getInt64(); |
| if (the_inst->getShiftMaskModifier() == ShiftMask_Masked) |
| shiftBy = shiftBy & 63; |
| int64 input = bound << shiftBy; |
| if (!isLB) { |
| if (shiftBy < 64) { |
| input = input + ((int64(1) << shiftBy) - 1); |
| } else { |
| input = __INT64_C(0xffffffffffffffff); |
| } |
| } |
| if (bound < 0) { |
| input = input | __INT64_C(0x8000000000000000); |
| } else { |
| input = input & __INT64_C(0x7fffffffffffffff); |
| } |
| inputVar = VarBound(inputOpnd); |
| return ConstBound(input); |
| } |
| |
| default: |
| break; |
| } |
| } |
| } |
| return ConstBound(); |
| } |
| default: |
| break; |
| } |
| assert(0); |
| return ConstBound(); |
| } else { |
| return ConstBound(); |
| } |
| } |
| |
| void PiBoundIter::print(::std::ostream& outs) const |
| { |
| if (!instr) { |
| outs << "[]"; |
| } else { |
| PiBoundIter acopy(*this); |
| outs << "["; |
| instr->print(outs); |
| outs << " : "; |
| current.print(outs); |
| while (++acopy) { |
| outs << ", "; |
| acopy.current.print(outs); |
| } |
| outs << "]"; |
| } |
| } |
| |
| bool PiBound::extractConstant(Type::Tag newtype, ConstInst *cinst0, PiBound &res) |
| { |
| assert(cinst0); |
| ConstInst::ConstValue cv = cinst0->getValue(); |
| switch (cinst0->getType()) { |
| case Type::Int8: case Type::Int16: case Type::Int32: |
| { |
| I_32 c = cv.i4; |
| res = PiBound(newtype, int64(c)); |
| return true; |
| } |
| case Type::Int64: |
| { |
| int64 c = cv.i8; |
| res = PiBound(newtype, int64(c)); |
| return true; |
| } |
| case Type::UInt8: case Type::UInt16: case Type::UInt32: |
| { |
| U_32 c = (U_32) cv.i4; |
| res = PiBound(newtype, int64(uint64(c))); |
| return true; |
| } |
| case Type::UInt64: |
| { |
| uint64 c = cv.i8; |
| if (c < uint64(__INT64_C(0x8000000000000000))) { |
| res = PiBound(newtype, int64(c)); |
| return true; |
| } |
| break; |
| } |
| default: |
| break; |
| } |
| return false; |
| } |
| |
| Opnd *PiBoundIter::getConstantOpnd(Opnd *opnd) |
| { |
| if (ConstantFolder::isConstant(opnd)) { |
| return opnd; |
| } else { |
| return 0; |
| } |
| } |
| |
| PiBound PiBoundIter::getBound(AbcdReasons *why0) { |
| if (why0) { |
| assert(why); |
| why0->addReasons(*why); |
| } |
| return current; |
| } |
| |
| void PiBoundIter::init(bool useReasons) |
| { |
| assert(!why); |
| why = useReasons ? new AbcdReasons(mm) : 0; |
| } |
| |
| void PiBoundIter::setCurrent() |
| { |
| if (isEmpty()) return; |
| if (!instr) return; |
| switch (instr->getOpcode()) { |
| case Op_Phi: |
| { |
| if (idx >= instr->getNumSrcOperands()) { |
| instr = 0; |
| if (why) why->clear(); |
| } else { |
| Opnd *srci = instr->getSrc(idx); |
| VarBound vb(srci); |
| current = PiBound(instr->getType(), vb); |
| if (why) why->clear(); |
| } |
| } |
| break; |
| case Op_TauPi: |
| { |
| // first, try to insert condition |
| TauPiInst *pInst = instr->asTauPiInst(); |
| const PiCondition *cond = pInst->getCond(); |
| Opnd *tauDepOpnd = pInst->getSrc(1); |
| SsaTmpOpnd *tauDep = tauDepOpnd->asSsaTmpOpnd(); |
| assert(tauDep); |
| if (isLb) { |
| current = cond->getLb(); |
| } else { |
| current = cond->getUb(); |
| } |
| assert(!current.isUnknown()); |
| if (current.isUndefined() && (idx >= 1)) { |
| instr = 0; |
| } else if ((!current.isUndefined()) && (idx == 0)) { |
| // use the Pi condition |
| if (why) why->addReason(tauDep); |
| } else if (idx <= 1) { |
| // effect of assignment |
| Opnd *srci = instr->getSrc(0); |
| VarBound vb(srci); |
| current = PiBound(instr->getType(), vb); |
| } else { |
| instr = 0; |
| } |
| } |
| break; |
| case Op_Add: |
| if (idx > 0) instr = 0; |
| else { |
| Opnd *op0 = instr->getSrc(0); |
| Opnd *op1 = instr->getSrc(1); |
| Opnd *constOpnd0 = getConstantOpnd(op0); |
| Opnd *constOpnd1 = getConstantOpnd(op1); |
| if ((constOpnd0 || constOpnd1) |
| && (instr->getType() == Type::Int32)) { |
| int64 c; |
| // I assume we've done folding first |
| assert(!(constOpnd0 && constOpnd1)); |
| |
| if (constOpnd1) { |
| // swap the operands; |
| constOpnd0 = constOpnd1; |
| op1 = op0; |
| } |
| // now constOpnd0 is the constant opnd |
| // op1 is the non-constant opnd |
| |
| Inst *inst0 = constOpnd0->getInst(); |
| assert(inst0); |
| ConstInst *cinst0 = inst0->asConstInst(); |
| assert(cinst0); |
| ConstInst::ConstValue cv = cinst0->getValue(); |
| c = cv.i4; |
| |
| VarBound vb(op1); |
| current = PiBound(instr->getType(), 1, vb, c); |
| } else |
| instr = 0; |
| } |
| break; |
| case Op_Sub: |
| if (idx > 0) instr = 0; |
| else { |
| Opnd *constOpnd = getConstantOpnd(instr->getSrc(1)); |
| if (constOpnd |
| && (instr->getType() == Type::Int32)) { |
| |
| #ifndef NDEBUG |
| Opnd *op0 = instr->getSrc(0); |
| #endif |
| Opnd *op1 = constOpnd; |
| // now op1 should be constant |
| // I assume we've done folding first |
| assert(!getConstantOpnd(op0)); |
| |
| Inst *inst1 = op1->getInst(); |
| assert(inst1); |
| ConstInst *cinst1 = inst1->asConstInst(); |
| assert(cinst1); |
| ConstInst::ConstValue cv = cinst1->getValue(); |
| I_32 c = cv.i4; |
| I_32 negc = -c; |
| if (neg_overflowed(negc,c)) { // overflowed |
| instr = 0; |
| } else { |
| VarBound vb(op1); |
| current = PiBound(instr->getType(), 1, vb, negc); |
| } |
| } else |
| instr = 0; |
| } |
| break; |
| case Op_Min: |
| if ((idx == 0) || (idx == 1)) { |
| Opnd *srci = instr->getSrc(idx); // the source operand |
| VarBound vb(srci); |
| current = PiBound(instr->getType(), vb); |
| } else { |
| instr = 0; |
| } |
| break; |
| case Op_Max: |
| if ((idx == 0) || (idx == 1)) { |
| Opnd *srci = instr->getSrc(idx); // the source operand |
| VarBound vb(srci); |
| current = PiBound(instr->getType(), vb); |
| } else { |
| instr = 0; |
| } |
| break; |
| case Op_Abs: |
| if (idx == 0) { |
| ConstBound cb((int64)0); |
| current = PiBound(instr->getType(), (int64) 0); |
| } else { |
| instr = 0; |
| } |
| break; |
| case Op_TauCheckBounds: |
| assert(0); |
| switch (idx) { |
| case 0: |
| { |
| Opnd *srci = instr->getSrc(1); // the index in; |
| VarBound vb(srci); |
| current = PiBound(srci->getType()->tag, vb); // result bounded by input index |
| } |
| break; |
| case 1: |
| if (isLb) { |
| current = PiBound(instr->getType(), int64(0)); // and 0 |
| } else { |
| // the array length |
| Opnd *srci = instr->getSrc(0); // the array length |
| VarBound vb(srci); |
| current = PiBound(srci->getType()->tag, int64(1), vb, int64(-1)); // len - 1 |
| } |
| break; |
| default: |
| instr = 0; |
| break; |
| }; |
| break; |
| case Op_Copy: |
| if (idx == 0) { |
| Opnd *srci = instr->getSrc(0); // the source operand |
| VarBound vb(srci); |
| current = PiBound(instr->getType(), vb); |
| } else { |
| instr = 0; |
| } |
| break; |
| case Op_LdVar: |
| if (idx == 0) { |
| assert(instr->isVarAccess()); |
| VarAccessInst *varInst = (VarAccessInst *)instr; |
| Opnd *srci = varInst->getSrc(0); |
| VarBound vb(srci); |
| current = PiBound(instr->getType(), vb); |
| } else { |
| instr = 0; |
| } |
| break; |
| case Op_StVar: |
| if (idx == 0) { |
| assert(instr->isVarAccess()); |
| Opnd *srci = instr->getSrc(0); |
| VarBound vb(srci); |
| current = PiBound(instr->getType(), vb); |
| } else { |
| instr = 0; |
| } |
| break; |
| case Op_TauArrayLen: |
| if (idx == 0) { |
| if (isLb) { |
| // 0 |
| current = PiBound(instr->getType(), int64(0)); |
| } else { |
| current = PiBound(instr->getType(), int64(0x7fffffff)); // bounded by max int |
| } |
| } else { |
| instr = 0; |
| } |
| break; |
| case Op_LdConstant: |
| if (idx == 0) { |
| ConstInst *cinst0 = instr->asConstInst(); |
| if (!PiBound::extractConstant(instr->getType(), cinst0, current)) { |
| instr = 0; |
| } |
| } else { |
| instr = 0; |
| } |
| break; |
| // could maybe do something with these: |
| case Op_TauRem: |
| if (idx == 0) { |
| Opnd *denom = instr->getSrc(1); |
| if (getConstantOpnd(denom)) { |
| Inst *consti1 = denom->getInst(); |
| ConstInst *cinst1 = consti1->asConstInst(); |
| assert(cinst1); |
| PiBound tmp(instr->getType(), true); |
| if (PiBound::extractConstant(instr->getType(), cinst1, current)) { |
| if (isLb) { |
| current = tmp.abs().neg(); |
| } else { |
| current = tmp.abs(); |
| } |
| } |
| } else { |
| instr = 0; |
| } |
| } else { |
| instr = 0; |
| } |
| break; |
| case Op_Conv: |
| if (idx == 0) { |
| Opnd *srci = instr->getSrc(0); // the source operand |
| Type::Tag srcType = srci->getType()->tag; |
| Type::Tag dstType = instr->getDst()->getType()->tag; |
| Type::Tag instrType = instr->getType(); |
| PiCondition bounds = PiCondition::typeBounds(dstType, srcType); |
| PiCondition bounds2 = bounds.cast(instrType); |
| PiCondition bounds3 = bounds.cast(dstType); |
| if (isLb) { |
| current = bounds3.getLb(); |
| } else { |
| current = bounds3.getUb(); |
| } |
| } else { |
| instr = 0; |
| } |
| break; |
| case Op_Cmp: |
| if (idx == 0) { |
| current = PiBound(instr->getType(), int64(isLb ? 0 : 1)); |
| } else { |
| instr = 0; |
| } |
| break; |
| case Op_Cmp3: |
| if (idx == 0) { |
| current = PiBound(instr->getType(), int64(isLb ? -1 : 1)); |
| } else { |
| instr = 0; |
| } |
| break; |
| |
| case Op_TauCheckNull: |
| case Op_TauCheckZero: |
| case Op_TauCheckCast: |
| case Op_TauHasType: |
| case Op_TauHasExactType: |
| case Op_TauIsNonNull: |
| assert(0); |
| break; |
| |
| case Op_Or: |
| case Op_Not: |
| case Op_Neg: |
| case Op_DefArg: |
| case Op_NewArray: |
| case Op_TauCast: |
| case Op_TauAsType: |
| |
| default: |
| instr = 0 ; |
| break; |
| } |
| } |
| |
| namespace { |
| bool hasTypeBounds(Type::Tag srcTag, int64 &lb, int64 &ub) |
| { |
| switch (srcTag) { |
| case Type::Int8: lb = -int64(0x80); ub = 0x7f; return true; |
| case Type::Int16: lb = -int64(0x8000); ub = 0x7fff; return true; |
| case Type::Int32: lb = -int64(0x80000000); ub = 0x7fffffff; return true; |
| case Type::Int64: |
| lb = __INT64_C(0x8000000000000000); |
| ub = __INT64_C(0x7fffffffffffffff); return true; |
| case Type::UInt8: lb = 0; ub = 0x100; return true; |
| case Type::UInt16: lb = 0; ub = 0x10000; return true; |
| case Type::UInt32: lb = 0; ub = __INT64_C(0x100000000); return true; |
| default: |
| return false; |
| } |
| } |
| |
| int numbitsInType(Type::Tag typetag) { |
| if ((typetag == Type::Int64) || (typetag == Type::UInt64) || |
| ((typetag == Type::IntPtr) && (sizeof(POINTER_SIZE_INT) == 8))) { |
| return 64; |
| } else { |
| return 32; |
| } |
| } |
| } // namespace |
| |
| } // namespace Jitrino |
