public ClassState getChild(ExecutionContext childContext) { return new ClassState(this, childContext); }
public void assignField(VirtualField field, HeapItem item) { int register = 0; String heapId = getHeapId(field); assignRegister(register, item, heapId); }
@Override public String toString() { StringBuilder sb = new StringBuilder("Fields:\n"); for (VirtualField field : virtualClass.getFields()) { sb.append(field).append(" = ").append(peekField(field)).append('\n'); } sb.setLength(sb.length() - 1); sb.append('\n'); return sb.toString(); }
public void pokeField(VirtualField field, HeapItem item) { int register = 0; String heapId = getHeapId(field); pokeRegister(register, item, heapId); }
private void inheritClassStates(ExecutionContext parentContext, ExecutionContext childContext) { for (VirtualClass virtualClass : classManager.getLoadedClasses()) { if (!parentContext.isClassInitialized(virtualClass)) { continue; } ClassState fromClassState = parentContext.peekClassState(virtualClass); ClassState toClassState = fromClassState.getChild(childContext); for (VirtualField field : fromClassState.getVirtualClass().getFields()) { HeapItem item = fromClassState.peekField(field); // TODO: should update field here? toClassState.pokeField(field, item); } SideEffect.Level level = parentContext.getClassSideEffectLevel(virtualClass); childContext.initializeClass(toClassState, level); } }
cState = new ClassState(virtualClass, callerContext); SideEffect.Level level = graph.getHighestClassSideEffectLevel(virtualClass); callerContext.initializeClass(cState, level); HeapItem item = graph.getFieldConsensus(terminatingAddresses, field); if (item.isPrimitive()) { cState.pokeField(field, item); } else { cState.updateIdentities(field, item);
public static ClassState forClass(ExecutionContext context, VirtualType virtualClass) { ClassState cState = new ClassState(virtualClass, context); for (VirtualField field : virtualClass.getFields()) { Object value = field.getInitialValue(); String type = field.getType(); cState.pokeField(field, new HeapItem(value, type)); } return cState; } }
public HeapItem peekField(VirtualField field) { int register = 0; String heapId = getHeapId(field); HeapItem fieldItem = peekRegister(register, heapId); if (fieldItem == null) { log.error("Undefined field: {}; returning unknown", field); fieldItem = HeapItem.newUnknown(field.getType()); } return fieldItem; }
private static void setupClassStates(ExecutionContext context, VirtualMachine vm, Map<String, Map<String, HeapItem>> classNameToFieldDescriptorToItem) { ClassManager classManager = vm.getClassManager(); for (Entry<String, Map<String, HeapItem>> entry : classNameToFieldDescriptorToItem.entrySet()) { String className = entry.getKey(); VirtualClass virtualClass = classManager.getVirtualClass(className); Map<String, HeapItem> fieldDescriptorToItem = entry.getValue(); ClassState cState = context.peekClassState(virtualClass); for (Entry<String, HeapItem> fieldNameAndTypeToItem : fieldDescriptorToItem.entrySet()) { String fieldNameAndType = fieldNameAndTypeToItem.getKey(); String fieldName = fieldNameAndType.split(":")[0]; VirtualField field = virtualClass.getField(fieldName); HeapItem item = fieldNameAndTypeToItem.getValue(); cState.pokeField(field, item); } context.initializeClass(cState, SideEffect.Level.NONE); } }
public void setClassState(ClassState cState) { classToStatus.put(cState.getVirtualClass(), new ClassStatus(cState)); }
public void putField(ExecutionContext context, VirtualField field, HeapItem putItem) { if (isSafe(field)) { // TODO: consider enabling this, is it safe? if (log.isWarnEnabled()) { log.warn("Ignoring static assignment of non-local field: {} = {}", field, putItem); } } else { ClassState cState = context.readClassState(field.getDefiningClass()); cState.assignField(field, putItem); } }
public ClassState peekClassState(VirtualType virtualClass) { ExecutionContext ancestor = getAncestorWithClass(virtualClass); if (ancestor == null) { // VirtualClass has not been initialized; build template and cache it locally to track initialization state ClassState templateClassState = TemplateStateFactory.forClass(this, virtualClass); setClassState(templateClassState); return templateClassState; } else if (ancestor != this) { ClassState ancestorClassState = ancestor.peekClassState(virtualClass); ClassState cState = ancestorClassState.getChild(this); SideEffect.Level level = ancestor.getClassSideEffectLevel(virtualClass); // Must initialize, because the ancestor probably just has the template class state. initializeClass(cState, level); return cState; } return classToStatus.get(virtualClass).getClassState(); }
public void pokeField(VirtualField field, Object value) { int register = 0; String heapId = getHeapId(field); String type = field.getType(); pokeRegister(register, new HeapItem(value, type), heapId); }
public void initializeClass(ClassState cState, SideEffect.Level level) { setClassState(cState); setClassInitialized(cState.getVirtualClass(), level); }
public void assignField(VirtualField field, Object value) { int register = 0; String heapId = getHeapId(field); String type = field.getType(); assignRegister(register, new HeapItem(value, type), heapId); }
private HeapItem getLocalField(ExecutionContext context, VirtualField field) { ClassState cState = context.readClassState(field.getDefiningClass()); return cState.peekField(field); }
public Set<HeapItem> getFieldItems(int address, VirtualField field) { List<ExecutionNode> nodePile = getNodePile(address); Set<HeapItem> items = new HashSet<>(nodePile.size()); for (ExecutionNode node : nodePile) { ExecutionContext context = node.getContext(); ClassState cState = context.peekClassState(field.getDefiningClass()); HeapItem item = cState.peekField(field); items.add(item); } return items; }