@Override public void visit(ConstantClass obj) { @SlashedClassName String className = obj.getBytes(javaClass.getConstantPool()); if (className.indexOf('[') >= 0) { ClassParser.extractReferencedClassesFromSignature(referencedClassSet, className); } else if (ClassName.isValidClassName(className)) { referencedClassSet.add(DescriptorFactory.instance().getClassDescriptor(className)); } }
public static @CheckForNull CodeException getSurroundingTryBlock(ConstantPool constantPool, Code code, @CheckForNull String vmNameOfExceptionClass, int pc) { int size = Integer.MAX_VALUE; if (code.getExceptionTable() == null) { return null; } CodeException result = null; for (CodeException catchBlock : code.getExceptionTable()) { if (vmNameOfExceptionClass != null) { Constant catchType = constantPool.getConstant(catchBlock.getCatchType()); if (catchType == null && !vmNameOfExceptionClass.isEmpty() || catchType instanceof ConstantClass && !((ConstantClass) catchType).getBytes(constantPool).equals(vmNameOfExceptionClass)) { continue; } } int startPC = catchBlock.getStartPC(); int endPC = catchBlock.getEndPC(); if (pc >= startPC && pc <= endPC) { int thisSize = endPC - startPC; if (size > thisSize) { size = thisSize; result = catchBlock; } } } return result; }
@Override public void visit(ConstantPool pool) { for (Constant constant : pool.getConstantPool()) { if (constant instanceof ConstantClass) { ConstantClass cc = (ConstantClass) constant; @SlashedClassName String className = cc.getBytes(pool); if ("java/util/Calendar".equals(className) || "java/text/DateFormat".equals(className)) { sawDateClass = true; break; } if (className.charAt(0) != '[') { try { ClassDescriptor cDesc = DescriptorFactory.createClassDescriptor(className); if (subtypes2.isSubtype(cDesc, calendarType) || subtypes2.isSubtype(cDesc, dateFormatType)) { sawDateClass = true; break; } } catch (ClassNotFoundException e) { reporter.reportMissingClass(e); } } } } }
public static String getExceptionSig(DismantleBytecode dbc, CodeException e) { if (e.getCatchType() == 0) { return "Ljava/lang/Throwable;"; } Constant c = dbc.getConstantPool().getConstant(e.getCatchType()); if (c instanceof ConstantClass) { return "L" + ((ConstantClass) c).getBytes(dbc.getConstantPool()) + ";"; } return "Ljava/lang/Throwable;"; }
@Override public void visitLDC(LDC obj) { Object constantValue = obj.getValue(cpg); ValueNumber value; if (constantValue instanceof ConstantClass) { ConstantClass constantClass = (ConstantClass) constantValue; String className = constantClass.getBytes(cpg.getConstantPool()); value = factory.getClassObjectValue(className); } else if (constantValue instanceof ObjectType) { ObjectType objectType = (ObjectType) constantValue; String className = objectType.getClassName(); value = factory.getClassObjectValue(className); } else { value = constantValueMap.get(constantValue); if (value == null) { value = factory.createFreshValue(ValueNumber.CONSTANT_VALUE); constantValueMap.put(constantValue, value); // Keep track of String constants if (constantValue instanceof String) { stringConstantMap.put(value, (String) constantValue); } } } getFrame().pushValue(value); }
/** * Determine the outer class of obj. * * @param obj * @return JavaClass for outer class, or null if obj is not an outer class * @throws ClassNotFoundException */ @CheckForNull public static JavaClass getOuterClass(JavaClass obj) throws ClassNotFoundException { for (Attribute a : obj.getAttributes()) { if (a instanceof InnerClasses) { for (InnerClass ic : ((InnerClasses) a).getInnerClasses()) { if (obj.getClassNameIndex() == ic.getInnerClassIndex()) { // System.out.println("Outer class is " + // ic.getOuterClassIndex()); ConstantClass oc = (ConstantClass) obj.getConstantPool().getConstant(ic.getOuterClassIndex()); String ocName = oc.getBytes(obj.getConstantPool()); return Repository.lookupClass(ocName); } } } } return null; }
Constant catchType = constantPool.getConstant(catchBlock.getCatchType()); if (catchType == null && !vmNameOfExceptionClass.isEmpty() || catchType instanceof ConstantClass && !((ConstantClass) catchType).getBytes(constantPool).equals(vmNameOfExceptionClass)) { continue;
if (value instanceof ConstantClass) { ConstantClass cc = (ConstantClass) value; constantClass = cc.getBytes(classContext.getJavaClass().getConstantPool()); pcForConstantClass = pc;
@Override public void visitClass(ClassDescriptor classDescriptor) throws CheckedAnalysisException { IAnalysisCache analysisCache = Global.getAnalysisCache(); ObligationFactory factory = database.getFactory(); JavaClass jclass = analysisCache.getClassAnalysis(JavaClass.class, classDescriptor); for (Constant c : jclass.getConstantPool().getConstantPool()) { if (c instanceof ConstantNameAndType) { ConstantNameAndType cnt = (ConstantNameAndType) c; String signature = cnt.getSignature(jclass.getConstantPool()); if (factory.signatureInvolvesObligations(signature)) { super.visitClass(classDescriptor); return; } } else if (c instanceof ConstantClass) { String className = ((ConstantClass) c).getBytes(jclass.getConstantPool()); if (factory.signatureInvolvesObligations(className)) { super.visitClass(classDescriptor); return; } } } if (DEBUG) { System.out.println(classDescriptor + " isn't interesting for obligation analysis"); } }
int index = t.getIndex(); ConstantClass c = (ConstantClass) t.getConstantPool().getConstant(index); String name = c.getBytes(t.getConstantPool()); if (name.charAt(0) != '[') { name = "L" + name + ";";
/** * 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); } }
&& (codeBytes[handlerPC + 1] & 0xff) == Const.ICONST_0 && (codeBytes[handlerPC + 2] & 0xff) == Const.IRETURN && FindNullDeref.catchTypesForNull.contains(cl.getBytes(cp))) {
if (value instanceof ConstantClass) { ConstantClass v = (ConstantClass) value; initializationOf = ClassName.toSignature(v.getBytes(javaClass.getConstantPool())); foundDeadClassInitialization = true; } else if (value instanceof ObjectType) {
boolean catchIsThrown(ConstantPool pool, Set<String> thrownExceptions) { if (thrownExceptions.isEmpty()) { return false; } int exIndex = catchTypes.nextSetBit(0); String exName = ((ConstantClass) pool.getConstant(exIndex)).getBytes(pool); return thrownExceptions.contains(exName); }
boolean catchIsThrown(ConstantPool pool, Set<String> thrownExceptions) { if (thrownExceptions.isEmpty()) { return false; } int exIndex = catchTypes.nextSetBit(0); String exName = ((ConstantClass) pool.getConstant(exIndex)).getBytes(pool); return thrownExceptions.contains(exName); }
public void visitConstantClass(ConstantClass obj) { ConstantPool cp= jc.getConstantPool(); String bytes= obj.getBytes(cp); fileUnit.addDependency(bytes.replace("/", ".")); } });
@Override public void visit(ConstantClass obj) { @SlashedClassName String className = obj.getBytes(javaClass.getConstantPool()); if (className.indexOf('[') >= 0) { ClassParser.extractReferencedClassesFromSignature(referencedClassSet, className); } else if (ClassName.isValidClassName(className)) { referencedClassSet.add(DescriptorFactory.instance().getClassDescriptor(className)); } }
@Override public void visit(ConstantPool pool) { for (Constant constant : pool.getConstantPool()) { if (constant instanceof ConstantClass) { ConstantClass cc = (ConstantClass) constant; @SlashedClassName String className = cc.getBytes(pool); if ("java/util/Calendar".equals(className) || "java/text/DateFormat".equals(className)) { sawDateClass = true; break; } try { ClassDescriptor cDesc = DescriptorFactory.createClassDescriptor(className); if (subtypes2.isSubtype(cDesc, calendarType) || subtypes2.isSubtype(cDesc, dateFormatType)) { sawDateClass = true; break; } } catch (ClassNotFoundException e) { reporter.reportMissingClass(e); } } } }
public static String getExceptionSig(DismantleBytecode dbc, CodeException e) { if (e.getCatchType() == 0) { return "Ljava/lang/Throwable;"; } Constant c = dbc.getConstantPool().getConstant(e.getCatchType()); if (c instanceof ConstantClass) { return "L" + ((ConstantClass) c).getBytes(dbc.getConstantPool()) + ";"; } return "Ljava/lang/Throwable;"; }
/** * Verify for an inner class declared inside the 'main' method that the * enclosing method attribute is set correctly. */ public void testCheckMethodLevelNamedInnerClass() throws ClassNotFoundException { final JavaClass clazz = getTestClass(PACKAGE_BASE_NAME+".data.AttributeTestClassEM01$1S"); final ConstantPool pool = clazz.getConstantPool(); final Attribute[] encMethodAttrs = findAttribute("EnclosingMethod", clazz); assertTrue("Expected 1 EnclosingMethod attribute but found " + encMethodAttrs.length, encMethodAttrs.length == 1); final EnclosingMethod em = (EnclosingMethod) encMethodAttrs[0]; final String enclosingClassName = em.getEnclosingClass().getBytes(pool); final String enclosingMethodName = em.getEnclosingMethod().getName(pool); assertTrue( "Expected class name to be '"+PACKAGE_BASE_SIG+"/data/AttributeTestClassEM01' but was " + enclosingClassName, enclosingClassName .equals(PACKAGE_BASE_SIG+"/data/AttributeTestClassEM01")); assertTrue("Expected method name to be 'main' but was " + enclosingMethodName, enclosingMethodName.equals("main")); }