jdk8-mips64-public/langtools: comparison test/tools/javac/flow/LVTHarness.java

--1:000000000000
+:959103a6100f
+/*
+* Copyright (c) 2013, 2014, Oracle and/or its affiliates. All rights reserved.
+* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+*
+* This code is free software; you can redistribute it and/or modify it
+* under the terms of the GNU General Public License version 2 only, as
+* published by the Free Software Foundation.
+*
+* This code is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+* version 2 for more details (a copy is included in the LICENSE file that
+* accompanied this code).
+*
+* You should have received a copy of the GNU General Public License version
+* 2 along with this work; if not, write to the Free Software Foundation,
+* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+*
+* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+* or visit www.oracle.com if you need additional information or have any
+* questions.
+*/
+/*
+* @test
+* @bug 7047734 8027660 8037937
+* @summary The LVT is not generated correctly during some try/catch scenarios
+*          javac crash while creating LVT entry for a local variable defined in
+*          an inner block
+* @library /tools/javac/lib
+* @build JavacTestingAbstractProcessor LVTHarness
+* @run main LVTHarness
+*/
+import java.io.File;
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.util.Set;
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.processing.RoundEnvironment;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import javax.tools.JavaCompiler;
+import javax.tools.JavaFileObject;
+import javax.tools.StandardJavaFileManager;
+import javax.tools.ToolProvider;
+import com.sun.source.util.JavacTask;
+import com.sun.tools.classfile.Attribute;
+import com.sun.tools.classfile.ClassFile;
+import com.sun.tools.classfile.ConstantPool;
+import com.sun.tools.classfile.ConstantPoolException;
+import com.sun.tools.classfile.Code_attribute;
+import com.sun.tools.classfile.ConstantPool.InvalidIndex;
+import com.sun.tools.classfile.ConstantPool.UnexpectedEntry;
+import com.sun.tools.classfile.Descriptor.InvalidDescriptor;
+import com.sun.tools.classfile.LocalVariableTable_attribute;
+import com.sun.tools.classfile.Method;
+import static javax.tools.StandardLocation.*;
+import static com.sun.tools.classfile.LocalVariableTable_attribute.Entry;
+import static javax.tools.JavaFileObject.Kind.SOURCE;
+public class LVTHarness {
+static int nerrors = 0;
+static final JavaCompiler comp = ToolProvider.getSystemJavaCompiler();
+static final StandardJavaFileManager fm = comp.getStandardFileManager(null, null, null);
+public static void main(String[] args) throws Exception {
+String testDir = System.getProperty("test.src");
+fm.setLocation(SOURCE_PATH, Arrays.asList(new File(testDir, "tests")));
+// Make sure classes are written to scratch dir.
+fm.setLocation(CLASS_OUTPUT, Arrays.asList(new File(".")));
+for (JavaFileObject jfo : fm.list(SOURCE_PATH, "", Collections.singleton(SOURCE), true)) {
+new LVTHarness(jfo).check();
+}
+if (nerrors > 0) {
+throw new AssertionError("Errors were found");
+}
+}
+JavaFileObject jfo;
+Map<ElementKey, AliveRanges> aliveRangeMap = new HashMap<>();
+Set<String> declaredKeys = new HashSet<>();
+List<ElementKey> seenAliveRanges = new ArrayList<>();
+protected LVTHarness(JavaFileObject jfo) {
+this.jfo = jfo;
+}
+protected void check() throws Exception {
+JavacTask ct = (JavacTask) comp.getTask(null, fm, null, Arrays.asList("-g"),
+null, Arrays.asList(jfo));
+System.err.println("compiling code " + jfo);
+ct.setProcessors(Collections.singleton(new AliveRangeFinder()));
+if (!ct.call()) {
+throw new AssertionError("Error during compilation");
+}
+File javaFile = new File(jfo.getName());
+File classFile = new File(javaFile.getName().replace(".java", ".class"));
+checkClassFile(classFile);
+//check all candidates have been used up
+for (Map.Entry<ElementKey, AliveRanges> entry : aliveRangeMap.entrySet()) {
+if (!seenAliveRanges.contains(entry.getKey())) {
+error("Redundant @AliveRanges annotation on method " +
+entry.getKey().elem + " with key " + entry.getKey());
+}
+}
+}
+void checkClassFile(File file)
+throws IOException, ConstantPoolException, InvalidDescriptor {
+ClassFile classFile = ClassFile.read(file);
+ConstantPool constantPool = classFile.constant_pool;
+//lets get all the methods in the class file.
+for (Method method : classFile.methods) {
+for (ElementKey elementKey: aliveRangeMap.keySet()) {
+String methodDesc = method.getName(constantPool) +
+method.descriptor.getParameterTypes(constantPool).replace(" ", "");
+if (methodDesc.equals(elementKey.elem.toString())) {
+checkMethod(constantPool, method, aliveRangeMap.get(elementKey));
+seenAliveRanges.add(elementKey);
+}
+}
+}
+}
+void checkMethod(ConstantPool constantPool, Method method, AliveRanges ranges)
+throws InvalidIndex, UnexpectedEntry {
+Code_attribute code = (Code_attribute) method.attributes.get(Attribute.Code);
+LocalVariableTable_attribute lvt =
+(LocalVariableTable_attribute) (code.attributes.get(Attribute.LocalVariableTable));
+List<String> infoFromRanges = convertToStringList(ranges);
+List<String> infoFromLVT = convertToStringList(constantPool, lvt);
+// infoFromRanges most be contained in infoFromLVT
+int i = 0;
+int j = 0;
+while (i < infoFromRanges.size() && j < infoFromLVT.size()) {
+int comparison = infoFromRanges.get(i).compareTo(infoFromLVT.get(j));
+if (comparison == 0) {
+i++; j++;
+} else if (comparison > 0) {
+j++;
+} else {
+break;
+}
+}
+if (i < infoFromRanges.size()) {
+error(infoFromLVT, infoFromRanges);
+}
+}
+List<String> convertToStringList(AliveRanges ranges) {
+List<String> result = new ArrayList<>();
+for (Annotation anno : ranges.value()) {
+AliveRange range = (AliveRange)anno;
+String str = formatLocalVariableData(range.varName(),
+range.bytecodeStart(), range.bytecodeLength());
+result.add(str);
+}
+Collections.sort(result);
+return result;
+}
+List<String> convertToStringList(ConstantPool constantPool,
+LocalVariableTable_attribute lvt) throws InvalidIndex, UnexpectedEntry {
+List<String> result = new ArrayList<>();
+for (Entry entry : lvt.local_variable_table) {
+String str = formatLocalVariableData(constantPool.getUTF8Value(entry.name_index),
+entry.start_pc, entry.length);
+result.add(str);
+}
+Collections.sort(result);
+return result;
+}
+String formatLocalVariableData(String varName, int start, int length) {
+StringBuilder sb = new StringBuilder()
+.append("var name: ").append(varName)
+.append(" start: ").append(start)
+.append(" length: ").append(length);
+return sb.toString();
+}
+protected void error(List<String> infoFromLVT, List<String> infoFromRanges) {
+nerrors++;
+System.err.printf("Error occurred while checking file: %s\n", jfo.getName());
+System.err.println("The range info from the annotations is");
+printStringListToErrOutput(infoFromRanges);
+System.err.println();
+System.err.println("And the range info from the class file is");
+printStringListToErrOutput(infoFromLVT);
+System.err.println();
+}
+void printStringListToErrOutput(List<String> list) {
+for (String s : list) {
+System.err.println("\t" + s);
+}
+}
+protected void error(String msg) {
+nerrors++;
+System.err.printf("Error occurred while checking file: %s\nreason: %s\n",
+jfo.getName(), msg);
+}
+class AliveRangeFinder extends JavacTestingAbstractProcessor {
+@Override
+public boolean process(Set<? extends TypeElement> annotations,
+RoundEnvironment roundEnv) {
+if (roundEnv.processingOver())
+return true;
+TypeElement aliveRangeAnno = elements.getTypeElement("AliveRanges");
+if (!annotations.contains(aliveRangeAnno)) {
+error("no @AliveRanges annotation found in test class");
+}
+for (Element elem: roundEnv.getElementsAnnotatedWith(aliveRangeAnno)) {
+Annotation annotation = elem.getAnnotation(AliveRanges.class);
+aliveRangeMap.put(new ElementKey(elem), (AliveRanges)annotation);
+}
+return true;
+}
+}
+class ElementKey {
+String key;
+Element elem;
+public ElementKey(Element elem) {
+this.elem = elem;
+this.key = computeKey(elem);
+}
+@Override
+public boolean equals(Object obj) {
+if (obj instanceof ElementKey) {
+ElementKey other = (ElementKey)obj;
+return other.key.equals(key);
+}
+return false;
+}
+@Override
+public int hashCode() {
+return key.hashCode();
+}
+String computeKey(Element e) {
+StringBuilder buf = new StringBuilder();
+while (e != null) {
+buf.append(e.toString());
+e = e.getEnclosingElement();
+}
+buf.append(jfo.getName());
+return buf.toString();
+}
+@Override
+public String toString() {
+return "Key{" + key + "}";
+}
+}
+}

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: test/tools/javac/flow/LVTHarness.java

test/tools/javac/flow/LVTHarness.java