src/java.base/share/classes/sun/reflect/ConstantPool.java

@@ -1,7 +1,7 @@
 /*
- * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2015, 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.  Oracle designates this

@@ -43,17 +43,78 @@
   public Field    getFieldAt         (int index) { return getFieldAt0         (constantPoolOop, index); }
   public Field    getFieldAtIfLoaded (int index) { return getFieldAtIfLoaded0 (constantPoolOop, index); }
   // Fetches the class name, member (field, method or interface
   // method) name, and type descriptor as an array of three Strings
   public String[] getMemberRefInfoAt (int index) { return getMemberRefInfoAt0 (constantPoolOop, index); }
+  // Fetches the name and type from name_and_type index as an array of two Strings
+  public String[] getNameAndTypeRefInfoAt
+                                     (int index) { return getNameAndTypeRefInfoAt0 (constantPoolOop, index); }
+  // Fetches the invokedynamic name and type descriptor as an array of two Strings
+  public String[] getInvokedynamicRefInfoAt
+                                     (int index) { return getInvokedynamicRefInfoAt0 (constantPoolOop, index); }
   public int      getIntAt           (int index) { return getIntAt0           (constantPoolOop, index); }
   public long     getLongAt          (int index) { return getLongAt0          (constantPoolOop, index); }
   public float    getFloatAt         (int index) { return getFloatAt0         (constantPoolOop, index); }
   public double   getDoubleAt        (int index) { return getDoubleAt0        (constantPoolOop, index); }
   public String   getStringAt        (int index) { return getStringAt0        (constantPoolOop, index); }
   public String   getUTF8At          (int index) { return getUTF8At0          (constantPoolOop, index); }
+  public Tag      getTagAt           (int index) { return Tag.valueOf(
+                                                          getTagAt0           (constantPoolOop, index));}
 
+  public static enum Tag {
+      UTF8,
+      INTEGER,
+      FLOAT,
+      LONG,
+      DOUBLE,
+      CLASS,
+      STRING,
+      FIELDREF,
+      METHODREF,
+      INTERFACEMETHODREF,
+      NAMEANDTYPE,
+      METHODHANDLE,
+      METHODTYPE,
+      INVOKEDYNAMIC,
+      INVALID,
+      UNRESOLVED_CLASS,
+      CLASS_INDEX,
+      STRING_INDEX,
+      UNRESOLVED_CLASS_IN_ERROR,
+      METHODHANDLE_IN_ERROR,
+      METHODTYPE_IN_ERROR;
+
+      private static Tag valueOf(byte v) {
+          switch (v) {
+              case   0: return INVALID;
+              case   1: return UTF8;
+              case   3: return INTEGER;
+              case   4: return FLOAT;
+              case   5: return LONG;
+              case   6: return DOUBLE;
+              case   7: return CLASS;
+              case   8: return STRING;
+              case   9: return FIELDREF;
+              case  10: return METHODREF;
+              case  11: return INTERFACEMETHODREF;
+              case  12: return NAMEANDTYPE;
+              case  15: return METHODHANDLE;
+              case  16: return METHODTYPE;
+              case  18: return INVOKEDYNAMIC;
+              // The tags 100 - 105 are hotspot specific ones
+              // (not from JVM spec) used in constantTag.hpp
+              case 100: return UNRESOLVED_CLASS;
+              case 101: return CLASS_INDEX;
+              case 102: return STRING_INDEX;
+              case 103: return UNRESOLVED_CLASS_IN_ERROR;
+              case 104: return METHODHANDLE_IN_ERROR;
+              case 105: return METHODTYPE_IN_ERROR;
+              default:
+                  throw new IllegalArgumentException("Unknown constant pool tag " + v);
+          }
+      }
+   }
   //---------------------------------------------------------------------------
   // Internals only below this point
   //
 
   static {

@@ -69,12 +130,17 @@
   private native Member   getMethodAt0        (Object constantPoolOop, int index);
   private native Member   getMethodAtIfLoaded0(Object constantPoolOop, int index);
   private native Field    getFieldAt0         (Object constantPoolOop, int index);
   private native Field    getFieldAtIfLoaded0 (Object constantPoolOop, int index);
   private native String[] getMemberRefInfoAt0 (Object constantPoolOop, int index);
+  private native String[] getNameAndTypeRefInfoAt0
+                                              (Object constantPoolOop, int index);
+  private native String[] getInvokedynamicRefInfoAt0
+                                              (Object constantPoolOop, int index);
   private native int      getIntAt0           (Object constantPoolOop, int index);
   private native long     getLongAt0          (Object constantPoolOop, int index);
   private native float    getFloatAt0         (Object constantPoolOop, int index);
   private native double   getDoubleAt0        (Object constantPoolOop, int index);
   private native String   getStringAt0        (Object constantPoolOop, int index);
   private native String   getUTF8At0          (Object constantPoolOop, int index);
+  private native byte     getTagAt0           (Object constantPoolOop, int index);
 }