1 /* 2 * Copyright (c) 2002, 2012, 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. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 package sun.jvm.hotspot.interpreter; 26 27 import sun.jvm.hotspot.oops.*; 28 import sun.jvm.hotspot.runtime.*; 29 import sun.jvm.hotspot.utilities.*; 30 31 public class BytecodeLoadConstant extends Bytecode { BytecodeLoadConstant(Method method, int bci)32 BytecodeLoadConstant(Method method, int bci) { 33 super(method, bci); 34 } 35 hasCacheIndex()36 public boolean hasCacheIndex() { 37 // normal ldc uses CP index, but fast_aldc uses swapped CP cache index 38 return code() >= Bytecodes.number_of_java_codes; 39 } 40 rawIndex()41 int rawIndex() { 42 if (javaCode() == Bytecodes._ldc) 43 return getIndexU1(); 44 else 45 return getIndexU2(code(), false); 46 } 47 poolIndex()48 public int poolIndex() { 49 int index = rawIndex(); 50 if (hasCacheIndex()) { 51 return method().getConstants().objectToCPIndex(index); 52 } else { 53 return index; 54 } 55 } 56 cacheIndex()57 public int cacheIndex() { 58 if (hasCacheIndex()) { 59 return rawIndex(); 60 } else { 61 return -1; // no cache index 62 } 63 } 64 resultType()65 public BasicType resultType() { 66 int index = poolIndex(); 67 ConstantTag tag = method().getConstants().getTagAt(index); 68 return tag.basicType(); 69 } 70 getCachedConstant()71 private Oop getCachedConstant() { 72 int i = cacheIndex(); 73 if (i >= 0) { 74 throw new InternalError("invokedynamic not implemented yet"); 75 } 76 return null; 77 } 78 verify()79 public void verify() { 80 if (Assert.ASSERTS_ENABLED) { 81 Assert.that(isValid(), "check load constant"); 82 } 83 } 84 isValid()85 public boolean isValid() { 86 int jcode = javaCode(); 87 boolean codeOk = jcode == Bytecodes._ldc || jcode == Bytecodes._ldc_w || 88 jcode == Bytecodes._ldc2_w; 89 if (! codeOk) return false; 90 91 ConstantTag ctag = method().getConstants().getTagAt(poolIndex()); 92 if (jcode == Bytecodes._ldc2_w) { 93 // has to be double or long 94 return (ctag.isDouble() || ctag.isLong()) ? true: false; 95 } else { 96 // has to be int or float or String or Klass 97 return (ctag.isString() 98 || ctag.isUnresolvedKlass() || ctag.isKlass() 99 || ctag.isMethodHandle() || ctag.isMethodType() 100 || ctag.isInt() || ctag.isFloat())? true: false; 101 } 102 } 103 isKlassConstant()104 public boolean isKlassConstant() { 105 int jcode = javaCode(); 106 if (jcode == Bytecodes._ldc2_w) { 107 return false; 108 } 109 110 ConstantTag ctag = method().getConstants().getTagAt(poolIndex()); 111 return ctag.isKlass() || ctag.isUnresolvedKlass(); 112 } 113 114 // return Symbol (if unresolved) or Klass (if resolved) getKlass()115 public Object getKlass() { 116 if (Assert.ASSERTS_ENABLED) { 117 Assert.that(isKlassConstant(), "not a klass literal"); 118 } 119 // tag change from 'unresolved' to 'klass' does not happen atomically. 120 // We just look at the object at the corresponding index and 121 // decide based on the oop type. 122 ConstantPool cpool = method().getConstants(); 123 int cpIndex = poolIndex(); 124 ConstantPool.CPSlot oop = cpool.getSlotAt(cpIndex); 125 if (oop.isResolved()) { 126 return oop.getKlass(); 127 } else if (oop.isUnresolved()) { 128 return oop.getSymbol(); 129 } else { 130 throw new RuntimeException("should not reach here"); 131 } 132 } 133 at(Method method, int bci)134 public static BytecodeLoadConstant at(Method method, int bci) { 135 BytecodeLoadConstant b = new BytecodeLoadConstant(method, bci); 136 if (Assert.ASSERTS_ENABLED) { 137 b.verify(); 138 } 139 return b; 140 } 141 142 /** Like at, but returns null if the BCI is not at ldc or ldc_w or ldc2_w */ atCheck(Method method, int bci)143 public static BytecodeLoadConstant atCheck(Method method, int bci) { 144 BytecodeLoadConstant b = new BytecodeLoadConstant(method, bci); 145 return (b.isValid() ? b : null); 146 } 147 at(BytecodeStream bcs)148 public static BytecodeLoadConstant at(BytecodeStream bcs) { 149 return new BytecodeLoadConstant(bcs.method(), bcs.bci()); 150 } 151 getConstantValue()152 public String getConstantValue() { 153 ConstantPool cpool = method().getConstants(); 154 int cpIndex = poolIndex(); 155 ConstantTag ctag = cpool.getTagAt(cpIndex); 156 if (ctag.isInt()) { 157 return "<int " + Integer.toString(cpool.getIntAt(cpIndex)) +">"; 158 } else if (ctag.isLong()) { 159 return "<long " + Long.toString(cpool.getLongAt(cpIndex)) + "L>"; 160 } else if (ctag.isFloat()) { 161 return "<float " + Float.toString(cpool.getFloatAt(cpIndex)) + "F>"; 162 } else if (ctag.isDouble()) { 163 return "<double " + Double.toString(cpool.getDoubleAt(cpIndex)) + "D>"; 164 } else if (ctag.isString()) { 165 // tag change from 'unresolved' to 'string' does not happen atomically. 166 // We just look at the object at the corresponding index and 167 // decide based on the oop type. 168 Symbol sym = cpool.getUnresolvedStringAt(cpIndex); 169 return "<String \"" + sym.asString() + "\">"; 170 } else if (ctag.isKlass() || ctag.isUnresolvedKlass()) { 171 // tag change from 'unresolved' to 'klass' does not happen atomically. 172 // We just look at the object at the corresponding index and 173 // decide based on the oop type. 174 ConstantPool.CPSlot obj = cpool.getSlotAt(cpIndex); 175 if (obj.isResolved()) { 176 Klass k = obj.getKlass(); 177 return "<Class " + k.getName().asString() + "@" + k.getAddress() + ">"; 178 } else if (obj.isUnresolved()) { 179 Symbol sym = obj.getSymbol(); 180 return "<Class " + sym.asString() + ">"; 181 } else { 182 throw new RuntimeException("should not reach here"); 183 } 184 } else if (ctag.isMethodHandle()) { 185 Oop x = getCachedConstant(); 186 int refidx = cpool.getMethodHandleIndexAt(cpIndex); 187 int refkind = cpool.getMethodHandleRefKindAt(cpIndex); 188 return "<MethodHandle kind=" + Integer.toString(refkind) + 189 " ref=" + Integer.toString(refidx) 190 + (x == null ? "" : " @" + x.getHandle()) + ">"; 191 } else if (ctag.isMethodType()) { 192 Oop x = getCachedConstant(); 193 int refidx = cpool.getMethodTypeIndexAt(cpIndex); 194 return "<MethodType " + cpool.getSymbolAt(refidx).asString() 195 + (x == null ? "" : " @" + x.getHandle()) + ">"; 196 } else { 197 if (Assert.ASSERTS_ENABLED) { 198 Assert.that(false, "invalid load constant type"); 199 } 200 return null; 201 } 202 } 203 toString()204 public String toString() { 205 StringBuffer buf = new StringBuffer(); 206 buf.append(getJavaBytecodeName()); 207 buf.append(spaces); 208 buf.append('#'); 209 buf.append(Integer.toString(poolIndex())); 210 if (hasCacheIndex()) { 211 buf.append('('); 212 buf.append(Integer.toString(cacheIndex())); 213 buf.append(')'); 214 } 215 buf.append(spaces); 216 buf.append(getConstantValue()); 217 if (code() != javaCode()) { 218 buf.append(spaces); 219 buf.append('['); 220 buf.append(getBytecodeName()); 221 buf.append(']'); 222 } 223 return buf.toString(); 224 } 225 } 226