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