1 /* 2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 3 * 4 * This code is free software; you can redistribute it and/or modify it 5 * under the terms of the GNU General Public License version 2 only, as 6 * published by the Free Software Foundation. Oracle designates this 7 * particular file as subject to the "Classpath" exception as provided 8 * by Oracle in the LICENSE file that accompanied this code. 9 * 10 * This code is distributed in the hope that it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 13 * version 2 for more details (a copy is included in the LICENSE file that 14 * accompanied this code). 15 * 16 * You should have received a copy of the GNU General Public License version 17 * 2 along with this work; if not, write to the Free Software Foundation, 18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 19 * 20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 21 * or visit www.oracle.com if you need additional information or have any 22 * questions. 23 */ 24 25 /* 26 * This file is available under and governed by the GNU General Public 27 * License version 2 only, as published by the Free Software Foundation. 28 * However, the following notice accompanied the original version of this 29 * file: 30 * 31 * ASM: a very small and fast Java bytecode manipulation framework 32 * Copyright (c) 2000-2011 INRIA, France Telecom 33 * All rights reserved. 34 * 35 * Redistribution and use in source and binary forms, with or without 36 * modification, are permitted provided that the following conditions 37 * are met: 38 * 1. Redistributions of source code must retain the above copyright 39 * notice, this list of conditions and the following disclaimer. 40 * 2. Redistributions in binary form must reproduce the above copyright 41 * notice, this list of conditions and the following disclaimer in the 42 * documentation and/or other materials provided with the distribution. 43 * 3. Neither the name of the copyright holders nor the names of its 44 * contributors may be used to endorse or promote products derived from 45 * this software without specific prior written permission. 46 * 47 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 48 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 49 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 50 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 51 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 52 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 53 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 54 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 55 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 56 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 57 * THE POSSIBILITY OF SUCH DAMAGE. 58 */ 59 package jdk.internal.org.objectweb.asm; 60 61 /** 62 * A constant pool item. Constant pool items can be created with the 'newXXX' 63 * methods in the {@link ClassWriter} class. 64 * 65 * @author Eric Bruneton 66 */ 67 final class Item { 68 69 /** 70 * Index of this item in the constant pool. 71 */ 72 int index; 73 74 /** 75 * Type of this constant pool item. A single class is used to represent all 76 * constant pool item types, in order to minimize the bytecode size of this 77 * package. The value of this field is one of {@link ClassWriter#INT}, 78 * {@link ClassWriter#LONG}, {@link ClassWriter#FLOAT}, 79 * {@link ClassWriter#DOUBLE}, {@link ClassWriter#UTF8}, 80 * {@link ClassWriter#STR}, {@link ClassWriter#CLASS}, 81 * {@link ClassWriter#NAME_TYPE}, {@link ClassWriter#FIELD}, 82 * {@link ClassWriter#METH}, {@link ClassWriter#IMETH}, 83 * {@link ClassWriter#MODULE}, {@link ClassWriter#PACKAGE}, 84 * {@link ClassWriter#MTYPE}, {@link ClassWriter#INDY}. 85 * 86 * MethodHandle constant 9 variations are stored using a range of 9 values 87 * from {@link ClassWriter#HANDLE_BASE} + 1 to 88 * {@link ClassWriter#HANDLE_BASE} + 9. 89 * 90 * Special Item types are used for Items that are stored in the ClassWriter 91 * {@link ClassWriter#typeTable}, instead of the constant pool, in order to 92 * avoid clashes with normal constant pool items in the ClassWriter constant 93 * pool's hash table. These special item types are 94 * {@link ClassWriter#TYPE_NORMAL}, {@link ClassWriter#TYPE_UNINIT} and 95 * {@link ClassWriter#TYPE_MERGED}. 96 */ 97 int type; 98 99 /** 100 * Value of this item, for an integer item. 101 */ 102 int intVal; 103 104 /** 105 * Value of this item, for a long item. 106 */ 107 long longVal; 108 109 /** 110 * First part of the value of this item, for items that do not hold a 111 * primitive value. 112 */ 113 String strVal1; 114 115 /** 116 * Second part of the value of this item, for items that do not hold a 117 * primitive value. 118 */ 119 String strVal2; 120 121 /** 122 * Third part of the value of this item, for items that do not hold a 123 * primitive value. 124 */ 125 String strVal3; 126 127 /** 128 * The hash code value of this constant pool item. 129 */ 130 int hashCode; 131 132 /** 133 * Link to another constant pool item, used for collision lists in the 134 * constant pool's hash table. 135 */ 136 Item next; 137 138 /** 139 * Constructs an uninitialized {@link Item}. 140 */ 141 Item() { 142 } 143 144 /** 145 * Constructs an uninitialized {@link Item} for constant pool element at 146 * given position. 147 * 148 * @param index 149 * index of the item to be constructed. 150 */ 151 Item(final int index) { 152 this.index = index; 153 } 154 155 /** 156 * Constructs a copy of the given item. 157 * 158 * @param index 159 * index of the item to be constructed. 160 * @param i 161 * the item that must be copied into the item to be constructed. 162 */ 163 Item(final int index, final Item i) { 164 this.index = index; 165 type = i.type; 166 intVal = i.intVal; 167 longVal = i.longVal; 168 strVal1 = i.strVal1; 169 strVal2 = i.strVal2; 170 strVal3 = i.strVal3; 171 hashCode = i.hashCode; 172 } 173 174 /** 175 * Sets this item to an integer item. 176 * 177 * @param intVal 178 * the value of this item. 179 */ 180 void set(final int intVal) { 181 this.type = ClassWriter.INT; 182 this.intVal = intVal; 183 this.hashCode = 0x7FFFFFFF & (type + intVal); 184 } 185 186 /** 187 * Sets this item to a long item. 188 * 189 * @param longVal 190 * the value of this item. 191 */ 192 void set(final long longVal) { 193 this.type = ClassWriter.LONG; 194 this.longVal = longVal; 195 this.hashCode = 0x7FFFFFFF & (type + (int) longVal); 196 } 197 198 /** 199 * Sets this item to a float item. 200 * 201 * @param floatVal 202 * the value of this item. 203 */ 204 void set(final float floatVal) { 205 this.type = ClassWriter.FLOAT; 206 this.intVal = Float.floatToRawIntBits(floatVal); 207 this.hashCode = 0x7FFFFFFF & (type + (int) floatVal); 208 } 209 210 /** 211 * Sets this item to a double item. 212 * 213 * @param doubleVal 214 * the value of this item. 215 */ 216 void set(final double doubleVal) { 217 this.type = ClassWriter.DOUBLE; 218 this.longVal = Double.doubleToRawLongBits(doubleVal); 219 this.hashCode = 0x7FFFFFFF & (type + (int) doubleVal); 220 } 221 222 /** 223 * Sets this item to an item that do not hold a primitive value. 224 * 225 * @param type 226 * the type of this item. 227 * @param strVal1 228 * first part of the value of this item. 229 * @param strVal2 230 * second part of the value of this item. 231 * @param strVal3 232 * third part of the value of this item. 233 */ 234 @SuppressWarnings("fallthrough") 235 void set(final int type, final String strVal1, final String strVal2, 236 final String strVal3) { 237 this.type = type; 238 this.strVal1 = strVal1; 239 this.strVal2 = strVal2; 240 this.strVal3 = strVal3; 241 switch (type) { 242 case ClassWriter.CLASS: 243 this.intVal = 0; // intVal of a class must be zero, see visitInnerClass 244 case ClassWriter.UTF8: 245 case ClassWriter.STR: 246 case ClassWriter.MTYPE: 247 case ClassWriter.MODULE: 248 case ClassWriter.PACKAGE: 249 case ClassWriter.TYPE_NORMAL: 250 hashCode = 0x7FFFFFFF & (type + strVal1.hashCode()); 251 return; 252 case ClassWriter.NAME_TYPE: { 253 hashCode = 0x7FFFFFFF & (type + strVal1.hashCode() 254 * strVal2.hashCode()); 255 return; 256 } 257 // ClassWriter.FIELD: 258 // ClassWriter.METH: 259 // ClassWriter.IMETH: 260 // ClassWriter.HANDLE_BASE + 1..9 261 default: 262 hashCode = 0x7FFFFFFF & (type + strVal1.hashCode() 263 * strVal2.hashCode() * strVal3.hashCode()); 264 } 265 } 266 267 /** 268 * Sets the item to an InvokeDynamic item. 269 * 270 * @param name 271 * invokedynamic's name. 272 * @param desc 273 * invokedynamic's desc. 274 * @param bsmIndex 275 * zero based index into the class attribute BootrapMethods. 276 */ 277 void set(String name, String desc, int bsmIndex) { 278 this.type = ClassWriter.INDY; 279 this.longVal = bsmIndex; 280 this.strVal1 = name; 281 this.strVal2 = desc; 282 this.hashCode = 0x7FFFFFFF & (ClassWriter.INDY + bsmIndex 283 * strVal1.hashCode() * strVal2.hashCode()); 284 } 285 286 /** 287 * Sets the item to a BootstrapMethod item. 288 * 289 * @param position 290 * position in byte in the class attribute BootrapMethods. 291 * @param hashCode 292 * hashcode of the item. This hashcode is processed from the 293 * hashcode of the bootstrap method and the hashcode of all 294 * bootstrap arguments. 295 */ 296 void set(int position, int hashCode) { 297 this.type = ClassWriter.BSM; 298 this.intVal = position; 299 this.hashCode = hashCode; 300 } 301 302 /** 303 * Indicates if the given item is equal to this one. <i>This method assumes 304 * that the two items have the same {@link #type}</i>. 305 * 306 * @param i 307 * the item to be compared to this one. Both items must have the 308 * same {@link #type}. 309 * @return <tt>true</tt> if the given item if equal to this one, 310 * <tt>false</tt> otherwise. 311 */ 312 boolean isEqualTo(final Item i) { 313 switch (type) { 314 case ClassWriter.UTF8: 315 case ClassWriter.STR: 316 case ClassWriter.CLASS: 317 case ClassWriter.MODULE: 318 case ClassWriter.PACKAGE: 319 case ClassWriter.MTYPE: 320 case ClassWriter.TYPE_NORMAL: 321 return i.strVal1.equals(strVal1); 322 case ClassWriter.TYPE_MERGED: 323 case ClassWriter.LONG: 324 case ClassWriter.DOUBLE: 325 return i.longVal == longVal; 326 case ClassWriter.INT: 327 case ClassWriter.FLOAT: 328 return i.intVal == intVal; 329 case ClassWriter.TYPE_UNINIT: 330 return i.intVal == intVal && i.strVal1.equals(strVal1); 331 case ClassWriter.NAME_TYPE: 332 return i.strVal1.equals(strVal1) && i.strVal2.equals(strVal2); 333 case ClassWriter.INDY: { 334 return i.longVal == longVal && i.strVal1.equals(strVal1) 335 && i.strVal2.equals(strVal2); 336 } 337 // case ClassWriter.FIELD: 338 // case ClassWriter.METH: 339 // case ClassWriter.IMETH: 340 // case ClassWriter.HANDLE_BASE + 1..9 341 default: 342 return i.strVal1.equals(strVal1) && i.strVal2.equals(strVal2) 343 && i.strVal3.equals(strVal3); 344 } 345 } 346 347 }