void checkClassFile(final File cfile, String methodToFind, int[][] expectedLNT) throws Exception { ClassFile classFile = ClassFile.read(cfile); boolean methodFound = false; for (Method method : classFile.methods) { if (method.getName(classFile.constant_pool).equals(methodToFind)) { methodFound = true; Code_attribute code = (Code_attribute) method.attributes.get("Code"); LineNumberTable_attribute lnt = (LineNumberTable_attribute) code.attributes.get("LineNumberTable"); Assert.check( lnt.line_number_table_length == expectedLNT.length, "The LineNumberTable found has a length different to the expected one"); int i = 0; for (LineNumberTable_attribute.Entry entry : lnt.line_number_table) { Assert.check( entry.line_number == expectedLNT[i][0] && entry.start_pc == expectedLNT[i][1], "LNT entry at pos " + i + " differ from expected." + "Found " + entry.line_number + ":" + entry.start_pc + ". Expected " + expectedLNT[i][0] + ":" + expectedLNT[i][1]); i++; } } } Assert.check(methodFound, "The seek method was not found"); }
String getName(Method m) { try { return m.getName(constant_pool); } catch (ConstantPoolException e) { return report(e); } }
void checkClassFile(final Path path) throws Exception { ClassFile classFile = ClassFile.read(new BufferedInputStream(Files.newInputStream(path))); constantPool = classFile.constant_pool; utf8Index = constantPool.getUTF8Index("STR_TO_LOOK_FOR"); for (Method method : classFile.methods) { if (method.getName(constantPool).equals("methodToLookFor")) { Code_attribute codeAtt = (Code_attribute) method.attributes.get(Attribute.Code); for (Instruction inst : codeAtt.getInstructions()) { inst.accept(codeVisitor, null); } } } Assert.check( numberOfRefToStr == 1, "There should only be one reference to a CONSTANT_String_info structure in the generated code"); }
/** * This constructor takes a ClassFile and the MethodInfo structure representing the method and * produces an M6Method object. * * @param c The ClassFile representing the class * @param m The MethodInfo structure representing the method to analyze. */ public M6Method(M6Class cls, Method m) throws ConstantPoolException { this.cls = cls; cf = cls.cf; this.m = m; name = m.getName(cf.constant_pool); desc = m.descriptor.getValue(cf.constant_pool); String[] ss = splitMethodDesc(desc); for (int i = 1; i < ss.length; i++) { params.add(ss[i]); } returntype = ss[0]; cai = (Code_attribute) m.attributes.get(Attribute.Code); if (cai != null) { max_stack = cai.max_stack; max_locals = cai.max_locals; code_length = cai.code_length; sm = (StackMap_attribute) cai.attributes.get(Attribute.StackMap); lnt = (LineNumberTable_attribute) cai.attributes.get(Attribute.LineNumberTable); lvt = (LocalVariableTable_attribute) cai.attributes.get(Attribute.LocalVariableTable); } else { max_stack = max_locals = code_length = 0; sm = null; lnt = null; lvt = null; } tagTable = new Hashtable(); // debug = true; processed = false; }
void verifyBytecode(VarargsMethod selected, JavaSource source, int id) { bytecodeCheckCount.incrementAndGet(); File compiledTest = new File(String.format("Test%d.class", id)); try { ClassFile cf = ClassFile.read(compiledTest); Method testMethod = null; for (Method m : cf.methods) { if (m.getName(cf.constant_pool).equals("test")) { testMethod = m; break; } } if (testMethod == null) { throw new Error("Test method not found"); } Code_attribute ea = (Code_attribute) testMethod.attributes.get(Attribute.Code); if (testMethod == null) { throw new Error("Code attribute for test() method not found"); } for (Instruction i : ea.getInstructions()) { if (i.getMnemonic().equals("invokevirtual")) { int cp_entry = i.getUnsignedShort(1); CONSTANT_Methodref_info methRef = (CONSTANT_Methodref_info) cf.constant_pool.get(cp_entry); String type = methRef.getNameAndTypeInfo().getType(); String sig = selected.parameterTypes.bytecodeSigStr; if (!type.contains(sig)) { throw new Error( "Unexpected type method call: " + type + "" + "\nfound: " + sig + "\n" + source.getCharContent(true)); } break; } } } catch (Exception e) { e.printStackTrace(); throw new Error("error reading " + compiledTest + ": " + e); } }
void verifyBytecode(VarargsMethod selected) { bytecodeCheckCount++; File compiledTest = new File("Test.class"); try { ClassFile cf = ClassFile.read(compiledTest); Method testMethod = null; for (Method m : cf.methods) { if (m.getName(cf.constant_pool).equals("test")) { testMethod = m; break; } } if (testMethod == null) { throw new Error("Test method not found"); } Code_attribute ea = (Code_attribute) testMethod.attributes.get(Attribute.Code); if (testMethod == null) { throw new Error("Code attribute for test() method not found"); } for (Instruction i : ea.getInstructions()) { if (i.getMnemonic().equals("invokevirtual")) { int cp_entry = i.getUnsignedShort(1); CONSTANT_Methodref_info methRef = (CONSTANT_Methodref_info) cf.constant_pool.get(cp_entry); String type = methRef.getNameAndTypeInfo().getType(); if (!type.contains(selected.varargsElement.bytecodeString)) { throw new Error("Unexpected type method call: " + type); } break; } } } catch (Exception e) { e.printStackTrace(); throw new Error("error reading " + compiledTest + ": " + e); } }
void verifyBytecode(JavaSource source, int id) { boolean lastInlined = false; boolean hasCode = false; int gapsCount = 0; for (int i = 0; i < stmts.length; i++) { lastInlined = stmts[i].canInline; hasCode = hasCode || !stmts[i].empty; if (lastInlined && hasCode) { hasCode = false; gapsCount++; } } if (!lastInlined) { gapsCount++; } File compiledTest = new File(String.format("Test%s.class", id)); try { ClassFile cf = ClassFile.read(compiledTest); if (cf == null) { throw new Error("Classfile not found: " + compiledTest.getName()); } Method test_method = null; for (Method m : cf.methods) { if (m.getName(cf.constant_pool).equals("test")) { test_method = m; break; } } if (test_method == null) { throw new Error("Method test() not found in class Test"); } Code_attribute code = null; for (Attribute a : test_method.attributes) { if (a.getName(cf.constant_pool).equals(Attribute.Code)) { code = (Code_attribute) a; break; } } if (code == null) { throw new Error("Code attribute not found in method test()"); } int actualGapsCount = 0; for (int i = 0; i < code.exception_table_langth; i++) { int catchType = code.exception_table[i].catch_type; if (catchType == 0) { // any actualGapsCount++; } } if (actualGapsCount != gapsCount) { throw new Error( "Bad exception table for test()\n" + "expected gaps: " + gapsCount + "\n" + "found gaps: " + actualGapsCount + "\n" + source); } } catch (Exception e) { e.printStackTrace(); throw new Error("error reading " + compiledTest + ": " + e); } }