@Override protected int getMaxValueNumber() { return symtab.getMaxValueNumber(); }
protected boolean isConstantRef(SymbolTable symbolTable, int valueNumber) { if (valueNumber == -1) { return false; } if (symbolTable.isConstant(valueNumber)) { Object v = symbolTable.getConstantValue(valueNumber); return (!(v instanceof Number)); } else { return false; } }
public boolean isBooleanOrZeroOneConstant(int v) { return isBooleanConstant(v) || isZero(v) || isOne(v); }
@Override protected int getNextNewValueNumber() { while (symtab.isConstant(nextSSAValue) || skip(nextSSAValue)) ++nextSSAValue; symtab.ensureSymbol(nextSSAValue); int v = nextSSAValue++; return v; }
for (int i = 1; i <= s.getMaxValueNumber(); i++) { if (DEBUG) { System.err.print(i); if (s.isConstant(i)) { if (s.isStringConstant(i)) { TypeReference type = node.getMethod().getDeclaringClass().getClassLoader().getLanguage().getConstantType( s.getStringValue(i)); result.put(pointerKeys.getPointerKeyForLocal(node, i), getInstanceKeyForConstant(type, s.getConstantValue(i)));
for (int v = 0; v <= targetST.getMaxValueNumber(); v++) { String[] vns = targetIR.getLocalNames(1, v); for (int n = 0; vns != null && n < vns.length; n++) { int paramCount = targetST.getParameterValueNumbers().length; int argCount = instruction.getNumberOfPositionalParameters(); int nullvn = sourceST.getNullConstant(); DefUse sourceDU = builder.getCFAContextInterpreter().getDU(caller); InstanceKey[] nullkeys = builder.getInvariantContents(sourceST, sourceDU, caller, nullvn, builder); for (int i = argCount; i < paramCount; i++) { PointerKey F = builder.getPointerKeyForLocal(target, targetST.getParameter(i)); for (InstanceKey nullkey : nullkeys) { builder.getSystem().newConstraint(F, nullkey);
/** * add constraints for reference constants assigned to vars */ protected void addNodeConstantConstraints(CGNode node, IR ir) { SymbolTable symbolTable = ir.getSymbolTable(); for (int i = 1; i <= symbolTable.getMaxValueNumber(); i++) { if (symbolTable.isConstant(i)) { Object v = symbolTable.getConstantValue(i); if (!(v instanceof Number)) { Object S = symbolTable.getConstantValue(i); TypeReference type = node.getMethod().getDeclaringClass().getClassLoader().getLanguage().getConstantType(S); if (type != null) { InstanceKey ik = heapModel.getInstanceKeyForConstant(type, S); if (ik != null) { PointerKey pk = heapModel.getPointerKeyForLocal(node, i); addNode(pk); addNode(ik); addEdge(pk, ik, NewLabel.v()); } } } } } }
@Override public int getConstantValue(Object o) { if (o instanceof Integer) { return getUnderlyingSymtab().getConstant(((Integer) o).intValue()); } else if (o instanceof Float) { return getUnderlyingSymtab().getConstant(((Float) o).floatValue()); } else if (o instanceof Double) { return getUnderlyingSymtab().getConstant(((Double) o).doubleValue()); } else if (o instanceof Long) { return getUnderlyingSymtab().getConstant(((Long) o).longValue()); } else if (o instanceof String) { return getUnderlyingSymtab().getConstant((String) o); } else if (o instanceof Boolean) { return getUnderlyingSymtab().getConstant((Boolean) o); } else if (o instanceof Character) { return getUnderlyingSymtab().getConstant(((Character) o).charValue()); } else if (o instanceof Byte) { return getUnderlyingSymtab().getConstant(((Byte) o).byteValue()); } else if (o instanceof Short) { return getUnderlyingSymtab().getConstant(((Short) o).shortValue()); } else if (o == null) { return getUnderlyingSymtab().getNullConstant(); } else if (o == CAstControlFlowMap.SWITCH_DEFAULT) { return getUnderlyingSymtab().getConstant("__default label"); } else { System.err.println(("cannot handle constant " + o)); Assertions.UNREACHABLE(); return -1; } }
@Override public IVariable makeVariable(int valueNumber) { SymbolTable st = ir.getSymbolTable(); if (st.isIntegerConstant(valueNumber) && st.isZero(valueNumber)) { return new DalvikTypeVariable(language.getPrimitive(language.getConstantType(Integer.valueOf(0))), true); } else { if (doPrimitives) { if (st.isConstant(valueNumber)) { if (st.isBooleanConstant(valueNumber)) { return new DalvikTypeVariable(language.getPrimitive(language.getConstantType(Boolean.TRUE))); } } } return new DalvikTypeVariable(TypeAbstraction.TOP); } } }
public TypeAbstraction getConstantPrimitiveType(int valueNumber) { SymbolTable st = ir.getSymbolTable(); if (!st.isConstant(valueNumber) || st.isNullConstant(valueNumber)) { return TypeAbstraction.TOP; } else { return language.getPrimitive(language.getConstantType(st.getConstantValue(valueNumber))); } }
@Override public TypeAbstraction getConstantType(int valueNumber) { SymbolTable st = ir.getSymbolTable(); if (st.isStringConstant(valueNumber)) { return new PointType(cha.lookupClass(JavaScriptTypes.String)); } else if (st.isBooleanConstant(valueNumber)) { return new PointType(cha.lookupClass(JavaScriptTypes.Boolean)); } else if (st.isNullConstant(valueNumber)) { return new PointType(cha.lookupClass(JavaScriptTypes.Null)); } else { return new PointType(cha.lookupClass(JavaScriptTypes.Number)); } } }
@Override public IVariable makeVariable(int valueNumber) { if (doPrimitives) { SymbolTable st = ir.getSymbolTable(); if (st.isConstant(valueNumber)) { if (st.isBooleanConstant(valueNumber)) { return new TypeVariable(language.getPrimitive(language.getConstantType(Boolean.TRUE))); } } } return new TypeVariable(TypeAbstraction.TOP); }
int index = symbolTable.getConstant(i); int arrayRef = workingState.getLocal(instruction.array); TypeReference t = instruction.getType(); value = symbolTable.getConstant((char) ae.intValue()); else if (t.equals(TypeReference.Byte)) value = symbolTable.getConstant(ae.byteValue()); else if (t.equals(TypeReference.Short)) value = symbolTable.getConstant(ae.shortValue()); else if (t.equals(TypeReference.Int)) value = symbolTable.getConstant(ae.intValue()); else if (t.equals(TypeReference.Long)) value = symbolTable.getConstant(ae.longValue()); else if (t.equals(TypeReference.Float)) value = symbolTable.getConstant(ae.floatValue()); else if (t.equals(TypeReference.Double)) value = symbolTable.getConstant(ae.doubleValue()); else if (t.equals(TypeReference.Boolean)) value = symbolTable.getConstant(ae.intValue() != 0); else
public String getStringValue(int v) throws IllegalArgumentException { if (!isStringConstant(v)) { throw new IllegalArgumentException("not a string constant: value number " + v); } return (String) ((ConstantValue) values[v]).getValue(); }
protected AbstractScope makeScriptScope(final CAstEntity s, Scope parent) { return new AbstractScope(parent) { SymbolTable scriptGlobalSymtab = new SymbolTable(s.getArgumentCount());
@Override protected void addNodesForParameters(CGNode node, IR ir) { SymbolTable symbolTable = ir.getSymbolTable(); int numParams = symbolTable.getNumberOfParameters(); for (int i = 0; i < numParams; i++) { int parameter = symbolTable.getParameter(i); PointerKey paramPk = heapModel.getPointerKeyForLocal(node, parameter); addNode(paramPk); params.put(paramPk, node); } PointerKey returnKey = heapModel.getPointerKeyForReturnValue(node); addNode(returnKey); returns.put(returnKey, node); PointerKey exceptionReturnKey = heapModel.getPointerKeyForExceptionalReturnValue(node); addNode(exceptionReturnKey); returns.put(exceptionReturnKey, node); }
/** * @return array of value numbers representing parameters to this method */ public int[] getParameterValueNumbers() { return symbolTable.getParameterValueNumbers(); }
@Override protected void initializeVariables() { MachineState entryState = getEntryState(); int parameterNumber = 0; int local = -1; for (int i = 0; i < method.getNumberOfParameters(); i++) { local++; TypeReference t = method.getParameterType(i); if (t != null) { int symbol = symbolTable.getParameter(parameterNumber++); entryState.setLocal(local, symbol); if (t.equals(TypeReference.Double) || t.equals(TypeReference.Long)) { local++; } } } // This useless value ensures that the state cannot be empty, even // for a static method with no arguments in blocks with an empty stack // and no locals being used. This ensures that propagation of the // state thru the CFGSystem will always show changes the first time // it reaches a block, and thus no piece of the CFG will be skipped. // // (note that this bizarre state really happened, in java_cup) // entryState.push(symbolTable.newSymbol()); }
/** * @return the value number of the ith parameter */ public int getParameter(int i) { return symbolTable.getParameter(i); }
@Override protected boolean isConstantRef(SymbolTable symbolTable, int valueNumber) { if (valueNumber == -1) { return false; } return symbolTable.isConstant(valueNumber); }