public SharedBitSet(int i) { value = new BitVector(i); }
public BitPointsToSet(Type type, PAG pag) { super(type); this.pag = pag; bits = new BitVector(pag.getAllocNodeNumberer().size()); }
public static BitVector and(BitVector set1, BitVector set2) { int min = set1.size(); { int max = set2.size(); if (min > max) { min = max; } // max is not necessarily correct at this point, so let it go // out of scope } BitVector ret = new BitVector(min); long[] retbits = ret.bits; long[] bits1 = set1.bits; long[] bits2 = set2.bits; min >>= 6; for (int i = 0; i < min; i++) { retbits[i] = bits1[i] & bits2[i]; } return ret; }
private void fixAncestors() { BitVector ancestors = new BitVector(0); BitVector indirectAncestors = new BitVector(0); for (TypeVariable typeVariable : parents) { TypeVariable parent = typeVariable.ecr(); if (parent.ancestors == null) { parent.fixAncestors(); } ancestors.set(parent.id); ancestors.or(parent.ancestors); indirectAncestors.or(parent.ancestors); } this.ancestors = ancestors; this.indirectAncestors = indirectAncestors; }
public static BitVector or(BitVector set1, BitVector set2) { int min = set1.size(); int max = set2.size(); if (min > max) { min = max; max = set1.size(); } BitVector ret = new BitVector(max); long[] retbits = ret.bits; long[] bits1 = set1.bits; long[] bits2 = set2.bits; min >>= 6; max >>= 6; for (int i = 0; i < min; i++) { retbits[i] = bits1[i] | bits2[i]; } if (bits1.length == min) { System.arraycopy(bits2, min, retbits, min, max - min); } else { System.arraycopy(bits1, min, retbits, min, max - min); } return ret; }
protected final void convertToBits() { if (bits != null) { return; } // ++numBitVectors; bits = new BitVector(pag.getAllocNodeNumberer().size()); for (Node node : nodes) { if (node != null) { fastAdd(node); } } }
private void merge_connected_components() throws TypeException { refresh_solved(); BitVector list = new BitVector(); list.or(solved); list.or(unsolved); new StronglyConnectedComponentsBV(list, this); }
private final void doubleSize() { int uniSize = universe.size(); if (array.length * 128 > uniSize) { bits = new BitVector(uniSize); Numberable[] oldArray = array; array = null; for (Numberable element : oldArray) { if (element != null) { bits.set(element.getNumber()); } } } else { Numberable[] oldArray = array; array = new Numberable[array.length * 2]; for (Numberable element : oldArray) { if (element != null) { array[findPosition(element)] = element; } } } }
private void fixAncestors() { BitVector ancestors = new BitVector(0); BitVector indirectAncestors = new BitVector(0); fixParents(); for (BitSetIterator i = parents.iterator(); i.hasNext();) { TypeVariableBV parent = resolver.typeVariableForId(i.next()).ecr(); if (parent.ancestors == null) { parent.fixAncestors(); } ancestors.set(parent.id); ancestors.or(parent.ancestors); indirectAncestors.or(parent.ancestors); } this.ancestors = ancestors; this.indirectAncestors = indirectAncestors; }
private void remove_transitive_constraints() throws TypeException { refresh_solved(); BitVector list = new BitVector(); list.or(solved); list.or(unsolved); for (BitSetIterator varIt = list.iterator(); varIt.hasNext();) { final TypeVariableBV var = typeVariableForId(varIt.next()); var.removeIndirectRelations(); } }
final private BitVector makeMaskOfInterface(SootClass interf) { if (!(interf.isInterface())) { throw new RuntimeException(); } BitVector ret = new BitVector(pag.getAllocNodeNumberer().size()); typeMask.put(interf.getType(), ret); Collection<SootClass> implementers = getFastHierarchy().getAllImplementersOfInterface(interf); for (SootClass impl : implementers) { BitVector other = typeMask.get(impl.getType()); if (other == null) { other = makeClassTypeMask(impl); } ret.or(other); } // I think, the following can be eliminated. It is added to make // type-masks exactly the same as the original type-masks if (implementers.size() == 0) { for (AllocNode an : anySubtypeAllocs) { ret.set(an.getNumber()); } } return ret; }
private void refresh_solved() throws TypeException { unsolved = new BitVector(); // solved stays the same for (BitSetIterator varIt = unsolved.iterator(); varIt.hasNext();) { final TypeVariableBV var = typeVariableForId(varIt.next()); if (var.depth() == 0) { if (var.type() == null) { unsolved.set(var.id()); } else { solved.set(var.id()); } } } // validate(); }
BitVector mask = typeMask.get(t); if (mask == null) { typeMask.put(t, mask = new BitVector()); for (final AllocNode an : pag.getAllocNodeNumberer()) { if (castNeverFails(an.getType(), t)) { return new BitVector(); } else { curClass = curClass.getSuperclass(); if (type instanceof RefType && curClass.isPhantom()) { return new BitVector();
final BitVector mask = new BitVector(nBits);
public void removeIndirectRelations() { if (rep != this) { ecr().removeIndirectRelations(); return; } if (indirectAncestors == null) { fixAncestors(); } BitVector parentsToRemove = new BitVector(); for (BitSetIterator parentIt = parents.iterator(); parentIt.hasNext();) { final int parent = parentIt.next(); if (indirectAncestors.get(parent)) { parentsToRemove.set(parent); } } for (BitSetIterator i = parentsToRemove.iterator(); i.hasNext();) { removeParent(resolver.typeVariableForId(i.next())); } }
private void fixParents() { if (rep != this) { ecr().fixParents(); } BitVector invalid = new BitVector(); invalid.or(parents); invalid.and(resolver.invalidIds()); for (BitSetIterator i = invalid.iterator(); i.hasNext();) { parents.set(resolver.typeVariableForId(i.next()).id()); } parents.clear(this.id); parents.clear(this.id()); parents.andNot(invalid); }
final TypeVariableBV var = typeVariableForId(varIt.next()); TypeNode lca = null; BitVector children_to_remove = new BitVector();