1 /* 2 * Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package sun.reflect; 27 28 import java.lang.reflect.*; 29 30 /** Provides reflective access to the constant pools of classes. 31 Currently this is needed to provide reflective access to annotations 32 but may be used by other internal subsystems in the future. */ 33 34 public class ConstantPool { 35 // Number of entries in this constant pool (= maximum valid constant pool index) 36 public int getSize() { return getSize0 (constantPoolOop); } 37 public Class<?> getClassAt (int index) { return getClassAt0 (constantPoolOop, index); } 38 public Class<?> getClassAtIfLoaded (int index) { return getClassAtIfLoaded0 (constantPoolOop, index); } 39 // Returns either a Method or Constructor. 40 // Static initializers are returned as Method objects. 41 public Member getMethodAt (int index) { return getMethodAt0 (constantPoolOop, index); } 42 public Member getMethodAtIfLoaded(int index) { return getMethodAtIfLoaded0(constantPoolOop, index); } 43 public Field getFieldAt (int index) { return getFieldAt0 (constantPoolOop, index); } 44 public Field getFieldAtIfLoaded (int index) { return getFieldAtIfLoaded0 (constantPoolOop, index); } 45 // Fetches the class name, member (field, method or interface 46 // method) name, and type descriptor as an array of three Strings 47 public String[] getMemberRefInfoAt (int index) { return getMemberRefInfoAt0 (constantPoolOop, index); } 48 // Fetches the name and type from name_and_type index as an array of two Strings 49 public String[] getNameAndTypeRefInfoAt 50 (int index) { return getNameAndTypeRefInfoAt0 (constantPoolOop, index); } 51 // Fetches the invokedynamic name and type descriptor as an array of two Strings 52 public String[] getInvokedynamicRefInfoAt 53 (int index) { return getInvokedynamicRefInfoAt0 (constantPoolOop, index); } 54 public int getIntAt (int index) { return getIntAt0 (constantPoolOop, index); } 55 public long getLongAt (int index) { return getLongAt0 (constantPoolOop, index); } 56 public float getFloatAt (int index) { return getFloatAt0 (constantPoolOop, index); } 57 public double getDoubleAt (int index) { return getDoubleAt0 (constantPoolOop, index); } 58 public String getStringAt (int index) { return getStringAt0 (constantPoolOop, index); } 59 public String getUTF8At (int index) { return getUTF8At0 (constantPoolOop, index); } 60 public Tag getTagAt (int index) { return Tag.valueOf( 61 getTagAt0 (constantPoolOop, index));} 62 63 public static enum Tag { 64 UTF8, 65 INTEGER, 66 FLOAT, 67 LONG, 68 DOUBLE, 69 CLASS, 70 STRING, 71 FIELDREF, 72 METHODREF, 73 INTERFACEMETHODREF, 74 NAMEANDTYPE, 75 METHODHANDLE, 76 METHODTYPE, 77 INVOKEDYNAMIC, 78 INVALID, 79 UNRESOLVED_CLASS, 80 CLASS_INDEX, 81 STRING_INDEX, 82 UNRESOLVED_CLASS_IN_ERROR, 83 METHODHANDLE_IN_ERROR, 84 METHODTYPE_IN_ERROR; 85 86 private static Tag valueOf(byte v) { 87 switch (v) { 88 case 0: return INVALID; 89 case 1: return UTF8; 90 case 3: return INTEGER; 91 case 4: return FLOAT; 92 case 5: return LONG; 93 case 6: return DOUBLE; 94 case 7: return CLASS; 95 case 8: return STRING; 96 case 9: return FIELDREF; 97 case 10: return METHODREF; 98 case 11: return INTERFACEMETHODREF; 99 case 12: return NAMEANDTYPE; 100 case 15: return METHODHANDLE; 101 case 16: return METHODTYPE; 102 case 18: return INVOKEDYNAMIC; 103 // The tags 100 - 105 are hotspot specific ones 104 // (not from JVM spec) used in constantTag.hpp 105 case 100: return UNRESOLVED_CLASS; 106 case 101: return CLASS_INDEX; 107 case 102: return STRING_INDEX; 108 case 103: return UNRESOLVED_CLASS_IN_ERROR; 109 case 104: return METHODHANDLE_IN_ERROR; 110 case 105: return METHODTYPE_IN_ERROR; 111 default: 112 throw new IllegalArgumentException("Unknown constant pool tag " + v); 113 } 114 } 115 } 116 //--------------------------------------------------------------------------- 117 // Internals only below this point 118 // 119 120 static { 121 Reflection.registerFieldsToFilter(ConstantPool.class, new String[] { "constantPoolOop" }); 122 } 123 124 // HotSpot-internal constant pool object (set by the VM, name known to the VM) 125 private Object constantPoolOop; 126 127 private native int getSize0 (Object constantPoolOop); 128 private native Class<?> getClassAt0 (Object constantPoolOop, int index); 129 private native Class<?> getClassAtIfLoaded0 (Object constantPoolOop, int index); 130 private native Member getMethodAt0 (Object constantPoolOop, int index); 131 private native Member getMethodAtIfLoaded0(Object constantPoolOop, int index); 132 private native Field getFieldAt0 (Object constantPoolOop, int index); 133 private native Field getFieldAtIfLoaded0 (Object constantPoolOop, int index); 134 private native String[] getMemberRefInfoAt0 (Object constantPoolOop, int index); 135 private native String[] getNameAndTypeRefInfoAt0 136 (Object constantPoolOop, int index); 137 private native String[] getInvokedynamicRefInfoAt0 138 (Object constantPoolOop, int index); 139 private native int getIntAt0 (Object constantPoolOop, int index); 140 private native long getLongAt0 (Object constantPoolOop, int index); 141 private native float getFloatAt0 (Object constantPoolOop, int index); 142 private native double getDoubleAt0 (Object constantPoolOop, int index); 143 private native String getStringAt0 (Object constantPoolOop, int index); 144 private native String getUTF8At0 (Object constantPoolOop, int index); 145 private native byte getTagAt0 (Object constantPoolOop, int index); 146 }