private boolean isVolatileArray(XField f) { return isVolatile(f) && f.getSignature().charAt(0) == '['; } }
/** * Determine whether redundant load elimination should be performed for the * heap location referenced by the current instruction. * * @return true if we should do redundant load elimination for the current * instruction, false if not */ private boolean doRedundantLoadElimination() { if (!REDUNDANT_LOAD_ELIMINATION) { return false; } XField xfield = loadedFieldSet.getField(handle); if (xfield == null) { return false; } if(xfield.getSignature().equals("D") || xfield.getSignature().equals("J")) { // TODO: support two-slot fields return false; } // Don't do redundant load elimination for fields that // are loaded in only one place. /* if (false && loadedFieldSet.getLoadStoreCount(xfield).getLoadCount() <= 1){ return false; } */ return true; }
/** * Determine whether forward substitution should be performed for the heap * location referenced by the current instruction. * * @return true if we should do forward substitution for the current * instruction, false if not */ private boolean doForwardSubstitution() { if (!REDUNDANT_LOAD_ELIMINATION) { return false; } XField xfield = loadedFieldSet.getField(handle); if (xfield == null) { return false; } if(xfield.getSignature().equals("D") || xfield.getSignature().equals("J")) { return false; } // Don't do forward substitution for fields that // are never read. if (!loadedFieldSet.isLoaded(xfield)) { return false; } return true; }
public OpcodeStack.Item getSummary(XField field) { if (field == null) { return new OpcodeStack.Item(); } OpcodeStack.Item result = summary.get(field); if (result == null || field.isVolatile()) { String signature = field.getSignature(); return new OpcodeStack.Item(signature); } return result; }
buf.append(field.getSignature()); // the value being stored if (!"V".equals(methodReturnType) && !methodReturnType.equals(field.getSignature())) { if (DEBUG) { System.out.println("In " + javaClass.getClassName() + "." + methodName + " expected return type V or " + field.getSignature() + ", saw " + methodReturnType); System.out.println(isLoad ? "LOAD" : "STORE");
/** * Add a field annotation for an XField. * * @param xfield * the XField * @return this object */ @Nonnull public BugInstance addOptionalField(@CheckForNull XField xfield) { if (xfield == null) { return this; } return addField(xfield.getClassName(), xfield.getName(), xfield.getSignature(), xfield.isStatic()); }
/** * Add a field annotation for an XField. * * @param xfield * the XField * @return this object */ @Nonnull public BugInstance addField(XField xfield) { return addField(xfield.getClassName(), xfield.getName(), xfield.getSignature(), xfield.isStatic()); }
continue; OpcodeStack.Item defaultItem = new OpcodeStack.Item(f.getSignature()); fields++; Item value = entry.getValue();
private boolean interesting(XField f) { if (!f.isPublic() && !f.isProtected()) { return false; } if (!f.isStatic() || f.isSynthetic() || f.isVolatile()) { return false; } if (!f.isFinal()) { return true; } boolean isArray = f.getSignature().charAt(0) == '['; if (!(isArray || isCollection(f.getSignature()))) { return false; } return true; }
@Override public void visit(Code obj) { sawInitializeSuper = false; super.visit(obj); fieldSummary.setFieldsWritten(getXMethod(), touched); if (Const.CONSTRUCTOR_NAME.equals(getMethodName()) && sawInitializeSuper) { XClass thisClass = getXClass(); for (XField f : thisClass.getXFields()) { if (!f.isStatic() && !f.isFinal() && !touched.contains(f)) { OpcodeStack.Item item; char firstChar = f.getSignature().charAt(0); if (firstChar == 'L' || firstChar == '[') { item = OpcodeStack.Item.nullItem(f.getSignature()); } else if (firstChar == 'I') { item = new OpcodeStack.Item("I", (Integer) 0); } else if (firstChar == 'J') { item = new OpcodeStack.Item("J", 0L); } else { item = new OpcodeStack.Item(f.getSignature()); } fieldSummary.mergeSummary(f, item); } } } touched.clear(); }
public static FieldAnnotation fromXField(XField fieldDescriptor) { return new FieldAnnotation(fieldDescriptor.getClassName(), fieldDescriptor.getName(), fieldDescriptor.getSignature(), fieldDescriptor.getSourceSignature(), fieldDescriptor.isStatic()); }
public void mergeSummary(XField fieldOperand, OpcodeStack.Item mergeValue) { if (SystemProperties.ASSERTIONS_ENABLED) { String mSignature = mergeValue.getSignature(); Type mergeType = Type.getType(mSignature); Type fieldType = Type.getType(fieldOperand.getSignature()); IncompatibleTypes check = IncompatibleTypes.getPriorityForAssumingCompatible(mergeType, fieldType, false); if (check.getPriority() <= Priorities.NORMAL_PRIORITY) { AnalysisContext.logError(fieldOperand + " not compatible with " + mergeValue, new IllegalArgumentException(check.toString())); } } OpcodeStack.Item oldSummary = summary.get(fieldOperand); if (oldSummary != null) { Item newValue = OpcodeStack.Item.merge(mergeValue, oldSummary); newValue.clearNewlyAllocated(); summary.put(fieldOperand, newValue); } else { if (mergeValue.isNewlyAllocated()) { mergeValue = new OpcodeStack.Item(mergeValue); mergeValue.clearNewlyAllocated(); } summary.put(fieldOperand, mergeValue); } }
String signature = f.getSignature(); if (signature.startsWith("Ljava/util/concurrent") || signature.startsWith("Ljava/lang/StringB") || signature.charAt(0) == '[' || signature.indexOf("Map") >= 0 || signature.indexOf("List") >= 0
if (maskingField.isStatic() || maskingField.isFinal()) { priority++; } else if (fld.getSignature().charAt(0) == 'L' && !fld.getSignature().startsWith("Ljava/lang/") || fld.getSignature().charAt(0) == '[') { priority--; if (!fld.getSignature().equals(maskingField.getSignature())) { priority += 2; } else if (fld.getAccessFlags() != maskingField.getAccessFlags()) {
double isSerializable = DeepSubtypeAnalysis.isDeepSerializable(fieldX.getSignature()); if (isSerializable < 0.6) { priority++;
XField f = fieldsThatMightBeAProblem.get(nameOfField); String sig = f.getSignature();
if (seen == Const.PUTFIELD && incrementField.equals(getXFieldOperand())) { bugReporter.reportBug(new BugInstance(this, "VO_VOLATILE_INCREMENT", "J".equals(incrementField.getSignature()) ? Priorities.HIGH_PRIORITY : Priorities.NORMAL_PRIORITY) .addClassAndMethod(this).addField(incrementField).addSourceLine(this));
getMethod(), getNameConstantOperand(), xField.getSignature()); if (possibleTarget == null) { possibleTarget = LocalVariableAnnotation.findUniqueBestMatchingParameter(getClassContext(), getMethod(),
char firstChar = field.getSignature().charAt(0); if (firstChar != 'L' && firstChar != '[') { return;
public static Type getType(XField xfield) { Type t = Type.getType(xfield.getSignature()); if (!(t instanceof ReferenceType)) { return t;