AllocDotField(PAG pag, AllocNode base, SparkField field) { super(pag, null); if (field == null) { throw new RuntimeException("null field"); } this.base = base; this.field = field; base.addField(this, field); pag.getAllocDotFieldNodeNumberer().add(this); }
public K next() { if (!hasNext()) { throw new NoSuchElementException(); } return universe.get(cur++); }
public LargeNumberedMap(ArrayNumberer<K> universe) { this.universe = universe; int newsize = universe.size(); if (newsize < 8) { newsize = 8; } values = new Object[newsize]; }
public static void printNodeNumberMapping(String fileName, PAG pag) { try { PrintWriter pw = new PrintWriter(new FileOutputStream(fileName)); for (Iterator iter = pag.getVarNodeNumberer().iterator(); iter.hasNext();) { VarNode vn = (VarNode) iter.next(); pw.println(vn.getNumber() + "\t" + vn); } pw.close(); } catch (FileNotFoundException e) { logger.error(e.getMessage(), e); } }
@Override public synchronized void add(E o) { if (o.getNumber() != 0) { return; } // In case we removed entries from the numberer, we want to re-use the free space int chosenNumber = -1; if (freeNumbers != null) { int ns = freeNumbers.nextSetBit(0); if (ns != -1) { chosenNumber = ns; freeNumbers.clear(ns); } } if (chosenNumber == -1) { chosenNumber = ++lastNumber; } if (lastNumber >= numberToObj.length) { resize(numberToObj.length * 2); } numberToObj[lastNumber] = o; o.setNumber(lastNumber); }
public Scene(Singletons.Global g) { setReservedNames(); // load soot.class.path system property, if defined String scp = System.getProperty("soot.class.path"); if (scp != null) { setSootClassPath(scp); } kindNumberer = new ArrayNumberer<Kind>( new Kind[] { Kind.INVALID, Kind.STATIC, Kind.VIRTUAL, Kind.INTERFACE, Kind.SPECIAL, Kind.CLINIT, Kind.THREAD, Kind.EXECUTOR, Kind.ASYNCTASK, Kind.FINALIZE, Kind.INVOKE_FINALIZE, Kind.PRIVILEGED, Kind.NEWINSTANCE }); addSootBasicClasses(); determineExcludedPackages(); }
/** * Removes the given method from this class. */ public void removeMethod(SootMethod m) { checkLevel(SIGNATURES); if (!m.isDeclared() || m.getDeclaringClass() != this) { throw new RuntimeException("incorrect declarer for remove: " + m.getName()); } if (subSigToMethods.get(m.getNumberedSubSignature()) == null) { throw new RuntimeException("Attempt to remove method " + m.getSubSignature() + " which is not in class " + this); } subSigToMethods.put(m.getNumberedSubSignature(), null); methodList.remove(m); m.setDeclared(false); m.setDeclaringClass(null); Scene.v().getMethodNumberer().remove(m); }
public static void dumpVarNodeInfo(final PAG pag) { PrintWriter varNodeWriter = null; try { varNodeWriter = new PrintWriter(new BufferedWriter(new FileWriter("varNodeInfo"))); } catch (IOException e) { logger.error(e.getMessage(), e); } for (Iterator iter = pag.getVarNodeNumberer().iterator(); iter.hasNext();) { VarNode varNode = (VarNode) iter.next(); varNodeWriter.println(varNode.getNumber() + " " + varNode); } varNodeWriter.flush(); varNodeWriter.close(); }
public int getNumAllocNodes() { return allocNodeNumberer.size(); }
VarNode(PAG pag, Object variable, Type t) { super(pag, t); if (!(t instanceof RefLikeType) || t instanceof AnySubType) { throw new RuntimeException("Attempt to create VarNode of type " + t); } this.variable = variable; pag.getVarNodeNumberer().add(this); setFinishingNumber(++pag.maxFinishNumber); }
public OverflowList(PointsToBitVector bv) { BitSetIterator it = bv.iterator(); // Iterates over only the 1 bits while (it.hasNext()) { // Get the next node in the bitset by looking it up in the // pointer assignment graph. // Ripped from BitPointsToSet. Node n = (Node) (pag.getAllocNodeNumberer().get(it.next())); add(n); } }
public void traceNode(int id) { buildVmatchEdges(); String fName = "trace." + id + ".dot"; try { FileOutputStream fos = new FileOutputStream(new File(fName)); PrintStream ps = new PrintStream(fos); ps.println("digraph G {"); // iterate over all variable nodes for (Iterator iter = pag.getVarNodeNumberer().iterator(); iter.hasNext();) { final VarNode n = (VarNode) iter.next(); if (n.getNumber() == id) { LocalVarNode lvn = (LocalVarNode) n; printOneNode(lvn); trace(lvn, ps, new HashSet<Node>(), TRACE_MAX_LVL); } } ps.print("}"); ps.close(); fos.close(); } catch (IOException e) { logger.error(e.getMessage(), e); } }
public boolean put(Numberable key, V value) { int number = key.getNumber(); if (number == 0) { throw new RuntimeException(String.format("oops, forgot to initialize. Object is of type %s, and looks like this: %s", key.getClass().getName(), key.toString())); } if (number >= values.length) { Object[] oldValues = values; values = new Object[universe.size() * 2 + 5]; System.arraycopy(oldValues, 0, values, 0, oldValues.length); } boolean ret = (values[number] != value); values[number] = value; return ret; }
FieldRefNode(PAG pag, VarNode base, SparkField field) { super(pag, null); if (field == null) { throw new RuntimeException("null field"); } this.base = base; this.field = field; base.addField(this, field); pag.getFieldRefNodeNumberer().add(this); }
/** Calls v's visit method on all nodes in this set. */ public final boolean forall(P2SetVisitor v) { for (BitSetIterator it = bits.iterator(); it.hasNext();) { v.visit((Node) pag.getAllocNodeNumberer().get(it.next())); } return v.getReturnValue(); }
final PrintWriter file = new PrintWriter(new FileOutputStream(new File(output_dir, "solution"))); file.println("Solution:"); for (Iterator vnIt = pag.getVarNodeNumberer().iterator(); vnIt.hasNext();) { final VarNode vn = (VarNode) vnIt.next(); if (vn.getReplacement() != vn) {
public BitPointsToSet(Type type, PAG pag) { super(type); this.pag = pag; bits = new BitVector(pag.getAllocNodeNumberer().size()); }
/** Tells this class if it is being managed by a Scene. */ public void setInScene(boolean isInScene) { this.isInScene = isInScene; Scene.v().getClassNumberer().add(this); }
public boolean forall(P2SetVisitor v) { // Iterate through the bit vector. Ripped from BitPointsToSet again. // It seems there should be a way to share code between BitPointsToSet // and // SharedHybridSet, but I don't know how at the moment. if (bitVector != null) { for (BitSetIterator it = bitVector.iterator(); it.hasNext();) { v.visit((Node) pag.getAllocNodeNumberer().get(it.next())); } } // Iterate through the overflow list for (OverflowList.ListNode i = overflow.overflow; i != null; i = i.next) { v.visit(i.elem); } return v.getReturnValue(); }
for (Iterator iter = pag.getVarNodeNumberer().iterator(); iter.hasNext();) { final VarNode n = (VarNode) iter.next();