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 {@link ClassVisitor} that generates classes in bytecode form. More 63 * precisely this visitor generates a byte array conforming to the Java class 64 * file format. It can be used alone, to generate a Java class "from scratch", 65 * or with one or more {@link ClassReader ClassReader} and adapter class visitor 66 * to generate a modified class from one or more existing Java classes. 67 * 68 * @author Eric Bruneton 69 */ 70 public class ClassWriter extends ClassVisitor { 71 72 /** 73 * Flag to automatically compute the maximum stack size and the maximum 74 * number of local variables of methods. If this flag is set, then the 75 * arguments of the {@link MethodVisitor#visitMaxs visitMaxs} method of the 76 * {@link MethodVisitor} returned by the {@link #visitMethod visitMethod} 77 * method will be ignored, and computed automatically from the signature and 78 * the bytecode of each method. 79 * 80 * @see #ClassWriter(int) 81 */ 82 public static final int COMPUTE_MAXS = 1; 83 84 /** 85 * Flag to automatically compute the stack map frames of methods from 86 * scratch. If this flag is set, then the calls to the 87 * {@link MethodVisitor#visitFrame} method are ignored, and the stack map 88 * frames are recomputed from the methods bytecode. The arguments of the 89 * {@link MethodVisitor#visitMaxs visitMaxs} method are also ignored and 90 * recomputed from the bytecode. In other words, computeFrames implies 91 * computeMaxs. 92 * 93 * @see #ClassWriter(int) 94 */ 95 public static final int COMPUTE_FRAMES = 2; 96 97 /** 98 * Pseudo access flag to distinguish between the synthetic attribute and the 99 * synthetic access flag. 100 */ 101 static final int ACC_SYNTHETIC_ATTRIBUTE = 0x40000; 102 103 /** 104 * Factor to convert from ACC_SYNTHETIC_ATTRIBUTE to Opcode.ACC_SYNTHETIC. 105 */ 106 static final int TO_ACC_SYNTHETIC = ACC_SYNTHETIC_ATTRIBUTE 107 / Opcodes.ACC_SYNTHETIC; 108 109 /** 110 * The type of instructions without any argument. 111 */ 112 static final int NOARG_INSN = 0; 113 114 /** 115 * The type of instructions with an signed byte argument. 116 */ 117 static final int SBYTE_INSN = 1; 118 119 /** 120 * The type of instructions with an signed short argument. 121 */ 122 static final int SHORT_INSN = 2; 123 124 /** 125 * The type of instructions with a local variable index argument. 126 */ 127 static final int VAR_INSN = 3; 128 129 /** 130 * The type of instructions with an implicit local variable index argument. 131 */ 132 static final int IMPLVAR_INSN = 4; 133 134 /** 135 * The type of instructions with a type descriptor argument. 136 */ 137 static final int TYPE_INSN = 5; 138 139 /** 140 * The type of field and method invocations instructions. 141 */ 142 static final int FIELDORMETH_INSN = 6; 143 144 /** 145 * The type of the INVOKEINTERFACE/INVOKEDYNAMIC instruction. 146 */ 147 static final int ITFMETH_INSN = 7; 148 149 /** 150 * The type of the INVOKEDYNAMIC instruction. 151 */ 152 static final int INDYMETH_INSN = 8; 153 154 /** 155 * The type of instructions with a 2 bytes bytecode offset label. 156 */ 157 static final int LABEL_INSN = 9; 158 159 /** 160 * The type of instructions with a 4 bytes bytecode offset label. 161 */ 162 static final int LABELW_INSN = 10; 163 164 /** 165 * The type of the LDC instruction. 166 */ 167 static final int LDC_INSN = 11; 168 169 /** 170 * The type of the LDC_W and LDC2_W instructions. 171 */ 172 static final int LDCW_INSN = 12; 173 174 /** 175 * The type of the IINC instruction. 176 */ 177 static final int IINC_INSN = 13; 178 179 /** 180 * The type of the TABLESWITCH instruction. 181 */ 182 static final int TABL_INSN = 14; 183 184 /** 185 * The type of the LOOKUPSWITCH instruction. 186 */ 187 static final int LOOK_INSN = 15; 188 189 /** 190 * The type of the MULTIANEWARRAY instruction. 191 */ 192 static final int MANA_INSN = 16; 193 194 /** 195 * The type of the WIDE instruction. 196 */ 197 static final int WIDE_INSN = 17; 198 199 /** 200 * The instruction types of all JVM opcodes. 201 */ 202 static final byte[] TYPE; 203 204 /** 205 * The type of CONSTANT_Class constant pool items. 206 */ 207 static final int CLASS = 7; 208 209 /** 210 * The type of CONSTANT_Fieldref constant pool items. 211 */ 212 static final int FIELD = 9; 213 214 /** 215 * The type of CONSTANT_Methodref constant pool items. 216 */ 217 static final int METH = 10; 218 219 /** 220 * The type of CONSTANT_InterfaceMethodref constant pool items. 221 */ 222 static final int IMETH = 11; 223 224 /** 225 * The type of CONSTANT_String constant pool items. 226 */ 227 static final int STR = 8; 228 229 /** 230 * The type of CONSTANT_Integer constant pool items. 231 */ 232 static final int INT = 3; 233 234 /** 235 * The type of CONSTANT_Float constant pool items. 236 */ 237 static final int FLOAT = 4; 238 239 /** 240 * The type of CONSTANT_Long constant pool items. 241 */ 242 static final int LONG = 5; 243 244 /** 245 * The type of CONSTANT_Double constant pool items. 246 */ 247 static final int DOUBLE = 6; 248 249 /** 250 * The type of CONSTANT_NameAndType constant pool items. 251 */ 252 static final int NAME_TYPE = 12; 253 254 /** 255 * The type of CONSTANT_Utf8 constant pool items. 256 */ 257 static final int UTF8 = 1; 258 259 /** 260 * The type of CONSTANT_MethodType constant pool items. 261 */ 262 static final int MTYPE = 16; 263 264 /** 265 * The type of CONSTANT_MethodHandle constant pool items. 266 */ 267 static final int HANDLE = 15; 268 269 /** 270 * The type of CONSTANT_InvokeDynamic constant pool items. 271 */ 272 static final int INDY = 18; 273 274 /** 275 * The base value for all CONSTANT_MethodHandle constant pool items. 276 * Internally, ASM store the 9 variations of CONSTANT_MethodHandle into 9 277 * different items. 278 */ 279 static final int HANDLE_BASE = 20; 280 281 /** 282 * Normal type Item stored in the ClassWriter {@link ClassWriter#typeTable}, 283 * instead of the constant pool, in order to avoid clashes with normal 284 * constant pool items in the ClassWriter constant pool's hash table. 285 */ 286 static final int TYPE_NORMAL = 30; 287 288 /** 289 * Uninitialized type Item stored in the ClassWriter 290 * {@link ClassWriter#typeTable}, instead of the constant pool, in order to 291 * avoid clashes with normal constant pool items in the ClassWriter constant 292 * pool's hash table. 293 */ 294 static final int TYPE_UNINIT = 31; 295 296 /** 297 * Merged type Item stored in the ClassWriter {@link ClassWriter#typeTable}, 298 * instead of the constant pool, in order to avoid clashes with normal 299 * constant pool items in the ClassWriter constant pool's hash table. 300 */ 301 static final int TYPE_MERGED = 32; 302 303 /** 304 * The type of BootstrapMethods items. These items are stored in a special 305 * class attribute named BootstrapMethods and not in the constant pool. 306 */ 307 static final int BSM = 33; 308 309 /** 310 * The class reader from which this class writer was constructed, if any. 311 */ 312 ClassReader cr; 313 314 /** 315 * Minor and major version numbers of the class to be generated. 316 */ 317 int version; 318 319 /** 320 * Index of the next item to be added in the constant pool. 321 */ 322 int index; 323 324 /** 325 * The constant pool of this class. 326 */ 327 final ByteVector pool; 328 329 /** 330 * The constant pool's hash table data. 331 */ 332 Item[] items; 333 334 /** 335 * The threshold of the constant pool's hash table. 336 */ 337 int threshold; 338 339 /** 340 * A reusable key used to look for items in the {@link #items} hash table. 341 */ 342 final Item key; 343 344 /** 345 * A reusable key used to look for items in the {@link #items} hash table. 346 */ 347 final Item key2; 348 349 /** 350 * A reusable key used to look for items in the {@link #items} hash table. 351 */ 352 final Item key3; 353 354 /** 355 * A reusable key used to look for items in the {@link #items} hash table. 356 */ 357 final Item key4; 358 359 /** 360 * A type table used to temporarily store internal names that will not 361 * necessarily be stored in the constant pool. This type table is used by 362 * the control flow and data flow analysis algorithm used to compute stack 363 * map frames from scratch. This array associates to each index <tt>i</tt> 364 * the Item whose index is <tt>i</tt>. All Item objects stored in this array 365 * are also stored in the {@link #items} hash table. These two arrays allow 366 * to retrieve an Item from its index or, conversely, to get the index of an 367 * Item from its value. Each Item stores an internal name in its 368 * {@link Item#strVal1} field. 369 */ 370 Item[] typeTable; 371 372 /** 373 * Number of elements in the {@link #typeTable} array. 374 */ 375 private short typeCount; 376 377 /** 378 * The access flags of this class. 379 */ 380 private int access; 381 382 /** 383 * The constant pool item that contains the internal name of this class. 384 */ 385 private int name; 386 387 /** 388 * The internal name of this class. 389 */ 390 String thisName; 391 392 /** 393 * The constant pool item that contains the signature of this class. 394 */ 395 private int signature; 396 397 /** 398 * The constant pool item that contains the internal name of the super class 399 * of this class. 400 */ 401 private int superName; 402 403 /** 404 * Number of interfaces implemented or extended by this class or interface. 405 */ 406 private int interfaceCount; 407 408 /** 409 * The interfaces implemented or extended by this class or interface. More 410 * precisely, this array contains the indexes of the constant pool items 411 * that contain the internal names of these interfaces. 412 */ 413 private int[] interfaces; 414 415 /** 416 * The index of the constant pool item that contains the name of the source 417 * file from which this class was compiled. 418 */ 419 private int sourceFile; 420 421 /** 422 * The SourceDebug attribute of this class. 423 */ 424 private ByteVector sourceDebug; 425 426 /** 427 * The constant pool item that contains the name of the enclosing class of 428 * this class. 429 */ 430 private int enclosingMethodOwner; 431 432 /** 433 * The constant pool item that contains the name and descriptor of the 434 * enclosing method of this class. 435 */ 436 private int enclosingMethod; 437 438 /** 439 * The runtime visible annotations of this class. 440 */ 441 private AnnotationWriter anns; 442 443 /** 444 * The runtime invisible annotations of this class. 445 */ 446 private AnnotationWriter ianns; 447 448 /** 449 * The runtime visible type annotations of this class. 450 */ 451 private AnnotationWriter tanns; 452 453 /** 454 * The runtime invisible type annotations of this class. 455 */ 456 private AnnotationWriter itanns; 457 458 /** 459 * The non standard attributes of this class. 460 */ 461 private Attribute attrs; 462 463 /** 464 * The number of entries in the InnerClasses attribute. 465 */ 466 private int innerClassesCount; 467 468 /** 469 * The InnerClasses attribute. 470 */ 471 private ByteVector innerClasses; 472 473 /** 474 * The number of entries in the BootstrapMethods attribute. 475 */ 476 int bootstrapMethodsCount; 477 478 /** 479 * The BootstrapMethods attribute. 480 */ 481 ByteVector bootstrapMethods; 482 483 /** 484 * The fields of this class. These fields are stored in a linked list of 485 * {@link FieldWriter} objects, linked to each other by their 486 * {@link FieldWriter#fv} field. This field stores the first element of this 487 * list. 488 */ 489 FieldWriter firstField; 490 491 /** 492 * The fields of this class. These fields are stored in a linked list of 493 * {@link FieldWriter} objects, linked to each other by their 494 * {@link FieldWriter#fv} field. This field stores the last element of this 495 * list. 496 */ 497 FieldWriter lastField; 498 499 /** 500 * The methods of this class. These methods are stored in a linked list of 501 * {@link MethodWriter} objects, linked to each other by their 502 * {@link MethodWriter#mv} field. This field stores the first element of 503 * this list. 504 */ 505 MethodWriter firstMethod; 506 507 /** 508 * The methods of this class. These methods are stored in a linked list of 509 * {@link MethodWriter} objects, linked to each other by their 510 * {@link MethodWriter#mv} field. This field stores the last element of this 511 * list. 512 */ 513 MethodWriter lastMethod; 514 515 /** 516 * <tt>true</tt> if the maximum stack size and number of local variables 517 * must be automatically computed. 518 */ 519 private boolean computeMaxs; 520 521 /** 522 * <tt>true</tt> if the stack map frames must be recomputed from scratch. 523 */ 524 private boolean computeFrames; 525 526 /** 527 * <tt>true</tt> if the stack map tables of this class are invalid. The 528 * {@link MethodWriter#resizeInstructions} method cannot transform existing 529 * stack map tables, and so produces potentially invalid classes when it is 530 * executed. In this case the class is reread and rewritten with the 531 * {@link #COMPUTE_FRAMES} option (the resizeInstructions method can resize 532 * stack map tables when this option is used). 533 */ 534 boolean invalidFrames; 535 536 // ------------------------------------------------------------------------ 537 // Static initializer 538 // ------------------------------------------------------------------------ 539 540 /** 541 * Computes the instruction types of JVM opcodes. 542 */ 543 static { 544 int i; 545 byte[] b = new byte[220]; 546 String s = "AAAAAAAAAAAAAAAABCLMMDDDDDEEEEEEEEEEEEEEEEEEEEAAAAAAAADD" 547 + "DDDEEEEEEEEEEEEEEEEEEEEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 548 + "AAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAJJJJJJJJJJJJJJJJDOPAA" 549 + "AAAAGGGGGGGHIFBFAAFFAARQJJKKJJJJJJJJJJJJJJJJJJ"; 550 for (i = 0; i < b.length; ++i) { 551 b[i] = (byte) (s.charAt(i) - 'A'); 552 } 553 TYPE = b; 554 555 // code to generate the above string 556 // 557 // // SBYTE_INSN instructions 558 // b[Constants.NEWARRAY] = SBYTE_INSN; 559 // b[Constants.BIPUSH] = SBYTE_INSN; 560 // 561 // // SHORT_INSN instructions 562 // b[Constants.SIPUSH] = SHORT_INSN; 563 // 564 // // (IMPL)VAR_INSN instructions 565 // b[Constants.RET] = VAR_INSN; 566 // for (i = Constants.ILOAD; i <= Constants.ALOAD; ++i) { 567 // b[i] = VAR_INSN; 568 // } 569 // for (i = Constants.ISTORE; i <= Constants.ASTORE; ++i) { 570 // b[i] = VAR_INSN; 571 // } 572 // for (i = 26; i <= 45; ++i) { // ILOAD_0 to ALOAD_3 573 // b[i] = IMPLVAR_INSN; 574 // } 575 // for (i = 59; i <= 78; ++i) { // ISTORE_0 to ASTORE_3 576 // b[i] = IMPLVAR_INSN; 577 // } 578 // 579 // // TYPE_INSN instructions 580 // b[Constants.NEW] = TYPE_INSN; 581 // b[Constants.ANEWARRAY] = TYPE_INSN; 582 // b[Constants.CHECKCAST] = TYPE_INSN; 583 // b[Constants.INSTANCEOF] = TYPE_INSN; 584 // 585 // // (Set)FIELDORMETH_INSN instructions 586 // for (i = Constants.GETSTATIC; i <= Constants.INVOKESTATIC; ++i) { 587 // b[i] = FIELDORMETH_INSN; 588 // } 589 // b[Constants.INVOKEINTERFACE] = ITFMETH_INSN; 590 // b[Constants.INVOKEDYNAMIC] = INDYMETH_INSN; 591 // 592 // // LABEL(W)_INSN instructions 593 // for (i = Constants.IFEQ; i <= Constants.JSR; ++i) { 594 // b[i] = LABEL_INSN; 595 // } 596 // b[Constants.IFNULL] = LABEL_INSN; 597 // b[Constants.IFNONNULL] = LABEL_INSN; 598 // b[200] = LABELW_INSN; // GOTO_W 599 // b[201] = LABELW_INSN; // JSR_W 600 // // temporary opcodes used internally by ASM - see Label and 601 // MethodWriter 602 // for (i = 202; i < 220; ++i) { 603 // b[i] = LABEL_INSN; 604 // } 605 // 606 // // LDC(_W) instructions 607 // b[Constants.LDC] = LDC_INSN; 608 // b[19] = LDCW_INSN; // LDC_W 609 // b[20] = LDCW_INSN; // LDC2_W 610 // 611 // // special instructions 612 // b[Constants.IINC] = IINC_INSN; 613 // b[Constants.TABLESWITCH] = TABL_INSN; 614 // b[Constants.LOOKUPSWITCH] = LOOK_INSN; 615 // b[Constants.MULTIANEWARRAY] = MANA_INSN; 616 // b[196] = WIDE_INSN; // WIDE 617 // 618 // for (i = 0; i < b.length; ++i) { 619 // System.err.print((char)('A' + b[i])); 620 // } 621 // System.err.println(); 622 } 623 624 // ------------------------------------------------------------------------ 625 // Constructor 626 // ------------------------------------------------------------------------ 627 628 /** 629 * Constructs a new {@link ClassWriter} object. 630 * 631 * @param flags 632 * option flags that can be used to modify the default behavior 633 * of this class. See {@link #COMPUTE_MAXS}, 634 * {@link #COMPUTE_FRAMES}. 635 */ 636 public ClassWriter(final int flags) { 637 super(Opcodes.ASM5); 638 index = 1; 639 pool = new ByteVector(); 640 items = new Item[256]; 641 threshold = (int) (0.75d * items.length); 642 key = new Item(); 643 key2 = new Item(); 644 key3 = new Item(); 645 key4 = new Item(); 646 this.computeMaxs = (flags & COMPUTE_MAXS) != 0; 647 this.computeFrames = (flags & COMPUTE_FRAMES) != 0; 648 } 649 650 /** 651 * Constructs a new {@link ClassWriter} object and enables optimizations for 652 * "mostly add" bytecode transformations. These optimizations are the 653 * following: 654 * 655 * <ul> 656 * <li>The constant pool from the original class is copied as is in the new 657 * class, which saves time. New constant pool entries will be added at the 658 * end if necessary, but unused constant pool entries <i>won't be 659 * removed</i>.</li> 660 * <li>Methods that are not transformed are copied as is in the new class, 661 * directly from the original class bytecode (i.e. without emitting visit 662 * events for all the method instructions), which saves a <i>lot</i> of 663 * time. Untransformed methods are detected by the fact that the 664 * {@link ClassReader} receives {@link MethodVisitor} objects that come from 665 * a {@link ClassWriter} (and not from any other {@link ClassVisitor} 666 * instance).</li> 667 * </ul> 668 * 669 * @param classReader 670 * the {@link ClassReader} used to read the original class. It 671 * will be used to copy the entire constant pool from the 672 * original class and also to copy other fragments of original 673 * bytecode where applicable. 674 * @param flags 675 * option flags that can be used to modify the default behavior 676 * of this class. <i>These option flags do not affect methods 677 * that are copied as is in the new class. This means that the 678 * maximum stack size nor the stack frames will be computed for 679 * these methods</i>. See {@link #COMPUTE_MAXS}, 680 * {@link #COMPUTE_FRAMES}. 681 */ 682 public ClassWriter(final ClassReader classReader, final int flags) { 683 this(flags); 684 classReader.copyPool(this); 685 this.cr = classReader; 686 } 687 688 // ------------------------------------------------------------------------ 689 // Implementation of the ClassVisitor abstract class 690 // ------------------------------------------------------------------------ 691 692 @Override 693 public final void visit(final int version, final int access, 694 final String name, final String signature, final String superName, 695 final String[] interfaces) { 696 this.version = version; 697 this.access = access; 698 this.name = (name == null) ? 0 : newClass(name); 699 thisName = name; 700 if (ClassReader.SIGNATURES && signature != null) { 701 this.signature = newUTF8(signature); 702 } 703 this.superName = superName == null ? 0 : newClass(superName); 704 if (interfaces != null && interfaces.length > 0) { 705 interfaceCount = interfaces.length; 706 this.interfaces = new int[interfaceCount]; 707 for (int i = 0; i < interfaceCount; ++i) { 708 this.interfaces[i] = newClass(interfaces[i]); 709 } 710 } 711 } 712 713 @Override 714 public final void visitSource(final String file, final String debug) { 715 if (file != null) { 716 sourceFile = newUTF8(file); 717 } 718 if (debug != null) { 719 sourceDebug = new ByteVector().encodeUTF8(debug, 0, 720 Integer.MAX_VALUE); 721 } 722 } 723 724 @Override 725 public final void visitOuterClass(final String owner, final String name, 726 final String desc) { 727 enclosingMethodOwner = newClass(owner); 728 if (name != null && desc != null) { 729 enclosingMethod = newNameType(name, desc); 730 } 731 } 732 733 @Override 734 public final AnnotationVisitor visitAnnotation(final String desc, 735 final boolean visible) { 736 if (!ClassReader.ANNOTATIONS) { 737 return null; 738 } 739 ByteVector bv = new ByteVector(); 740 // write type, and reserve space for values count 741 bv.putShort(newUTF8(desc)).putShort(0); 742 AnnotationWriter aw = new AnnotationWriter(this, true, bv, bv, 2); 743 if (visible) { 744 aw.next = anns; 745 anns = aw; 746 } else { 747 aw.next = ianns; 748 ianns = aw; 749 } 750 return aw; 751 } 752 753 @Override 754 public final AnnotationVisitor visitTypeAnnotation(int typeRef, 755 TypePath typePath, final String desc, final boolean visible) { 756 if (!ClassReader.ANNOTATIONS) { 757 return null; 758 } 759 ByteVector bv = new ByteVector(); 760 // write target_type and target_info 761 AnnotationWriter.putTarget(typeRef, typePath, bv); 762 // write type, and reserve space for values count 763 bv.putShort(newUTF8(desc)).putShort(0); 764 AnnotationWriter aw = new AnnotationWriter(this, true, bv, bv, 765 bv.length - 2); 766 if (visible) { 767 aw.next = tanns; 768 tanns = aw; 769 } else { 770 aw.next = itanns; 771 itanns = aw; 772 } 773 return aw; 774 } 775 776 @Override 777 public final void visitAttribute(final Attribute attr) { 778 attr.next = attrs; 779 attrs = attr; 780 } 781 782 @Override 783 public final void visitInnerClass(final String name, 784 final String outerName, final String innerName, final int access) { 785 if (innerClasses == null) { 786 innerClasses = new ByteVector(); 787 } 788 // Sec. 4.7.6 of the JVMS states "Every CONSTANT_Class_info entry in the 789 // constant_pool table which represents a class or interface C that is 790 // not a package member must have exactly one corresponding entry in the 791 // classes array". To avoid duplicates we keep track in the intVal field 792 // of the Item of each CONSTANT_Class_info entry C whether an inner 793 // class entry has already been added for C (this field is unused for 794 // class entries, and changing its value does not change the hashcode 795 // and equality tests). If so we store the index of this inner class 796 // entry (plus one) in intVal. This hack allows duplicate detection in 797 // O(1) time. 798 Item nameItem = newClassItem(name); 799 if (nameItem.intVal == 0) { 800 ++innerClassesCount; 801 innerClasses.putShort(nameItem.index); 802 innerClasses.putShort(outerName == null ? 0 : newClass(outerName)); 803 innerClasses.putShort(innerName == null ? 0 : newUTF8(innerName)); 804 innerClasses.putShort(access); 805 nameItem.intVal = innerClassesCount; 806 } else { 807 // Compare the inner classes entry nameItem.intVal - 1 with the 808 // arguments of this method and throw an exception if there is a 809 // difference? 810 } 811 } 812 813 @Override 814 public final FieldVisitor visitField(final int access, final String name, 815 final String desc, final String signature, final Object value) { 816 return new FieldWriter(this, access, name, desc, signature, value); 817 } 818 819 @Override 820 public final MethodVisitor visitMethod(final int access, final String name, 821 final String desc, final String signature, final String[] exceptions) { 822 return new MethodWriter(this, access, name, desc, signature, 823 exceptions, computeMaxs, computeFrames); 824 } 825 826 @Override 827 public final void visitEnd() { 828 } 829 830 // ------------------------------------------------------------------------ 831 // Other public methods 832 // ------------------------------------------------------------------------ 833 834 /** 835 * Returns the bytecode of the class that was build with this class writer. 836 * 837 * @return the bytecode of the class that was build with this class writer. 838 */ 839 public byte[] toByteArray() { 840 if (index > 0xFFFF) { 841 throw new RuntimeException("Class file too large!"); 842 } 843 // computes the real size of the bytecode of this class 844 int size = 24 + 2 * interfaceCount; 845 int nbFields = 0; 846 FieldWriter fb = firstField; 847 while (fb != null) { 848 ++nbFields; 849 size += fb.getSize(); 850 fb = (FieldWriter) fb.fv; 851 } 852 int nbMethods = 0; 853 MethodWriter mb = firstMethod; 854 while (mb != null) { 855 ++nbMethods; 856 size += mb.getSize(); 857 mb = (MethodWriter) mb.mv; 858 } 859 int attributeCount = 0; 860 if (bootstrapMethods != null) { 861 // we put it as first attribute in order to improve a bit 862 // ClassReader.copyBootstrapMethods 863 ++attributeCount; 864 size += 8 + bootstrapMethods.length; 865 newUTF8("BootstrapMethods"); 866 } 867 if (ClassReader.SIGNATURES && signature != 0) { 868 ++attributeCount; 869 size += 8; 870 newUTF8("Signature"); 871 } 872 if (sourceFile != 0) { 873 ++attributeCount; 874 size += 8; 875 newUTF8("SourceFile"); 876 } 877 if (sourceDebug != null) { 878 ++attributeCount; 879 size += sourceDebug.length + 6; 880 newUTF8("SourceDebugExtension"); 881 } 882 if (enclosingMethodOwner != 0) { 883 ++attributeCount; 884 size += 10; 885 newUTF8("EnclosingMethod"); 886 } 887 if ((access & Opcodes.ACC_DEPRECATED) != 0) { 888 ++attributeCount; 889 size += 6; 890 newUTF8("Deprecated"); 891 } 892 if ((access & Opcodes.ACC_SYNTHETIC) != 0) { 893 if ((version & 0xFFFF) < Opcodes.V1_5 894 || (access & ACC_SYNTHETIC_ATTRIBUTE) != 0) { 895 ++attributeCount; 896 size += 6; 897 newUTF8("Synthetic"); 898 } 899 } 900 if (innerClasses != null) { 901 ++attributeCount; 902 size += 8 + innerClasses.length; 903 newUTF8("InnerClasses"); 904 } 905 if (ClassReader.ANNOTATIONS && anns != null) { 906 ++attributeCount; 907 size += 8 + anns.getSize(); 908 newUTF8("RuntimeVisibleAnnotations"); 909 } 910 if (ClassReader.ANNOTATIONS && ianns != null) { 911 ++attributeCount; 912 size += 8 + ianns.getSize(); 913 newUTF8("RuntimeInvisibleAnnotations"); 914 } 915 if (ClassReader.ANNOTATIONS && tanns != null) { 916 ++attributeCount; 917 size += 8 + tanns.getSize(); 918 newUTF8("RuntimeVisibleTypeAnnotations"); 919 } 920 if (ClassReader.ANNOTATIONS && itanns != null) { 921 ++attributeCount; 922 size += 8 + itanns.getSize(); 923 newUTF8("RuntimeInvisibleTypeAnnotations"); 924 } 925 if (attrs != null) { 926 attributeCount += attrs.getCount(); 927 size += attrs.getSize(this, null, 0, -1, -1); 928 } 929 size += pool.length; 930 // allocates a byte vector of this size, in order to avoid unnecessary 931 // arraycopy operations in the ByteVector.enlarge() method 932 ByteVector out = new ByteVector(size); 933 out.putInt(0xCAFEBABE).putInt(version); 934 out.putShort(index).putByteArray(pool.data, 0, pool.length); 935 int mask = Opcodes.ACC_DEPRECATED | ACC_SYNTHETIC_ATTRIBUTE 936 | ((access & ACC_SYNTHETIC_ATTRIBUTE) / TO_ACC_SYNTHETIC); 937 out.putShort(access & ~mask).putShort(name).putShort(superName); 938 out.putShort(interfaceCount); 939 for (int i = 0; i < interfaceCount; ++i) { 940 out.putShort(interfaces[i]); 941 } 942 out.putShort(nbFields); 943 fb = firstField; 944 while (fb != null) { 945 fb.put(out); 946 fb = (FieldWriter) fb.fv; 947 } 948 out.putShort(nbMethods); 949 mb = firstMethod; 950 while (mb != null) { 951 mb.put(out); 952 mb = (MethodWriter) mb.mv; 953 } 954 out.putShort(attributeCount); 955 if (bootstrapMethods != null) { 956 out.putShort(newUTF8("BootstrapMethods")); 957 out.putInt(bootstrapMethods.length + 2).putShort( 958 bootstrapMethodsCount); 959 out.putByteArray(bootstrapMethods.data, 0, bootstrapMethods.length); 960 } 961 if (ClassReader.SIGNATURES && signature != 0) { 962 out.putShort(newUTF8("Signature")).putInt(2).putShort(signature); 963 } 964 if (sourceFile != 0) { 965 out.putShort(newUTF8("SourceFile")).putInt(2).putShort(sourceFile); 966 } 967 if (sourceDebug != null) { 968 int len = sourceDebug.length; 969 out.putShort(newUTF8("SourceDebugExtension")).putInt(len); 970 out.putByteArray(sourceDebug.data, 0, len); 971 } 972 if (enclosingMethodOwner != 0) { 973 out.putShort(newUTF8("EnclosingMethod")).putInt(4); 974 out.putShort(enclosingMethodOwner).putShort(enclosingMethod); 975 } 976 if ((access & Opcodes.ACC_DEPRECATED) != 0) { 977 out.putShort(newUTF8("Deprecated")).putInt(0); 978 } 979 if ((access & Opcodes.ACC_SYNTHETIC) != 0) { 980 if ((version & 0xFFFF) < Opcodes.V1_5 981 || (access & ACC_SYNTHETIC_ATTRIBUTE) != 0) { 982 out.putShort(newUTF8("Synthetic")).putInt(0); 983 } 984 } 985 if (innerClasses != null) { 986 out.putShort(newUTF8("InnerClasses")); 987 out.putInt(innerClasses.length + 2).putShort(innerClassesCount); 988 out.putByteArray(innerClasses.data, 0, innerClasses.length); 989 } 990 if (ClassReader.ANNOTATIONS && anns != null) { 991 out.putShort(newUTF8("RuntimeVisibleAnnotations")); 992 anns.put(out); 993 } 994 if (ClassReader.ANNOTATIONS && ianns != null) { 995 out.putShort(newUTF8("RuntimeInvisibleAnnotations")); 996 ianns.put(out); 997 } 998 if (ClassReader.ANNOTATIONS && tanns != null) { 999 out.putShort(newUTF8("RuntimeVisibleTypeAnnotations")); 1000 tanns.put(out); 1001 } 1002 if (ClassReader.ANNOTATIONS && itanns != null) { 1003 out.putShort(newUTF8("RuntimeInvisibleTypeAnnotations")); 1004 itanns.put(out); 1005 } 1006 if (attrs != null) { 1007 attrs.put(this, null, 0, -1, -1, out); 1008 } 1009 if (invalidFrames) { 1010 anns = null; 1011 ianns = null; 1012 attrs = null; 1013 innerClassesCount = 0; 1014 innerClasses = null; 1015 bootstrapMethodsCount = 0; 1016 bootstrapMethods = null; 1017 firstField = null; 1018 lastField = null; 1019 firstMethod = null; 1020 lastMethod = null; 1021 computeMaxs = false; 1022 computeFrames = true; 1023 invalidFrames = false; 1024 new ClassReader(out.data).accept(this, ClassReader.SKIP_FRAMES); 1025 return toByteArray(); 1026 } 1027 return out.data; 1028 } 1029 1030 // ------------------------------------------------------------------------ 1031 // Utility methods: constant pool management 1032 // ------------------------------------------------------------------------ 1033 1034 /** 1035 * Adds a number or string constant to the constant pool of the class being 1036 * build. Does nothing if the constant pool already contains a similar item. 1037 * 1038 * @param cst 1039 * the value of the constant to be added to the constant pool. 1040 * This parameter must be an {@link Integer}, a {@link Float}, a 1041 * {@link Long}, a {@link Double}, a {@link String} or a 1042 * {@link Type}. 1043 * @return a new or already existing constant item with the given value. 1044 */ 1045 Item newConstItem(final Object cst) { 1046 if (cst instanceof Integer) { 1047 int val = ((Integer) cst).intValue(); 1048 return newInteger(val); 1049 } else if (cst instanceof Byte) { 1050 int val = ((Byte) cst).intValue(); 1051 return newInteger(val); 1052 } else if (cst instanceof Character) { 1053 int val = ((Character) cst).charValue(); 1054 return newInteger(val); 1055 } else if (cst instanceof Short) { 1056 int val = ((Short) cst).intValue(); 1057 return newInteger(val); 1058 } else if (cst instanceof Boolean) { 1059 int val = ((Boolean) cst).booleanValue() ? 1 : 0; 1060 return newInteger(val); 1061 } else if (cst instanceof Float) { 1062 float val = ((Float) cst).floatValue(); 1063 return newFloat(val); 1064 } else if (cst instanceof Long) { 1065 long val = ((Long) cst).longValue(); 1066 return newLong(val); 1067 } else if (cst instanceof Double) { 1068 double val = ((Double) cst).doubleValue(); 1069 return newDouble(val); 1070 } else if (cst instanceof String) { 1071 return newString((String) cst); 1072 } else if (cst instanceof Type) { 1073 Type t = (Type) cst; 1074 int s = t.getSort(); 1075 if (s == Type.OBJECT) { 1076 return newClassItem(t.getInternalName()); 1077 } else if (s == Type.METHOD) { 1078 return newMethodTypeItem(t.getDescriptor()); 1079 } else { // s == primitive type or array 1080 return newClassItem(t.getDescriptor()); 1081 } 1082 } else if (cst instanceof Handle) { 1083 Handle h = (Handle) cst; 1084 return newHandleItem(h.tag, h.owner, h.name, h.desc, h.itf); 1085 } else { 1086 throw new IllegalArgumentException("value " + cst); 1087 } 1088 } 1089 1090 /** 1091 * Adds a number or string constant to the constant pool of the class being 1092 * build. Does nothing if the constant pool already contains a similar item. 1093 * <i>This method is intended for {@link Attribute} sub classes, and is 1094 * normally not needed by class generators or adapters.</i> 1095 * 1096 * @param cst 1097 * the value of the constant to be added to the constant pool. 1098 * This parameter must be an {@link Integer}, a {@link Float}, a 1099 * {@link Long}, a {@link Double} or a {@link String}. 1100 * @return the index of a new or already existing constant item with the 1101 * given value. 1102 */ 1103 public int newConst(final Object cst) { 1104 return newConstItem(cst).index; 1105 } 1106 1107 /** 1108 * Adds an UTF8 string to the constant pool of the class being build. Does 1109 * nothing if the constant pool already contains a similar item. <i>This 1110 * method is intended for {@link Attribute} sub classes, and is normally not 1111 * needed by class generators or adapters.</i> 1112 * 1113 * @param value 1114 * the String value. 1115 * @return the index of a new or already existing UTF8 item. 1116 */ 1117 public int newUTF8(final String value) { 1118 key.set(UTF8, value, null, null); 1119 Item result = get(key); 1120 if (result == null) { 1121 pool.putByte(UTF8).putUTF8(value); 1122 result = new Item(index++, key); 1123 put(result); 1124 } 1125 return result.index; 1126 } 1127 1128 /** 1129 * Adds a class reference to the constant pool of the class being build. 1130 * Does nothing if the constant pool already contains a similar item. 1131 * <i>This method is intended for {@link Attribute} sub classes, and is 1132 * normally not needed by class generators or adapters.</i> 1133 * 1134 * @param value 1135 * the internal name of the class. 1136 * @return a new or already existing class reference item. 1137 */ 1138 Item newClassItem(final String value) { 1139 key2.set(CLASS, value, null, null); 1140 Item result = get(key2); 1141 if (result == null) { 1142 pool.put12(CLASS, newUTF8(value)); 1143 result = new Item(index++, key2); 1144 put(result); 1145 } 1146 return result; 1147 } 1148 1149 /** 1150 * Adds a class reference to the constant pool of the class being build. 1151 * Does nothing if the constant pool already contains a similar item. 1152 * <i>This method is intended for {@link Attribute} sub classes, and is 1153 * normally not needed by class generators or adapters.</i> 1154 * 1155 * @param value 1156 * the internal name of the class. 1157 * @return the index of a new or already existing class reference item. 1158 */ 1159 public int newClass(final String value) { 1160 return newClassItem(value).index; 1161 } 1162 1163 /** 1164 * Adds a method type reference to the constant pool of the class being 1165 * build. Does nothing if the constant pool already contains a similar item. 1166 * <i>This method is intended for {@link Attribute} sub classes, and is 1167 * normally not needed by class generators or adapters.</i> 1168 * 1169 * @param methodDesc 1170 * method descriptor of the method type. 1171 * @return a new or already existing method type reference item. 1172 */ 1173 Item newMethodTypeItem(final String methodDesc) { 1174 key2.set(MTYPE, methodDesc, null, null); 1175 Item result = get(key2); 1176 if (result == null) { 1177 pool.put12(MTYPE, newUTF8(methodDesc)); 1178 result = new Item(index++, key2); 1179 put(result); 1180 } 1181 return result; 1182 } 1183 1184 /** 1185 * Adds a method type reference to the constant pool of the class being 1186 * build. Does nothing if the constant pool already contains a similar item. 1187 * <i>This method is intended for {@link Attribute} sub classes, and is 1188 * normally not needed by class generators or adapters.</i> 1189 * 1190 * @param methodDesc 1191 * method descriptor of the method type. 1192 * @return the index of a new or already existing method type reference 1193 * item. 1194 */ 1195 public int newMethodType(final String methodDesc) { 1196 return newMethodTypeItem(methodDesc).index; 1197 } 1198 1199 /** 1200 * Adds a handle to the constant pool of the class being build. Does nothing 1201 * if the constant pool already contains a similar item. <i>This method is 1202 * intended for {@link Attribute} sub classes, and is normally not needed by 1203 * class generators or adapters.</i> 1204 * 1205 * @param tag 1206 * the kind of this handle. Must be {@link Opcodes#H_GETFIELD}, 1207 * {@link Opcodes#H_GETSTATIC}, {@link Opcodes#H_PUTFIELD}, 1208 * {@link Opcodes#H_PUTSTATIC}, {@link Opcodes#H_INVOKEVIRTUAL}, 1209 * {@link Opcodes#H_INVOKESTATIC}, 1210 * {@link Opcodes#H_INVOKESPECIAL}, 1211 * {@link Opcodes#H_NEWINVOKESPECIAL} or 1212 * {@link Opcodes#H_INVOKEINTERFACE}. 1213 * @param owner 1214 * the internal name of the field or method owner class. 1215 * @param name 1216 * the name of the field or method. 1217 * @param desc 1218 * the descriptor of the field or method. 1219 * @param itf 1220 * true if the owner is an interface. 1221 * @return a new or an already existing method type reference item. 1222 */ 1223 Item newHandleItem(final int tag, final String owner, final String name, 1224 final String desc, final boolean itf) { 1225 key4.set(HANDLE_BASE + tag, owner, name, desc); 1226 Item result = get(key4); 1227 if (result == null) { 1228 if (tag <= Opcodes.H_PUTSTATIC) { 1229 put112(HANDLE, tag, newField(owner, name, desc)); 1230 } else { 1231 put112(HANDLE, 1232 tag, 1233 newMethod(owner, name, desc, itf)); 1234 } 1235 result = new Item(index++, key4); 1236 put(result); 1237 } 1238 return result; 1239 } 1240 1241 /** 1242 * Adds a handle to the constant pool of the class being build. Does nothing 1243 * if the constant pool already contains a similar item. <i>This method is 1244 * intended for {@link Attribute} sub classes, and is normally not needed by 1245 * class generators or adapters.</i> 1246 * 1247 * @param tag 1248 * the kind of this handle. Must be {@link Opcodes#H_GETFIELD}, 1249 * {@link Opcodes#H_GETSTATIC}, {@link Opcodes#H_PUTFIELD}, 1250 * {@link Opcodes#H_PUTSTATIC}, {@link Opcodes#H_INVOKEVIRTUAL}, 1251 * {@link Opcodes#H_INVOKESTATIC}, 1252 * {@link Opcodes#H_INVOKESPECIAL}, 1253 * {@link Opcodes#H_NEWINVOKESPECIAL} or 1254 * {@link Opcodes#H_INVOKEINTERFACE}. 1255 * @param owner 1256 * the internal name of the field or method owner class. 1257 * @param name 1258 * the name of the field or method. 1259 * @param desc 1260 * the descriptor of the field or method. 1261 * @return the index of a new or already existing method type reference 1262 * item. 1263 * 1264 * @deprecated this method is superseded by 1265 * {@link #newHandle(int, String, String, String, boolean)}. 1266 */ 1267 @Deprecated 1268 public int newHandle(final int tag, final String owner, final String name, 1269 final String desc) { 1270 return newHandle(tag, owner, name, desc, tag == Opcodes.H_INVOKEINTERFACE); 1271 } 1272 1273 /** 1274 * Adds a handle to the constant pool of the class being build. Does nothing 1275 * if the constant pool already contains a similar item. <i>This method is 1276 * intended for {@link Attribute} sub classes, and is normally not needed by 1277 * class generators or adapters.</i> 1278 * 1279 * @param tag 1280 * the kind of this handle. Must be {@link Opcodes#H_GETFIELD}, 1281 * {@link Opcodes#H_GETSTATIC}, {@link Opcodes#H_PUTFIELD}, 1282 * {@link Opcodes#H_PUTSTATIC}, {@link Opcodes#H_INVOKEVIRTUAL}, 1283 * {@link Opcodes#H_INVOKESTATIC}, 1284 * {@link Opcodes#H_INVOKESPECIAL}, 1285 * {@link Opcodes#H_NEWINVOKESPECIAL} or 1286 * {@link Opcodes#H_INVOKEINTERFACE}. 1287 * @param owner 1288 * the internal name of the field or method owner class. 1289 * @param name 1290 * the name of the field or method. 1291 * @param desc 1292 * the descriptor of the field or method. 1293 * @param itf 1294 * true if the owner is an interface. 1295 * @return the index of a new or already existing method type reference 1296 * item. 1297 */ 1298 public int newHandle(final int tag, final String owner, final String name, 1299 final String desc, final boolean itf) { 1300 return newHandleItem(tag, owner, name, desc, itf).index; 1301 } 1302 1303 /** 1304 * Adds an invokedynamic reference to the constant pool of the class being 1305 * build. Does nothing if the constant pool already contains a similar item. 1306 * <i>This method is intended for {@link Attribute} sub classes, and is 1307 * normally not needed by class generators or adapters.</i> 1308 * 1309 * @param name 1310 * name of the invoked method. 1311 * @param desc 1312 * descriptor of the invoke method. 1313 * @param bsm 1314 * the bootstrap method. 1315 * @param bsmArgs 1316 * the bootstrap method constant arguments. 1317 * 1318 * @return a new or an already existing invokedynamic type reference item. 1319 */ 1320 Item newInvokeDynamicItem(final String name, final String desc, 1321 final Handle bsm, final Object... bsmArgs) { 1322 // cache for performance 1323 ByteVector bootstrapMethods = this.bootstrapMethods; 1324 if (bootstrapMethods == null) { 1325 bootstrapMethods = this.bootstrapMethods = new ByteVector(); 1326 } 1327 1328 int position = bootstrapMethods.length; // record current position 1329 1330 int hashCode = bsm.hashCode(); 1331 bootstrapMethods.putShort(newHandle(bsm.tag, bsm.owner, bsm.name, 1332 bsm.desc, bsm.isInterface())); 1333 1334 int argsLength = bsmArgs.length; 1335 bootstrapMethods.putShort(argsLength); 1336 1337 for (int i = 0; i < argsLength; i++) { 1338 Object bsmArg = bsmArgs[i]; 1339 hashCode ^= bsmArg.hashCode(); 1340 bootstrapMethods.putShort(newConst(bsmArg)); 1341 } 1342 1343 byte[] data = bootstrapMethods.data; 1344 int length = (1 + 1 + argsLength) << 1; // (bsm + argCount + arguments) 1345 hashCode &= 0x7FFFFFFF; 1346 Item result = items[hashCode % items.length]; 1347 loop: while (result != null) { 1348 if (result.type != BSM || result.hashCode != hashCode) { 1349 result = result.next; 1350 continue; 1351 } 1352 1353 // because the data encode the size of the argument 1354 // we don't need to test if these size are equals 1355 int resultPosition = result.intVal; 1356 for (int p = 0; p < length; p++) { 1357 if (data[position + p] != data[resultPosition + p]) { 1358 result = result.next; 1359 continue loop; 1360 } 1361 } 1362 break; 1363 } 1364 1365 int bootstrapMethodIndex; 1366 if (result != null) { 1367 bootstrapMethodIndex = result.index; 1368 bootstrapMethods.length = position; // revert to old position 1369 } else { 1370 bootstrapMethodIndex = bootstrapMethodsCount++; 1371 result = new Item(bootstrapMethodIndex); 1372 result.set(position, hashCode); 1373 put(result); 1374 } 1375 1376 // now, create the InvokeDynamic constant 1377 key3.set(name, desc, bootstrapMethodIndex); 1378 result = get(key3); 1379 if (result == null) { 1380 put122(INDY, bootstrapMethodIndex, newNameType(name, desc)); 1381 result = new Item(index++, key3); 1382 put(result); 1383 } 1384 return result; 1385 } 1386 1387 /** 1388 * Adds an invokedynamic reference to the constant pool of the class being 1389 * build. Does nothing if the constant pool already contains a similar item. 1390 * <i>This method is intended for {@link Attribute} sub classes, and is 1391 * normally not needed by class generators or adapters.</i> 1392 * 1393 * @param name 1394 * name of the invoked method. 1395 * @param desc 1396 * descriptor of the invoke method. 1397 * @param bsm 1398 * the bootstrap method. 1399 * @param bsmArgs 1400 * the bootstrap method constant arguments. 1401 * 1402 * @return the index of a new or already existing invokedynamic reference 1403 * item. 1404 */ 1405 public int newInvokeDynamic(final String name, final String desc, 1406 final Handle bsm, final Object... bsmArgs) { 1407 return newInvokeDynamicItem(name, desc, bsm, bsmArgs).index; 1408 } 1409 1410 /** 1411 * Adds a field reference to the constant pool of the class being build. 1412 * Does nothing if the constant pool already contains a similar item. 1413 * 1414 * @param owner 1415 * the internal name of the field's owner class. 1416 * @param name 1417 * the field's name. 1418 * @param desc 1419 * the field's descriptor. 1420 * @return a new or already existing field reference item. 1421 */ 1422 Item newFieldItem(final String owner, final String name, final String desc) { 1423 key3.set(FIELD, owner, name, desc); 1424 Item result = get(key3); 1425 if (result == null) { 1426 put122(FIELD, newClass(owner), newNameType(name, desc)); 1427 result = new Item(index++, key3); 1428 put(result); 1429 } 1430 return result; 1431 } 1432 1433 /** 1434 * Adds a field reference to the constant pool of the class being build. 1435 * Does nothing if the constant pool already contains a similar item. 1436 * <i>This method is intended for {@link Attribute} sub classes, and is 1437 * normally not needed by class generators or adapters.</i> 1438 * 1439 * @param owner 1440 * the internal name of the field's owner class. 1441 * @param name 1442 * the field's name. 1443 * @param desc 1444 * the field's descriptor. 1445 * @return the index of a new or already existing field reference item. 1446 */ 1447 public int newField(final String owner, final String name, final String desc) { 1448 return newFieldItem(owner, name, desc).index; 1449 } 1450 1451 /** 1452 * Adds a method reference to the constant pool of the class being build. 1453 * Does nothing if the constant pool already contains a similar item. 1454 * 1455 * @param owner 1456 * the internal name of the method's owner class. 1457 * @param name 1458 * the method's name. 1459 * @param desc 1460 * the method's descriptor. 1461 * @param itf 1462 * <tt>true</tt> if <tt>owner</tt> is an interface. 1463 * @return a new or already existing method reference item. 1464 */ 1465 Item newMethodItem(final String owner, final String name, 1466 final String desc, final boolean itf) { 1467 int type = itf ? IMETH : METH; 1468 key3.set(type, owner, name, desc); 1469 Item result = get(key3); 1470 if (result == null) { 1471 put122(type, newClass(owner), newNameType(name, desc)); 1472 result = new Item(index++, key3); 1473 put(result); 1474 } 1475 return result; 1476 } 1477 1478 /** 1479 * Adds a method reference to the constant pool of the class being build. 1480 * Does nothing if the constant pool already contains a similar item. 1481 * <i>This method is intended for {@link Attribute} sub classes, and is 1482 * normally not needed by class generators or adapters.</i> 1483 * 1484 * @param owner 1485 * the internal name of the method's owner class. 1486 * @param name 1487 * the method's name. 1488 * @param desc 1489 * the method's descriptor. 1490 * @param itf 1491 * <tt>true</tt> if <tt>owner</tt> is an interface. 1492 * @return the index of a new or already existing method reference item. 1493 */ 1494 public int newMethod(final String owner, final String name, 1495 final String desc, final boolean itf) { 1496 return newMethodItem(owner, name, desc, itf).index; 1497 } 1498 1499 /** 1500 * Adds an integer to the constant pool of the class being build. Does 1501 * nothing if the constant pool already contains a similar item. 1502 * 1503 * @param value 1504 * the int value. 1505 * @return a new or already existing int item. 1506 */ 1507 Item newInteger(final int value) { 1508 key.set(value); 1509 Item result = get(key); 1510 if (result == null) { 1511 pool.putByte(INT).putInt(value); 1512 result = new Item(index++, key); 1513 put(result); 1514 } 1515 return result; 1516 } 1517 1518 /** 1519 * Adds a float to the constant pool of the class being build. Does nothing 1520 * if the constant pool already contains a similar item. 1521 * 1522 * @param value 1523 * the float value. 1524 * @return a new or already existing float item. 1525 */ 1526 Item newFloat(final float value) { 1527 key.set(value); 1528 Item result = get(key); 1529 if (result == null) { 1530 pool.putByte(FLOAT).putInt(key.intVal); 1531 result = new Item(index++, key); 1532 put(result); 1533 } 1534 return result; 1535 } 1536 1537 /** 1538 * Adds a long to the constant pool of the class being build. Does nothing 1539 * if the constant pool already contains a similar item. 1540 * 1541 * @param value 1542 * the long value. 1543 * @return a new or already existing long item. 1544 */ 1545 Item newLong(final long value) { 1546 key.set(value); 1547 Item result = get(key); 1548 if (result == null) { 1549 pool.putByte(LONG).putLong(value); 1550 result = new Item(index, key); 1551 index += 2; 1552 put(result); 1553 } 1554 return result; 1555 } 1556 1557 /** 1558 * Adds a double to the constant pool of the class being build. Does nothing 1559 * if the constant pool already contains a similar item. 1560 * 1561 * @param value 1562 * the double value. 1563 * @return a new or already existing double item. 1564 */ 1565 Item newDouble(final double value) { 1566 key.set(value); 1567 Item result = get(key); 1568 if (result == null) { 1569 pool.putByte(DOUBLE).putLong(key.longVal); 1570 result = new Item(index, key); 1571 index += 2; 1572 put(result); 1573 } 1574 return result; 1575 } 1576 1577 /** 1578 * Adds a string to the constant pool of the class being build. Does nothing 1579 * if the constant pool already contains a similar item. 1580 * 1581 * @param value 1582 * the String value. 1583 * @return a new or already existing string item. 1584 */ 1585 private Item newString(final String value) { 1586 key2.set(STR, value, null, null); 1587 Item result = get(key2); 1588 if (result == null) { 1589 pool.put12(STR, newUTF8(value)); 1590 result = new Item(index++, key2); 1591 put(result); 1592 } 1593 return result; 1594 } 1595 1596 /** 1597 * Adds a name and type to the constant pool of the class being build. Does 1598 * nothing if the constant pool already contains a similar item. <i>This 1599 * method is intended for {@link Attribute} sub classes, and is normally not 1600 * needed by class generators or adapters.</i> 1601 * 1602 * @param name 1603 * a name. 1604 * @param desc 1605 * a type descriptor. 1606 * @return the index of a new or already existing name and type item. 1607 */ 1608 public int newNameType(final String name, final String desc) { 1609 return newNameTypeItem(name, desc).index; 1610 } 1611 1612 /** 1613 * Adds a name and type to the constant pool of the class being build. Does 1614 * nothing if the constant pool already contains a similar item. 1615 * 1616 * @param name 1617 * a name. 1618 * @param desc 1619 * a type descriptor. 1620 * @return a new or already existing name and type item. 1621 */ 1622 Item newNameTypeItem(final String name, final String desc) { 1623 key2.set(NAME_TYPE, name, desc, null); 1624 Item result = get(key2); 1625 if (result == null) { 1626 put122(NAME_TYPE, newUTF8(name), newUTF8(desc)); 1627 result = new Item(index++, key2); 1628 put(result); 1629 } 1630 return result; 1631 } 1632 1633 /** 1634 * Adds the given internal name to {@link #typeTable} and returns its index. 1635 * Does nothing if the type table already contains this internal name. 1636 * 1637 * @param type 1638 * the internal name to be added to the type table. 1639 * @return the index of this internal name in the type table. 1640 */ 1641 int addType(final String type) { 1642 key.set(TYPE_NORMAL, type, null, null); 1643 Item result = get(key); 1644 if (result == null) { 1645 result = addType(key); 1646 } 1647 return result.index; 1648 } 1649 1650 /** 1651 * Adds the given "uninitialized" type to {@link #typeTable} and returns its 1652 * index. This method is used for UNINITIALIZED types, made of an internal 1653 * name and a bytecode offset. 1654 * 1655 * @param type 1656 * the internal name to be added to the type table. 1657 * @param offset 1658 * the bytecode offset of the NEW instruction that created this 1659 * UNINITIALIZED type value. 1660 * @return the index of this internal name in the type table. 1661 */ 1662 int addUninitializedType(final String type, final int offset) { 1663 key.type = TYPE_UNINIT; 1664 key.intVal = offset; 1665 key.strVal1 = type; 1666 key.hashCode = 0x7FFFFFFF & (TYPE_UNINIT + type.hashCode() + offset); 1667 Item result = get(key); 1668 if (result == null) { 1669 result = addType(key); 1670 } 1671 return result.index; 1672 } 1673 1674 /** 1675 * Adds the given Item to {@link #typeTable}. 1676 * 1677 * @param item 1678 * the value to be added to the type table. 1679 * @return the added Item, which a new Item instance with the same value as 1680 * the given Item. 1681 */ 1682 private Item addType(final Item item) { 1683 ++typeCount; 1684 Item result = new Item(typeCount, key); 1685 put(result); 1686 if (typeTable == null) { 1687 typeTable = new Item[16]; 1688 } 1689 if (typeCount == typeTable.length) { 1690 Item[] newTable = new Item[2 * typeTable.length]; 1691 System.arraycopy(typeTable, 0, newTable, 0, typeTable.length); 1692 typeTable = newTable; 1693 } 1694 typeTable[typeCount] = result; 1695 return result; 1696 } 1697 1698 /** 1699 * Returns the index of the common super type of the two given types. This 1700 * method calls {@link #getCommonSuperClass} and caches the result in the 1701 * {@link #items} hash table to speedup future calls with the same 1702 * parameters. 1703 * 1704 * @param type1 1705 * index of an internal name in {@link #typeTable}. 1706 * @param type2 1707 * index of an internal name in {@link #typeTable}. 1708 * @return the index of the common super type of the two given types. 1709 */ 1710 int getMergedType(final int type1, final int type2) { 1711 key2.type = TYPE_MERGED; 1712 key2.longVal = type1 | (((long) type2) << 32); 1713 key2.hashCode = 0x7FFFFFFF & (TYPE_MERGED + type1 + type2); 1714 Item result = get(key2); 1715 if (result == null) { 1716 String t = typeTable[type1].strVal1; 1717 String u = typeTable[type2].strVal1; 1718 key2.intVal = addType(getCommonSuperClass(t, u)); 1719 result = new Item((short) 0, key2); 1720 put(result); 1721 } 1722 return result.intVal; 1723 } 1724 1725 /** 1726 * Returns the common super type of the two given types. The default 1727 * implementation of this method <i>loads</i> the two given classes and uses 1728 * the java.lang.Class methods to find the common super class. It can be 1729 * overridden to compute this common super type in other ways, in particular 1730 * without actually loading any class, or to take into account the class 1731 * that is currently being generated by this ClassWriter, which can of 1732 * course not be loaded since it is under construction. 1733 * 1734 * @param type1 1735 * the internal name of a class. 1736 * @param type2 1737 * the internal name of another class. 1738 * @return the internal name of the common super class of the two given 1739 * classes. 1740 */ 1741 protected String getCommonSuperClass(final String type1, final String type2) { 1742 Class<?> c, d; 1743 ClassLoader classLoader = getClass().getClassLoader(); 1744 try { 1745 c = Class.forName(type1.replace('/', '.'), false, classLoader); 1746 d = Class.forName(type2.replace('/', '.'), false, classLoader); 1747 } catch (Exception e) { 1748 throw new RuntimeException(e.toString()); 1749 } 1750 if (c.isAssignableFrom(d)) { 1751 return type1; 1752 } 1753 if (d.isAssignableFrom(c)) { 1754 return type2; 1755 } 1756 if (c.isInterface() || d.isInterface()) { 1757 return "java/lang/Object"; 1758 } else { 1759 do { 1760 c = c.getSuperclass(); 1761 } while (!c.isAssignableFrom(d)); 1762 return c.getName().replace('.', '/'); 1763 } 1764 } 1765 1766 /** 1767 * Returns the constant pool's hash table item which is equal to the given 1768 * item. 1769 * 1770 * @param key 1771 * a constant pool item. 1772 * @return the constant pool's hash table item which is equal to the given 1773 * item, or <tt>null</tt> if there is no such item. 1774 */ 1775 private Item get(final Item key) { 1776 Item i = items[key.hashCode % items.length]; 1777 while (i != null && (i.type != key.type || !key.isEqualTo(i))) { 1778 i = i.next; 1779 } 1780 return i; 1781 } 1782 1783 /** 1784 * Puts the given item in the constant pool's hash table. The hash table 1785 * <i>must</i> not already contains this item. 1786 * 1787 * @param i 1788 * the item to be added to the constant pool's hash table. 1789 */ 1790 private void put(final Item i) { 1791 if (index + typeCount > threshold) { 1792 int ll = items.length; 1793 int nl = ll * 2 + 1; 1794 Item[] newItems = new Item[nl]; 1795 for (int l = ll - 1; l >= 0; --l) { 1796 Item j = items[l]; 1797 while (j != null) { 1798 int index = j.hashCode % newItems.length; 1799 Item k = j.next; 1800 j.next = newItems[index]; 1801 newItems[index] = j; 1802 j = k; 1803 } 1804 } 1805 items = newItems; 1806 threshold = (int) (nl * 0.75); 1807 } 1808 int index = i.hashCode % items.length; 1809 i.next = items[index]; 1810 items[index] = i; 1811 } 1812 1813 /** 1814 * Puts one byte and two shorts into the constant pool. 1815 * 1816 * @param b 1817 * a byte. 1818 * @param s1 1819 * a short. 1820 * @param s2 1821 * another short. 1822 */ 1823 private void put122(final int b, final int s1, final int s2) { 1824 pool.put12(b, s1).putShort(s2); 1825 } 1826 1827 /** 1828 * Puts two bytes and one short into the constant pool. 1829 * 1830 * @param b1 1831 * a byte. 1832 * @param b2 1833 * another byte. 1834 * @param s 1835 * a short. 1836 */ 1837 private void put112(final int b1, final int b2, final int s) { 1838 pool.put11(b1, b2).putShort(s); 1839 } 1840 }