< prev index next >

src/jdk.jdeps/share/classes/com/sun/tools/javap/AttributeWriter.java

Print this page
*** 30,10 ***
--- 30,11 ---
  import java.lang.classfile.Attributes;
  import java.lang.classfile.Signature;
  import java.lang.classfile.TypeAnnotation;
  import java.lang.classfile.attribute.*;
  import java.lang.classfile.constantpool.ModuleEntry;
+ import java.lang.classfile.constantpool.NameAndTypeEntry;
  import java.lang.classfile.constantpool.PoolEntry;
  import java.lang.classfile.constantpool.Utf8Entry;
  import java.lang.reflect.AccessFlag;
  import java.lang.reflect.ClassFileFormatVersion;
  import java.lang.reflect.Modifier;

*** 44,10 ***
--- 45,13 ---
  import static java.lang.classfile.ClassFile.ACC_MANDATED;
  import static java.lang.classfile.ClassFile.ACC_SYNTHETIC;
  import static java.lang.classfile.attribute.StackMapFrameInfo.*;
  import static java.lang.classfile.instruction.CharacterRange.*;
  
+ import com.sun.tools.javac.util.Assert;
+ import com.sun.tools.javac.util.StringUtils;
+ 
  /*
   *  A writer for writing Attributes as text.
   *
   *  <p><b>This is NOT part of any supported API.
   *  If you write code that depends on this, you do so at your own risk.

*** 64,10 ***
--- 68,11 ---
      }
  
      protected AttributeWriter(Context context) {
          super(context);
          context.put(AttributeWriter.class, this);
+         classWriter = ClassWriter.instance(context);
          annotationWriter = AnnotationWriter.instance(context);
          codeWriter = CodeWriter.instance(context);
          constantWriter = ConstantWriter.instance(context);
          options = Options.instance(context);
      }

*** 216,11 ***
                          if (first) {
                              println("InnerClasses:");
                              indent(+1);
                              first = false;
                          }
!                         for (var flag : maskToAccessFlagsReportUnknown(access_flags, AccessFlag.Location.INNER_CLASS, cffv)) {
                              if (flag.sourceModifier() && (flag != AccessFlag.ABSTRACT
                                      || !info.has(AccessFlag.INTERFACE))) {
                                  print(Modifier.toString(flag.mask()) + " ");
                              }
                          }
--- 221,12 ---
                          if (first) {
                              println("InnerClasses:");
                              indent(+1);
                              first = false;
                          }
!                         var flagSet = maskToAccessFlagsReportUnknown(access_flags, AccessFlag.Location.INNER_CLASS, cffv);
+                         for (var flag : flagSet) {
                              if (flag.sourceModifier() && (flag != AccessFlag.ABSTRACT
                                      || !info.has(AccessFlag.INTERFACE))) {
                                  print(Modifier.toString(flag.mask()) + " ");
                              }
                          }

*** 241,10 ***
--- 247,16 ---
                          if (info.outerClass().isPresent()) {
                              print(" of ");
                              constantWriter.write(info.outerClass().get().index());
                          }
                          println();
+                         if (options.verbose) {
+                             indent(1);
+                             classWriter.writeList(String.format("flags: (0x%04x) ", access_flags),
+                                     flagSet, "\n");
+                             indent(-1);
+                         }
                      }
                  }
                  if (!first)
                      indent(-1);
              }

*** 532,10 ***
--- 544,18 ---
                  for (var sc : attr.permittedSubclasses()) {
                      println(constantWriter.stringValue(sc));
                  }
                  indent(-1);
              }
+             case LoadableDescriptorsAttribute attr -> {
+                 println("LoadableDescriptors:");
+                 indent(+1);
+                 for (var sc : attr.loadableDescriptors()) {
+                     println(constantWriter.stringValue(sc));
+                 }
+                 indent(-1);
+             }
              case SignatureAttribute attr -> {
                  print("Signature: #" + attr.signature().index());
                  tab();
                  println("// " + attr.signature().stringValue());
              }

*** 567,12 ***
                          printMap("stack", frame.stack(), lr);
                          indent(-1);
                      } else {
                          int offsetDelta = lr.labelToBci(frame.target()) - lastOffset - 1;
                          switch (frameType) {
                              case 247 -> {
!                                 printHeader(frameType, "/* same_locals_1_stack_item_frame_extended */");
                                  indent(+1);
                                  println("offset_delta = " + offsetDelta);
                                  printMap("stack", frame.stack(), lr);
                                  indent(-1);
                              }
--- 587,31 ---
                          printMap("stack", frame.stack(), lr);
                          indent(-1);
                      } else {
                          int offsetDelta = lr.labelToBci(frame.target()) - lastOffset - 1;
                          switch (frameType) {
+                             case 246 -> {
+                                 printHeader(frameType, "/* early_larval */");
+                                 indent(+1);
+                                 println("number of unset_fields = " + frame.unsetFields().size());
+                                     indent(+1);
+                                     for (NameAndTypeEntry field : frame.unsetFields()) {
+                                         print("unset_field = #");
+                                         constantWriter.write(field.index());
+                                         println();
+                                     }
+                                     // temporary: print the nested contents of early larval
+                                     indent(+1);
+                                     println("offset_delta = " + offsetDelta);
+                                     printMap("locals", frame.locals(), lr);
+                                     printMap("stack", frame.stack(), lr);
+                                     indent(-1);
+                                     indent(-1);
+                                 indent(-1);
+                             }
                              case 247 -> {
!                                 printHeader(frameType, "/* same_locals_1_stack_item_entry_extended */");
                                  indent(+1);
                                  println("offset_delta = " + offsetDelta);
                                  printMap("stack", frame.stack(), lr);
                                  indent(-1);
                              }

*** 581,11 ***
                                  indent(+1);
                                  println("offset_delta = " + offsetDelta);
                                  indent(-1);
                              }
                              case 251 -> {
!                                 printHeader(frameType, "/* same_frame_extended */");
                                  indent(+1);
                                  println("offset_delta = " + offsetDelta);
                                  indent(-1);
                              }
                              case 252, 253, 254 -> {
--- 620,11 ---
                                  indent(+1);
                                  println("offset_delta = " + offsetDelta);
                                  indent(-1);
                              }
                              case 251 -> {
!                                 printHeader(frameType, "/* same_entry_extended */");
                                  indent(+1);
                                  println("offset_delta = " + offsetDelta);
                                  indent(-1);
                              }
                              case 252, 253, 254 -> {

*** 596,11 ***
                                  printMap("locals", locals.subList(locals.size()
                                          - frameType + 251, locals.size()), lr);
                                  indent(-1);
                              }
                              case 255 -> {
!                                 printHeader(frameType, "/* full_frame */");
                                  indent(+1);
                                  println("offset_delta = " + offsetDelta);
                                  printMap("locals", frame.locals(), lr);
                                  printMap("stack", frame.stack(), lr);
                                  indent(-1);
--- 635,11 ---
                                  printMap("locals", locals.subList(locals.size()
                                          - frameType + 251, locals.size()), lr);
                                  indent(-1);
                              }
                              case 255 -> {
!                                 printHeader(frameType, "/* full_entry */");
                                  indent(+1);
                                  println("offset_delta = " + offsetDelta);
                                  printMap("locals", frame.locals(), lr);
                                  printMap("stack", frame.stack(), lr);
                                  indent(-1);

*** 750,10 ***
--- 789,11 ---
              sb.append(String.format("%02x", b & 0xff));
          }
          return sb.toString();
      }
  
+     private final ClassWriter classWriter;
      private final AnnotationWriter annotationWriter;
      private final CodeWriter codeWriter;
      private final ConstantWriter constantWriter;
      private final Options options;
  }
< prev index next >