/*
* Copyright (c) 2016, 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 8140450
* @summary Basic test for the StackWalker::getByteCodeIndex method
* @modules jdk.jdeps/com.sun.tools.classfile
* @run main TestBCI
*/
import com.sun.tools.classfile.Attribute;
import com.sun.tools.classfile.ClassFile;
import com.sun.tools.classfile.Code_attribute;
import com.sun.tools.classfile.ConstantPoolException;
import com.sun.tools.classfile.Descriptor;
import com.sun.tools.classfile.LineNumberTable_attribute;
import com.sun.tools.classfile.Method;
import java.lang.StackWalker.StackFrame;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.function.Function;
import java.util.stream.Collectors;
import static java.lang.StackWalker.Option.RETAIN_CLASS_REFERENCE;
public class TestBCI {
public static void main(String... args) throws Exception {
TestBCI test = new TestBCI(Walker.class);
System.out.println("Line number table:");
test.methods.values().stream()
.sorted(Comparator.comparing(MethodInfo::name).reversed())
.forEach(System.out::println);
// walk the stack
test.walk();
}
private final Map<String, MethodInfo> methods;
private final Class<?> clazz;
TestBCI(Class<?> c) throws ConstantPoolException, IOException {
Map<String, MethodInfo> methods;
String filename = c.getName().replace('.', '/') + ".class";
try (InputStream in = c.getResourceAsStream(filename)) {
ClassFile cf = ClassFile.read(in);
methods = Arrays.stream(cf.methods)
.map(m -> new MethodInfo(cf, m))
.collect(Collectors.toMap(MethodInfo::name, Function.identity()));
}
this.clazz = c;
this.methods = methods;
}
void walk() {
Walker walker = new Walker();
walker.m1();
}
void verify(StackFrame frame) {
if (frame.getDeclaringClass() != clazz)
return;
int bci = frame.getByteCodeIndex();
int lineNumber = frame.getLineNumber();
System.out.format("%s.%s bci %d (%s:%d)%n",
frame.getClassName(), frame.getMethodName(), bci,
frame.getFileName(), lineNumber);
MethodInfo method = methods.get(frame.getMethodName());
SortedSet<Integer> values = method.findLineNumbers(bci).get();
if (!values.contains(lineNumber)) {
throw new RuntimeException("line number for bci: " + bci + " "
+ lineNumber + " not matched line number table: " + values);
}
}
/*
* BCIs in the execution stack when StackWalker::forEach is invoked
* will cover BCI range in the line number table.
*/
class Walker {
final StackWalker walker = StackWalker.getInstance(RETAIN_CLASS_REFERENCE);
void m1() {
int i = (int)Math.random()+2;
m2(i*2);
}
void m2(int i) {
i++;
m3(i);
}
void m3(int i) {
i++; m4(i++);
}
int m4(int i) {
walker.forEach(TestBCI.this::verify);
return i;
}
}
static class MethodInfo {
final Method method;
final String name;
final String paramTypes;
final String returnType;
final Map<Integer, SortedSet<Integer>> bciToLineNumbers = new HashMap<>();
MethodInfo(ClassFile cf, Method m) {
this.method = m;
String name;
String paramTypes;
String returnType;
LineNumberTable_attribute.Entry[] lineNumberTable;
try {
// method name
name = m.getName(cf.constant_pool);
// signature
paramTypes = m.descriptor.getParameterTypes(cf.constant_pool);
returnType = m.descriptor.getReturnType(cf.constant_pool);
Code_attribute codeAttr = (Code_attribute)
m.attributes.get(Attribute.Code);
lineNumberTable = ((LineNumberTable_attribute)
codeAttr.attributes.get(Attribute.LineNumberTable)).line_number_table;
} catch (ConstantPoolException|Descriptor.InvalidDescriptor e) {
throw new RuntimeException(e);
}
this.name = name;
this.paramTypes = paramTypes;
this.returnType = returnType;
Arrays.stream(lineNumberTable).forEach(entry ->
bciToLineNumbers.computeIfAbsent(entry.start_pc, _n -> new TreeSet<>())
.add(entry.line_number));
}
String name() {
return name;
}
Optional<SortedSet<Integer>> findLineNumbers(int value) {
return bciToLineNumbers.entrySet().stream()
.sorted(Map.Entry.comparingByKey(Comparator.reverseOrder()))
.filter(e -> e.getKey().intValue() <= value)
.map(Map.Entry::getValue)
.findFirst();
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(name);
sb.append(paramTypes).append(returnType).append(" ");
bciToLineNumbers.entrySet().stream()
.sorted(Map.Entry.comparingByKey())
.forEach(entry -> sb.append("bci:").append(entry.getKey()).append(" ")
.append(entry.getValue()).append(" "));
return sb.toString();
}
}
}