6855990: javap InstructionDetailWriter should support new 308 annotations attribute
Reviewed-by: mcimadamore
--- a/langtools/src/share/classes/com/sun/tools/classfile/ExtendedAnnotation.java Mon Jul 27 19:52:42 2009 -0700
+++ b/langtools/src/share/classes/com/sun/tools/classfile/ExtendedAnnotation.java Tue Jul 28 10:36:25 2009 -0700
@@ -260,9 +260,6 @@
// For generic/array types.
public List<Integer> location = new ArrayList<Integer>();
- // Tree position.
- public int pos = -1;
-
// For typecasts, type tests, new (and locals, as start_pc).
public int offset = -1;
@@ -391,9 +388,6 @@
sb.append(")");
}
- sb.append(", pos = ");
- sb.append(pos);
-
sb.append(']');
return sb.toString();
}
--- a/langtools/src/share/classes/com/sun/tools/javap/AnnotationWriter.java Mon Jul 27 19:52:42 2009 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javap/AnnotationWriter.java Tue Jul 28 10:36:25 2009 -0700
@@ -32,6 +32,10 @@
import com.sun.tools.classfile.Annotation.Class_element_value;
import com.sun.tools.classfile.Annotation.Enum_element_value;
import com.sun.tools.classfile.Annotation.Primitive_element_value;
+import com.sun.tools.classfile.ConstantPool;
+import com.sun.tools.classfile.ConstantPoolException;
+import com.sun.tools.classfile.Descriptor;
+import com.sun.tools.classfile.Descriptor.InvalidDescriptor;
/**
* A writer for writing annotations as text.
@@ -51,71 +55,243 @@
protected AnnotationWriter(Context context) {
super(context);
+ classWriter = ClassWriter.instance(context);
+ constantWriter = ConstantWriter.instance(context);
}
public void write(Annotation annot) {
- print("#" + annot.type_index + "(");
+ write(annot, false);
+ }
+
+ public void write(Annotation annot, boolean resolveIndices) {
+ writeDescriptor(annot.type_index, resolveIndices);
+ boolean showParens = annot.num_element_value_pairs > 0 || !resolveIndices;
+ if (showParens)
+ print("(");
for (int i = 0; i < annot.num_element_value_pairs; i++) {
if (i > 0)
print(",");
- write(annot.element_value_pairs[i]);
+ write(annot.element_value_pairs[i], resolveIndices);
}
- print(")");
+ if (showParens)
+ print(")");
}
public void write(ExtendedAnnotation annot) {
- write(annot.annotation);
- print('@');
- print(annot.position.toString());
+ write(annot, true, false);
+ }
+
+ public void write(ExtendedAnnotation annot, boolean showOffsets, boolean resolveIndices) {
+ write(annot.annotation, resolveIndices);
+ print(": ");
+ write(annot.position, showOffsets);
+ }
+
+ public void write(ExtendedAnnotation.Position pos, boolean showOffsets) {
+ print(pos.type);
+
+ switch (pos.type) {
+ // type case
+ case TYPECAST:
+ case TYPECAST_GENERIC_OR_ARRAY:
+ // object creation
+ case INSTANCEOF:
+ case INSTANCEOF_GENERIC_OR_ARRAY:
+ // new expression
+ case NEW:
+ case NEW_GENERIC_OR_ARRAY:
+ case NEW_TYPE_ARGUMENT:
+ case NEW_TYPE_ARGUMENT_GENERIC_OR_ARRAY:
+ if (showOffsets) {
+ print(", offset=");
+ print(pos.offset);
+ }
+ break;
+ // local variable
+ case LOCAL_VARIABLE:
+ case LOCAL_VARIABLE_GENERIC_OR_ARRAY:
+ print(", {");
+ for (int i = 0; i < pos.lvarOffset.length; ++i) {
+ if (i != 0) print("; ");
+ if (showOffsets) {
+ print(", start_pc=");
+ print(pos.lvarOffset[i]);
+ }
+ print(", length=");
+ print(pos.lvarLength[i]);
+ print(", index=");
+ print(pos.lvarIndex[i]);
+ }
+ print("}");
+ break;
+ // method receiver
+ case METHOD_RECEIVER:
+ // Do nothing
+ break;
+ // type parameters
+ case CLASS_TYPE_PARAMETER:
+ case METHOD_TYPE_PARAMETER:
+ print(", param_index=");
+ print(pos.parameter_index);
+ break;
+ // type parameters bound
+ case CLASS_TYPE_PARAMETER_BOUND:
+ case CLASS_TYPE_PARAMETER_BOUND_GENERIC_OR_ARRAY:
+ case METHOD_TYPE_PARAMETER_BOUND:
+ case METHOD_TYPE_PARAMETER_BOUND_GENERIC_OR_ARRAY:
+ print(", param_index=");
+ print(pos.parameter_index);
+ print(", bound_index=");
+ print(pos.bound_index);
+ break;
+ // wildcard
+ case WILDCARD_BOUND:
+ case WILDCARD_BOUND_GENERIC_OR_ARRAY:
+ print(", wild_card=");
+ print(pos.wildcard_position);
+ break;
+ // Class extends and implements clauses
+ case CLASS_EXTENDS:
+ case CLASS_EXTENDS_GENERIC_OR_ARRAY:
+ print(", type_index=");
+ print(pos.type_index);
+ break;
+ // throws
+ case THROWS:
+ print(", type_index=");
+ print(pos.type_index);
+ break;
+ case CLASS_LITERAL:
+ if (showOffsets) {
+ print(", offset=");
+ print(pos.offset);
+ }
+ break;
+ // method parameter: not specified
+ case METHOD_PARAMETER_GENERIC_OR_ARRAY:
+ print(", param_index=");
+ print(pos.parameter_index);
+ break;
+ // method type argument: wasn't specified
+ case METHOD_TYPE_ARGUMENT:
+ case METHOD_TYPE_ARGUMENT_GENERIC_OR_ARRAY:
+ if (showOffsets) {
+ print(", offset=");
+ print(pos.offset);
+ }
+ print(", type_index=");
+ print(pos.type_index);
+ break;
+ // We don't need to worry abut these
+ case METHOD_RETURN_GENERIC_OR_ARRAY:
+ case FIELD_GENERIC_OR_ARRAY:
+ break;
+ case UNKNOWN:
+ break;
+ default:
+ throw new AssertionError("unknown type: " + pos.type);
+ }
+
+ // Append location data for generics/arrays.
+ if (pos.type.hasLocation()) {
+ print(", location=");
+ print(pos.location);
+ }
}
public void write(Annotation.element_value_pair pair) {
- print("#" + pair.element_name_index + ":");
- write(pair.value);
+ write(pair, false);
+ }
+
+ public void write(Annotation.element_value_pair pair, boolean resolveIndices) {
+ writeIndex(pair.element_name_index, resolveIndices);
+ print("=");
+ write(pair.value, resolveIndices);
}
public void write(Annotation.element_value value) {
- ev_writer.write(value);
+ write(value, false);
+ }
+
+ public void write(Annotation.element_value value, boolean resolveIndices) {
+ ev_writer.write(value, resolveIndices);
+ }
+
+ private void writeDescriptor(int index, boolean resolveIndices) {
+ if (resolveIndices) {
+ try {
+ ConstantPool constant_pool = classWriter.getClassFile().constant_pool;
+ Descriptor d = new Descriptor(index);
+ print(d.getFieldType(constant_pool));
+ return;
+ } catch (ConstantPoolException ignore) {
+ } catch (InvalidDescriptor ignore) {
+ }
+ }
+
+ print("#" + index);
+ }
+
+ private void writeIndex(int index, boolean resolveIndices) {
+ if (resolveIndices) {
+ print(constantWriter.stringValue(index));
+ } else
+ print("#" + index);
}
element_value_Writer ev_writer = new element_value_Writer();
- class element_value_Writer implements Annotation.element_value.Visitor<Void,Void> {
- public void write(Annotation.element_value value) {
- value.accept(this, null);
+ class element_value_Writer implements Annotation.element_value.Visitor<Void,Boolean> {
+ public void write(Annotation.element_value value, boolean resolveIndices) {
+ value.accept(this, resolveIndices);
}
- public Void visitPrimitive(Primitive_element_value ev, Void p) {
- print(((char) ev.tag) + "#" + ev.const_value_index);
+ public Void visitPrimitive(Primitive_element_value ev, Boolean resolveIndices) {
+ if (resolveIndices)
+ writeIndex(ev.const_value_index, resolveIndices);
+ else
+ print(((char) ev.tag) + "#" + ev.const_value_index);
return null;
}
- public Void visitEnum(Enum_element_value ev, Void p) {
- print(((char) ev.tag) + "#" + ev.type_name_index + ".#" + ev.const_name_index);
+ public Void visitEnum(Enum_element_value ev, Boolean resolveIndices) {
+ if (resolveIndices) {
+ writeIndex(ev.type_name_index, resolveIndices);
+ print(".");
+ writeIndex(ev.const_name_index, resolveIndices);
+ } else
+ print(((char) ev.tag) + "#" + ev.type_name_index + ".#" + ev.const_name_index);
return null;
}
- public Void visitClass(Class_element_value ev, Void p) {
- print(((char) ev.tag) + "#" + ev.class_info_index);
+ public Void visitClass(Class_element_value ev, Boolean resolveIndices) {
+ if (resolveIndices) {
+ writeIndex(ev.class_info_index, resolveIndices);
+ print(".class");
+ } else
+ print(((char) ev.tag) + "#" + ev.class_info_index);
return null;
}
- public Void visitAnnotation(Annotation_element_value ev, Void p) {
+ public Void visitAnnotation(Annotation_element_value ev, Boolean resolveIndices) {
print((char) ev.tag);
- AnnotationWriter.this.write(ev.annotation_value);
+ AnnotationWriter.this.write(ev.annotation_value, resolveIndices);
return null;
}
- public Void visitArray(Array_element_value ev, Void p) {
+ public Void visitArray(Array_element_value ev, Boolean resolveIndices) {
print("[");
for (int i = 0; i < ev.num_values; i++) {
if (i > 0)
print(",");
- write(ev.values[i]);
+ write(ev.values[i], resolveIndices);
}
print("]");
return null;
}
}
+
+ private ClassWriter classWriter;
+ private ConstantWriter constantWriter;
}
--- a/langtools/src/share/classes/com/sun/tools/javap/CodeWriter.java Mon Jul 27 19:52:42 2009 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javap/CodeWriter.java Tue Jul 28 10:36:25 2009 -0700
@@ -64,6 +64,7 @@
stackMapWriter = StackMapWriter.instance(context);
localVariableTableWriter = LocalVariableTableWriter.instance(context);
localVariableTypeTableWriter = LocalVariableTypeTableWriter.instance(context);
+ typeAnnotationWriter = TypeAnnotationWriter.instance(context);
options = Options.instance(context);
}
@@ -253,6 +254,11 @@
detailWriters.add(tryBlockWriter);
}
+ if (options.details.contains(InstructionDetailWriter.Kind.TYPE_ANNOS)) {
+ typeAnnotationWriter.reset(attr);
+ detailWriters.add(typeAnnotationWriter);
+ }
+
return detailWriters;
}
@@ -261,6 +267,7 @@
private ConstantWriter constantWriter;
private LocalVariableTableWriter localVariableTableWriter;
private LocalVariableTypeTableWriter localVariableTypeTableWriter;
+ private TypeAnnotationWriter typeAnnotationWriter;
private SourceWriter sourceWriter;
private StackMapWriter stackMapWriter;
private TryBlockWriter tryBlockWriter;
--- a/langtools/src/share/classes/com/sun/tools/javap/InstructionDetailWriter.java Mon Jul 27 19:52:42 2009 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javap/InstructionDetailWriter.java Tue Jul 28 10:36:25 2009 -0700
@@ -42,7 +42,8 @@
LOCAL_VAR_TYPES("localVariableTypes"),
SOURCE("source"),
STACKMAPS("stackMaps"),
- TRY_BLOCKS("tryBlocks");
+ TRY_BLOCKS("tryBlocks"),
+ TYPE_ANNOS("typeAnnotations");
Kind(String option) {
this.option = option;
}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/src/share/classes/com/sun/tools/javap/TypeAnnotationWriter.java Tue Jul 28 10:36:25 2009 -0700
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2009 Sun Microsystems, Inc. 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. Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+package com.sun.tools.javap;
+
+import com.sun.tools.classfile.Attribute;
+import com.sun.tools.classfile.Code_attribute;
+import com.sun.tools.classfile.ExtendedAnnotation;
+import com.sun.tools.classfile.ExtendedAnnotation.Position;
+import com.sun.tools.classfile.Instruction;
+import com.sun.tools.classfile.Method;
+import com.sun.tools.classfile.RuntimeInvisibleTypeAnnotations_attribute;
+import com.sun.tools.classfile.RuntimeTypeAnnotations_attribute;
+import com.sun.tools.classfile.RuntimeVisibleTypeAnnotations_attribute;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Annotate instructions with details about type annotations.
+ *
+ * <p><b>This is NOT part of any API supported by Sun Microsystems. If
+ * you write code that depends on this, you do so at your own risk.
+ * This code and its internal interfaces are subject to change or
+ * deletion without notice.</b>
+ */
+public class TypeAnnotationWriter extends InstructionDetailWriter {
+ public enum NoteKind { VISIBLE, INVISIBLE };
+ public static class Note {
+ Note(NoteKind kind, ExtendedAnnotation anno) {
+ this.kind = kind;
+ this.anno = anno;
+ }
+ public final NoteKind kind;
+ public final ExtendedAnnotation anno;
+ }
+
+ static TypeAnnotationWriter instance(Context context) {
+ TypeAnnotationWriter instance = context.get(TypeAnnotationWriter.class);
+ if (instance == null)
+ instance = new TypeAnnotationWriter(context);
+ return instance;
+ }
+
+ protected TypeAnnotationWriter(Context context) {
+ super(context);
+ context.put(TypeAnnotationWriter.class, this);
+ annotationWriter = AnnotationWriter.instance(context);
+ classWriter = ClassWriter.instance(context);
+ }
+
+ public void reset(Code_attribute attr) {
+ Method m = classWriter.getMethod();
+ pcMap = new HashMap<Integer, List<Note>>();
+ check(NoteKind.VISIBLE, (RuntimeVisibleTypeAnnotations_attribute) m.attributes.get(Attribute.RuntimeVisibleTypeAnnotations));
+ check(NoteKind.INVISIBLE, (RuntimeInvisibleTypeAnnotations_attribute) m.attributes.get(Attribute.RuntimeInvisibleTypeAnnotations));
+ }
+
+ private void check(NoteKind kind, RuntimeTypeAnnotations_attribute attr) {
+ if (attr == null)
+ return;
+
+ for (ExtendedAnnotation anno: attr.annotations) {
+ Position p = anno.position;
+ Note note = null;
+ if (p.offset != -1)
+ addNote(p.offset, note = new Note(kind, anno));
+ if (p.lvarOffset != null) {
+ for (int i = 0; i < p.lvarOffset.length; i++) {
+ if (note == null)
+ note = new Note(kind, anno);
+ addNote(p.lvarOffset[i], note);
+ }
+ }
+ }
+ }
+
+ private void addNote(int pc, Note note) {
+ List<Note> list = pcMap.get(pc);
+ if (list == null)
+ pcMap.put(pc, list = new ArrayList<Note>());
+ list.add(note);
+ }
+
+ @Override
+ void writeDetails(Instruction instr) {
+ String indent = space(2); // get from Options?
+ int pc = instr.getPC();
+ List<Note> notes = pcMap.get(pc);
+ if (notes != null) {
+ for (Note n: notes) {
+ print(indent);
+ print("@");
+ annotationWriter.write(n.anno, false, true);
+ print(", ");
+ println(n.kind.toString().toLowerCase());
+ }
+ }
+ }
+
+ private AnnotationWriter annotationWriter;
+ private ClassWriter classWriter;
+ private Map<Integer, List<Note>> pcMap;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/javap/typeAnnotations/T6855990.java Tue Jul 28 10:36:25 2009 -0700
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+import java.io.*;
+
+/*
+ * @test
+ * @bug 6855990
+ * @summary InstructionDetailWriter should support new 308 annotations attribute
+ */
+
+public class T6855990 {
+ public static void main(String[] args) throws Exception {
+ new T6855990().run();
+ }
+
+ public void run() throws Exception {
+ @Simple String[] args = { "-c", "-XDdetails:typeAnnotations", "T6855990" };
+ StringWriter sw = new StringWriter();
+ PrintWriter pw = new PrintWriter(sw);
+ int rc = com.sun.tools.javap.Main.run(args, pw);
+ pw.close();
+ String out = sw.toString();
+ System.out.println(out);
+ if (out.indexOf("@Simple: LOCAL_VARIABLE") == -1)
+ throw new Exception("expected output not found");
+ }
+}
+
+@interface Simple { }
+