public boolean isStatic() { return field.isStatic(); }
@Override public void visit(Field obj) { super.visit(obj); XField f = XFactory.createXField(this); if (checkForInitialization(f) && !f.isSynthetic()) { if (f.isStatic()) { nonnullStaticFields.add(f); } else { nonnullFields.add(f); } } }
public void killLoadsWithSimilarName(String className, String methodName) { if (!REDUNDANT_LOAD_ELIMINATION) { return; } String packageName = extractPackageName(className); HashSet<AvailableLoad> killMe = new HashSet<>(); for (AvailableLoad availableLoad : getAvailableLoadMap().keySet()) { XField field = availableLoad.getField(); String fieldPackageName = extractPackageName(field.getClassName()); if (packageName.equals(fieldPackageName) && field.isStatic() && methodName.toLowerCase().indexOf(field.getName().toLowerCase()) >= 0) { killMe.add(availableLoad); } } killAvailableLoads(killMe); }
/** * 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()); }
if (!field.isStatic()) { String classSig = "L" + javaClass.getClassName().replace('.', '/') + ";";
@Override public void visit(Field obj) { XField xField = getXField(); if(!xField.isStatic() && (xField.isPrivate() || xField.isFinal()) && xField.isReferenceType()) { allowedFields.add(xField.getFieldDescriptor()); } }
public static FieldAnnotation fromXField(XField fieldDescriptor) { return new FieldAnnotation(fieldDescriptor.getClassName(), fieldDescriptor.getName(), fieldDescriptor.getSignature(), fieldDescriptor.getSourceSignature(), fieldDescriptor.isStatic()); }
boolean hasUpdates = false; for (XField f : xClass.getXFields()) { if (!f.isStatic()) { if (!f.isFinal() && !f.isSynthetic()) { hasMutableField = true;
/** * Look up the field referenced by given FieldInstruction, returning it as * an {@link XField XField} object. * * @param fins * the FieldInstruction * @param cpg * the ConstantPoolGen used by the class containing the * instruction * @return an XField object representing the field, or null if no such field * could be found */ public static @CheckForNull XField findXField(FieldInstruction fins, @Nonnull ConstantPoolGen cpg) { String className = fins.getClassName(cpg); String fieldName = fins.getFieldName(cpg); String fieldSig = fins.getSignature(cpg); boolean isStatic = (fins.getOpcode() == Const.GETSTATIC || fins.getOpcode() == Const.PUTSTATIC); XField xfield = findXField(className, fieldName, fieldSig, isStatic); short opcode = fins.getOpcode(); if (xfield != null && xfield.isResolved() && xfield.isStatic() == (opcode == Const.GETSTATIC || opcode == Const.PUTSTATIC)) { return xfield; } else { return null; } }
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; }
if (f.isStatic()) { staticCount++; } else if (!f.isPrivate()) {
@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(); }
bugPattern = "RC_REF_COMPARISON_BAD_PRACTICE_BOOLEAN"; priority = Priorities.NORMAL_PRIORITY; } else if (xf != null && xf.isStatic() && xf.isFinal()) { bugPattern = "RC_REF_COMPARISON_BAD_PRACTICE"; if (xf.isPublic() || !methodGen.isPublic()) {
/** * Called to indicate that a field load or store was encountered. * * @param cpIndex * the constant pool index of the fieldref * @param isStatic * true if it is a static field access * @param isLoad * true if the access is a load */ private void setField(int cpIndex, boolean isStatic, boolean isLoad) { // We only allow one field access for an accessor method. accessCount++; if (accessCount != 1) { access = null; return; } ConstantPool cp = javaClass.getConstantPool(); ConstantFieldref fieldref = (ConstantFieldref) cp.getConstant(cpIndex); ConstantClass cls = (ConstantClass) cp.getConstant(fieldref.getClassIndex()); String className = cls.getBytes(cp).replace('/', '.'); ConstantNameAndType nameAndType = (ConstantNameAndType) cp.getConstant(fieldref.getNameAndTypeIndex()); String fieldName = nameAndType.getName(cp); String fieldSig = nameAndType.getSignature(cp); XField xfield = Hierarchy.findXField(className, fieldName, fieldSig, isStatic); if (xfield != null && xfield.isStatic() == isStatic && isValidAccessMethod(methodSig, xfield, isLoad)) { access = new InnerClassAccess(methodName, methodSig, xfield, isLoad); } }
private MethodCall getMethodCall(MethodDescriptor methodDescriptorOperand) { Item objItem = getStack().getStackItem(getNumberArguments(methodDescriptorOperand.getSignature())); if (isNew(objItem)) { return new MethodCall(methodDescriptorOperand, TARGET_NEW); } if (objItem.getRegisterNumber() == 0 && !getMethod().isStatic()) { return new MethodCall(methodDescriptorOperand, constructor ? TARGET_NEW : TARGET_THIS); } XField xField = objItem.getXField(); if (xField != null) { if (classInit && xField.isStatic() && xField.getClassDescriptor().getClassName().equals(getClassName())) { return new MethodCall(methodDescriptorOperand, TARGET_NEW); } if (!getMethodDescriptor().isStatic() && objItem.getFieldLoadedFromRegister() == 0 && allowedFields.contains(xField.getFieldDescriptor())) { fieldsModifyingMethods.add(getMethodDescriptor()); return new MethodCall(methodDescriptorOperand, xField.getFieldDescriptor()); } } return new MethodCall(methodDescriptorOperand, TARGET_OTHER); }
int fr0 = item0.getFieldLoadedFromRegister(); int fr1 = item1.getFieldLoadedFromRegister(); if (field0 != null && field0.equals(field1) && (field0.isStatic() || fr0 != -1 && fr0 == fr1)) { int priority = NORMAL_PRIORITY; if (field0.isVolatile()) {
} else { for (XField f : c.getXFields()) { if (f.getName().equals(local.getName()) && (f.isStatic() || !getMethod().isStatic())) { bugReporter.reportBug(new BugInstance(this, "SA_LOCAL_SELF_ASSIGNMENT_INSTEAD_OF_FIELD", priority).addClassAndMethod(this).add(local).addField(f)
@Override public void visitClassContext(ClassContext classContext) { if(!classContext.getJavaClass().isEnum() || !classContext.getJavaClass().isPublic()) { return; } boolean hasInterestingField = false; for(XField field : classContext.getXClass().getXFields()) { if(!field.isStatic() && !field.isFinal() && !field.isSynthetic()) { if(field.isPublic()) { reporter.reportBug(new BugInstance("ME_MUTABLE_ENUM_FIELD", NORMAL_PRIORITY).addClass(classContext.getJavaClass()) .addField(field)); } else { hasInterestingField = true; } } } if(hasInterestingField) { super.visitClassContext(classContext); } }