rev 47452 : imported patch jdk-new-asmv6.patch

   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 MethodVisitor} that generates methods in bytecode form. Each visit
  63  * method of this class appends the bytecode corresponding to the visited
  64  * instruction to a byte vector, in the order these methods are called.
  65  *
  66  * @author Eric Bruneton
  67  * @author Eugene Kuleshov
  68  */
  69 class MethodWriter extends MethodVisitor {
  70 
  71     /**
  72      * Pseudo access flag used to denote constructors.
  73      */
  74     static final int ACC_CONSTRUCTOR = 0x80000;
  75 
  76     /**
  77      * Frame has exactly the same locals as the previous stack map frame and
  78      * number of stack items is zero.
  79      */
  80     static final int SAME_FRAME = 0; // to 63 (0-3f)
  81 
  82     /**
  83      * Frame has exactly the same locals as the previous stack map frame and
  84      * number of stack items is 1
  85      */
  86     static final int SAME_LOCALS_1_STACK_ITEM_FRAME = 64; // to 127 (40-7f)
  87 
  88     /**
  89      * Reserved for future use
  90      */
  91     static final int RESERVED = 128;
  92 
  93     /**
  94      * Frame has exactly the same locals as the previous stack map frame and
  95      * number of stack items is 1. Offset is bigger then 63;
  96      */
  97     static final int SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED = 247; // f7
  98 
  99     /**
 100      * Frame where current locals are the same as the locals in the previous
 101      * frame, except that the k last locals are absent. The value of k is given
 102      * by the formula 251-frame_type.
 103      */
 104     static final int CHOP_FRAME = 248; // to 250 (f8-fA)
 105 
 106     /**
 107      * Frame has exactly the same locals as the previous stack map frame and
 108      * number of stack items is zero. Offset is bigger then 63;
 109      */
 110     static final int SAME_FRAME_EXTENDED = 251; // fb
 111 
 112     /**
 113      * Frame where current locals are the same as the locals in the previous
 114      * frame, except that k additional locals are defined. The value of k is
 115      * given by the formula frame_type-251.
 116      */
 117     static final int APPEND_FRAME = 252; // to 254 // fc-fe
 118 
 119     /**
 120      * Full frame
 121      */
 122     static final int FULL_FRAME = 255; // ff
 123 
 124     /**
 125      * Indicates that the stack map frames must be recomputed from scratch. In
 126      * this case the maximum stack size and number of local variables is also
 127      * recomputed from scratch.
 128      *
 129      * @see #compute
 130      */
 131     static final int FRAMES = 0;
 132 
 133     /**
 134      * Indicates that the stack map frames of type F_INSERT must be computed.
 135      * The other frames are not (re)computed. They should all be of type F_NEW
 136      * and should be sufficient to compute the content of the F_INSERT frames,
 137      * together with the bytecode instructions between a F_NEW and a F_INSERT
 138      * frame - and without any knowledge of the type hierarchy (by definition of
 139      * F_INSERT).
 140      *
 141      * @see #compute
 142      */
 143     static final int INSERTED_FRAMES = 1;
 144 
 145     /**
 146      * Indicates that the maximum stack size and number of local variables must
 147      * be automatically computed.
 148      *
 149      * @see #compute
 150      */
 151     static final int MAXS = 2;
 152 
 153     /**
 154      * Indicates that nothing must be automatically computed.
 155      *
 156      * @see #compute
 157      */
 158     static final int NOTHING = 3;
 159 
 160     /**
 161      * The class writer to which this method must be added.
 162      */
 163     final ClassWriter cw;
 164 
 165     /**
 166      * Access flags of this method.
 167      */
 168     private int access;
 169 
 170     /**
 171      * The index of the constant pool item that contains the name of this
 172      * method.
 173      */
 174     private final int name;
 175 
 176     /**
 177      * The index of the constant pool item that contains the descriptor of this
 178      * method.
 179      */
 180     private final int desc;
 181 
 182     /**
 183      * The descriptor of this method.
 184      */
 185     private final String descriptor;
 186 
 187     /**
 188      * The signature of this method.
 189      */
 190     String signature;
 191 
 192     /**
 193      * If not zero, indicates that the code of this method must be copied from
 194      * the ClassReader associated to this writer in <code>cw.cr</code>. More
 195      * precisely, this field gives the index of the first byte to copied from
 196      * <code>cw.cr.b</code>.
 197      */
 198     int classReaderOffset;
 199 
 200     /**
 201      * If not zero, indicates that the code of this method must be copied from
 202      * the ClassReader associated to this writer in <code>cw.cr</code>. More
 203      * precisely, this field gives the number of bytes to copied from
 204      * <code>cw.cr.b</code>.
 205      */
 206     int classReaderLength;
 207 
 208     /**
 209      * Number of exceptions that can be thrown by this method.
 210      */
 211     int exceptionCount;
 212 
 213     /**
 214      * The exceptions that can be thrown by this method. More precisely, this
 215      * array contains the indexes of the constant pool items that contain the
 216      * internal names of these exception classes.
 217      */
 218     int[] exceptions;
 219 
 220     /**
 221      * The annotation default attribute of this method. May be <tt>null</tt>.
 222      */
 223     private ByteVector annd;
 224 
 225     /**
 226      * The runtime visible annotations of this method. May be <tt>null</tt>.
 227      */
 228     private AnnotationWriter anns;
 229 
 230     /**
 231      * The runtime invisible annotations of this method. May be <tt>null</tt>.
 232      */
 233     private AnnotationWriter ianns;
 234 
 235     /**
 236      * The runtime visible type annotations of this method. May be <tt>null</tt>
 237      * .
 238      */
 239     private AnnotationWriter tanns;
 240 
 241     /**
 242      * The runtime invisible type annotations of this method. May be
 243      * <tt>null</tt>.
 244      */
 245     private AnnotationWriter itanns;
 246 
 247     /**
 248      * The runtime visible parameter annotations of this method. May be
 249      * <tt>null</tt>.
 250      */
 251     private AnnotationWriter[] panns;
 252 
 253     /**
 254      * The runtime invisible parameter annotations of this method. May be
 255      * <tt>null</tt>.
 256      */
 257     private AnnotationWriter[] ipanns;
 258 
 259     /**
 260      * The number of synthetic parameters of this method.
 261      */
 262     private int synthetics;
 263 
 264     /**
 265      * The non standard attributes of the method.
 266      */
 267     private Attribute attrs;
 268 
 269     /**
 270      * The bytecode of this method.
 271      */
 272     private ByteVector code = new ByteVector();
 273 
 274     /**
 275      * Maximum stack size of this method.
 276      */
 277     private int maxStack;
 278 
 279     /**
 280      * Maximum number of local variables for this method.
 281      */
 282     private int maxLocals;
 283 
 284     /**
 285      * Number of local variables in the current stack map frame.
 286      */
 287     private int currentLocals;
 288 
 289     /**
 290      * Number of stack map frames in the StackMapTable attribute.
 291      */
 292     int frameCount;
 293 
 294     /**
 295      * The StackMapTable attribute.
 296      */
 297     private ByteVector stackMap;
 298 
 299     /**
 300      * The offset of the last frame that was written in the StackMapTable
 301      * attribute.
 302      */
 303     private int previousFrameOffset;
 304 
 305     /**
 306      * The last frame that was written in the StackMapTable attribute.
 307      *
 308      * @see #frame
 309      */
 310     private int[] previousFrame;
 311 
 312     /**
 313      * The current stack map frame. The first element contains the offset of the
 314      * instruction to which the frame corresponds, the second element is the
 315      * number of locals and the third one is the number of stack elements. The
 316      * local variables start at index 3 and are followed by the operand stack
 317      * values. In summary frame[0] = offset, frame[1] = nLocal, frame[2] =
 318      * nStack, frame[3] = nLocal. All types are encoded as integers, with the
 319      * same format as the one used in {@link Label}, but limited to BASE types.
 320      */
 321     private int[] frame;
 322 
 323     /**
 324      * Number of elements in the exception handler list.
 325      */
 326     private int handlerCount;
 327 
 328     /**
 329      * The first element in the exception handler list.
 330      */
 331     private Handler firstHandler;
 332 
 333     /**
 334      * The last element in the exception handler list.
 335      */
 336     private Handler lastHandler;
 337 
 338     /**
 339      * Number of entries in the MethodParameters attribute.
 340      */
 341     private int methodParametersCount;
 342 
 343     /**
 344      * The MethodParameters attribute.
 345      */
 346     private ByteVector methodParameters;
 347 
 348     /**
 349      * Number of entries in the LocalVariableTable attribute.
 350      */
 351     private int localVarCount;
 352 
 353     /**
 354      * The LocalVariableTable attribute.
 355      */
 356     private ByteVector localVar;
 357 
 358     /**
 359      * Number of entries in the LocalVariableTypeTable attribute.
 360      */
 361     private int localVarTypeCount;
 362 
 363     /**
 364      * The LocalVariableTypeTable attribute.
 365      */
 366     private ByteVector localVarType;
 367 
 368     /**
 369      * Number of entries in the LineNumberTable attribute.
 370      */
 371     private int lineNumberCount;
 372 
 373     /**
 374      * The LineNumberTable attribute.
 375      */
 376     private ByteVector lineNumber;
 377 
 378     /**
 379      * The start offset of the last visited instruction.
 380      */
 381     private int lastCodeOffset;
 382 
 383     /**
 384      * The runtime visible type annotations of the code. May be <tt>null</tt>.
 385      */
 386     private AnnotationWriter ctanns;
 387 
 388     /**
 389      * The runtime invisible type annotations of the code. May be <tt>null</tt>.
 390      */
 391     private AnnotationWriter ictanns;
 392 
 393     /**
 394      * The non standard attributes of the method's code.
 395      */
 396     private Attribute cattrs;
 397 
 398     /**





 399      * The number of subroutines in this method.
 400      */
 401     private int subroutines;
 402 
 403     // ------------------------------------------------------------------------
 404 
 405     /*
 406      * Fields for the control flow graph analysis algorithm (used to compute the
 407      * maximum stack size). A control flow graph contains one node per "basic
 408      * block", and one edge per "jump" from one basic block to another. Each
 409      * node (i.e., each basic block) is represented by the Label object that
 410      * corresponds to the first instruction of this basic block. Each node also
 411      * stores the list of its successors in the graph, as a linked list of Edge
 412      * objects.
 413      */
 414 
 415     /**
 416      * Indicates what must be automatically computed.
 417      *
 418      * @see #FRAMES
 419      * @see #INSERTED_FRAMES
 420      * @see #MAXS
 421      * @see #NOTHING
 422      */
 423     private final int compute;
 424 
 425     /**
 426      * A list of labels. This list is the list of basic blocks in the method,
 427      * i.e. a list of Label objects linked to each other by their
 428      * {@link Label#successor} field, in the order they are visited by
 429      * {@link MethodVisitor#visitLabel}, and starting with the first basic
 430      * block.
 431      */
 432     private Label labels;
 433 
 434     /**
 435      * The previous basic block.
 436      */
 437     private Label previousBlock;
 438 
 439     /**
 440      * The current basic block.
 441      */
 442     private Label currentBlock;
 443 
 444     /**
 445      * The (relative) stack size after the last visited instruction. This size
 446      * is relative to the beginning of the current basic block, i.e., the true
 447      * stack size after the last visited instruction is equal to the
 448      * {@link Label#inputStackTop beginStackSize} of the current basic block
 449      * plus <tt>stackSize</tt>.
 450      */
 451     private int stackSize;
 452 
 453     /**
 454      * The (relative) maximum stack size after the last visited instruction.
 455      * This size is relative to the beginning of the current basic block, i.e.,
 456      * the true maximum stack size after the last visited instruction is equal
 457      * to the {@link Label#inputStackTop beginStackSize} of the current basic
 458      * block plus <tt>stackSize</tt>.
 459      */
 460     private int maxStackSize;
 461 
 462     // ------------------------------------------------------------------------
 463     // Constructor
 464     // ------------------------------------------------------------------------
 465 
 466     /**
 467      * Constructs a new {@link MethodWriter}.
 468      *
 469      * @param cw
 470      *            the class writer in which the method must be added.
 471      * @param access
 472      *            the method's access flags (see {@link Opcodes}).
 473      * @param name
 474      *            the method's name.
 475      * @param desc
 476      *            the method's descriptor (see {@link Type}).
 477      * @param signature
 478      *            the method's signature. May be <tt>null</tt>.
 479      * @param exceptions
 480      *            the internal names of the method's exceptions. May be
 481      *            <tt>null</tt>.
 482      * @param compute
 483      *            Indicates what must be automatically computed (see #compute).




 484      */
 485     MethodWriter(final ClassWriter cw, final int access, final String name,
 486             final String desc, final String signature,
 487             final String[] exceptions, final int compute) {
 488         super(Opcodes.ASM6);

 489         if (cw.firstMethod == null) {
 490             cw.firstMethod = this;
 491         } else {
 492             cw.lastMethod.mv = this;
 493         }
 494         cw.lastMethod = this;
 495         this.cw = cw;
 496         this.access = access;
 497         if ("<init>".equals(name)) {
 498             this.access |= ACC_CONSTRUCTOR;
 499         }
 500         this.name = cw.newUTF8(name);
 501         this.desc = cw.newUTF8(desc);
 502         this.descriptor = desc;

 503         this.signature = signature;

 504         if (exceptions != null && exceptions.length > 0) {
 505             exceptionCount = exceptions.length;
 506             this.exceptions = new int[exceptionCount];
 507             for (int i = 0; i < exceptionCount; ++i) {
 508                 this.exceptions[i] = cw.newClass(exceptions[i]);
 509             }
 510         }
 511         this.compute = compute;
 512         if (compute != NOTHING) {
 513             // updates maxLocals
 514             int size = Type.getArgumentsAndReturnSizes(descriptor) >> 2;
 515             if ((access & Opcodes.ACC_STATIC) != 0) {
 516                 --size;
 517             }
 518             maxLocals = size;
 519             currentLocals = size;
 520             // creates and visits the label for the first basic block
 521             labels = new Label();
 522             labels.status |= Label.PUSHED;
 523             visitLabel(labels);
 524         }
 525     }
 526 
 527     // ------------------------------------------------------------------------
 528     // Implementation of the MethodVisitor abstract class
 529     // ------------------------------------------------------------------------
 530 
 531     @Override
 532     public void visitParameter(String name, int access) {
 533         if (methodParameters == null) {
 534             methodParameters = new ByteVector();
 535         }
 536         ++methodParametersCount;
 537         methodParameters.putShort((name == null) ? 0 : cw.newUTF8(name))
 538                 .putShort(access);
 539     }
 540 
 541     @Override
 542     public AnnotationVisitor visitAnnotationDefault() {



 543         annd = new ByteVector();
 544         return new AnnotationWriter(cw, false, annd, null, 0);
 545     }
 546 
 547     @Override
 548     public AnnotationVisitor visitAnnotation(final String desc,
 549             final boolean visible) {



 550         ByteVector bv = new ByteVector();
 551         // write type, and reserve space for values count
 552         bv.putShort(cw.newUTF8(desc)).putShort(0);
 553         AnnotationWriter aw = new AnnotationWriter(cw, true, bv, bv, 2);
 554         if (visible) {
 555             aw.next = anns;
 556             anns = aw;
 557         } else {
 558             aw.next = ianns;
 559             ianns = aw;
 560         }
 561         return aw;
 562     }
 563 
 564     @Override
 565     public AnnotationVisitor visitTypeAnnotation(final int typeRef,
 566             final TypePath typePath, final String desc, final boolean visible) {



 567         ByteVector bv = new ByteVector();
 568         // write target_type and target_info
 569         AnnotationWriter.putTarget(typeRef, typePath, bv);
 570         // write type, and reserve space for values count
 571         bv.putShort(cw.newUTF8(desc)).putShort(0);
 572         AnnotationWriter aw = new AnnotationWriter(cw, true, bv, bv,
 573                 bv.length - 2);
 574         if (visible) {
 575             aw.next = tanns;
 576             tanns = aw;
 577         } else {
 578             aw.next = itanns;
 579             itanns = aw;
 580         }
 581         return aw;
 582     }
 583 
 584     @Override
 585     public AnnotationVisitor visitParameterAnnotation(final int parameter,
 586             final String desc, final boolean visible) {



 587         ByteVector bv = new ByteVector();
 588         if ("Ljava/lang/Synthetic;".equals(desc)) {
 589             // workaround for a bug in javac with synthetic parameters
 590             // see ClassReader.readParameterAnnotations
 591             synthetics = Math.max(synthetics, parameter + 1);
 592             return new AnnotationWriter(cw, false, bv, null, 0);
 593         }
 594         // write type, and reserve space for values count
 595         bv.putShort(cw.newUTF8(desc)).putShort(0);
 596         AnnotationWriter aw = new AnnotationWriter(cw, true, bv, bv, 2);
 597         if (visible) {
 598             if (panns == null) {
 599                 panns = new AnnotationWriter[Type.getArgumentTypes(descriptor).length];
 600             }
 601             aw.next = panns[parameter];
 602             panns[parameter] = aw;
 603         } else {
 604             if (ipanns == null) {
 605                 ipanns = new AnnotationWriter[Type.getArgumentTypes(descriptor).length];
 606             }
 607             aw.next = ipanns[parameter];
 608             ipanns[parameter] = aw;
 609         }
 610         return aw;
 611     }
 612 
 613     @Override
 614     public void visitAttribute(final Attribute attr) {
 615         if (attr.isCodeAttribute()) {
 616             attr.next = cattrs;
 617             cattrs = attr;
 618         } else {
 619             attr.next = attrs;
 620             attrs = attr;
 621         }
 622     }
 623 
 624     @Override
 625     public void visitCode() {
 626     }
 627 
 628     @Override
 629     public void visitFrame(final int type, final int nLocal,
 630             final Object[] local, final int nStack, final Object[] stack) {
 631         if (compute == FRAMES) {
 632             return;
 633         }
 634 
 635         if (compute == INSERTED_FRAMES) {
 636             if (currentBlock.frame == null) {
 637                 // This should happen only once, for the implicit first frame
 638                 // (which is explicitly visited in ClassReader if the
 639                 // EXPAND_ASM_INSNS option is used).
 640                 currentBlock.frame = new CurrentFrame();
 641                 currentBlock.frame.owner = currentBlock;
 642                 currentBlock.frame.initInputFrame(cw, access,
 643                         Type.getArgumentTypes(descriptor), nLocal);
 644                 visitImplicitFirstFrame();
 645             } else {
 646                 if (type == Opcodes.F_NEW) {
 647                     currentBlock.frame.set(cw, nLocal, local, nStack, stack);
 648                 } else {
 649                     // In this case type is equal to F_INSERT by hypothesis, and
 650                     // currentBlock.frame contains the stack map frame at the
 651                     // current instruction, computed from the last F_NEW frame
 652                     // and the bytecode instructions in between (via calls to
 653                     // CurrentFrame#execute).
 654                 }
 655                 visitFrame(currentBlock.frame);
 656             }
 657         } else if (type == Opcodes.F_NEW) {
 658             if (previousFrame == null) {
 659                 visitImplicitFirstFrame();
 660             }
 661             currentLocals = nLocal;
 662             int frameIndex = startFrame(code.length, nLocal, nStack);
 663             for (int i = 0; i < nLocal; ++i) {
 664                 if (local[i] instanceof String) {
 665                     String desc = Type.getObjectType((String) local[i]).getDescriptor();
 666                     frame[frameIndex++] = Frame.type(cw, desc);
 667                 } else if (local[i] instanceof Integer) {
 668                     frame[frameIndex++] = Frame.BASE | ((Integer) local[i]).intValue();
 669                 } else {
 670                     frame[frameIndex++] = Frame.UNINITIALIZED
 671                             | cw.addUninitializedType("",
 672                                     ((Label) local[i]).position);
 673                 }
 674             }
 675             for (int i = 0; i < nStack; ++i) {
 676                 if (stack[i] instanceof String) {
 677                     String desc = Type.getObjectType((String) stack[i]).getDescriptor();
 678                     frame[frameIndex++] = Frame.type(cw, desc);
 679                 } else if (stack[i] instanceof Integer) {
 680                     frame[frameIndex++] = Frame.BASE | ((Integer) stack[i]).intValue();
 681                 } else {
 682                     frame[frameIndex++] = Frame.UNINITIALIZED
 683                             | cw.addUninitializedType("",
 684                                     ((Label) stack[i]).position);
 685                 }
 686             }
 687             endFrame();
 688         } else {
 689             int delta;
 690             if (stackMap == null) {
 691                 stackMap = new ByteVector();
 692                 delta = code.length;
 693             } else {
 694                 delta = code.length - previousFrameOffset - 1;
 695                 if (delta < 0) {
 696                     if (type == Opcodes.F_SAME) {
 697                         return;
 698                     } else {
 699                         throw new IllegalStateException();
 700                     }
 701                 }
 702             }
 703 
 704             switch (type) {
 705             case Opcodes.F_FULL:
 706                 currentLocals = nLocal;
 707                 stackMap.putByte(FULL_FRAME).putShort(delta).putShort(nLocal);
 708                 for (int i = 0; i < nLocal; ++i) {
 709                     writeFrameType(local[i]);
 710                 }
 711                 stackMap.putShort(nStack);
 712                 for (int i = 0; i < nStack; ++i) {
 713                     writeFrameType(stack[i]);
 714                 }
 715                 break;
 716             case Opcodes.F_APPEND:
 717                 currentLocals += nLocal;
 718                 stackMap.putByte(SAME_FRAME_EXTENDED + nLocal).putShort(delta);
 719                 for (int i = 0; i < nLocal; ++i) {
 720                     writeFrameType(local[i]);
 721                 }
 722                 break;
 723             case Opcodes.F_CHOP:
 724                 currentLocals -= nLocal;
 725                 stackMap.putByte(SAME_FRAME_EXTENDED - nLocal).putShort(delta);
 726                 break;
 727             case Opcodes.F_SAME:
 728                 if (delta < 64) {
 729                     stackMap.putByte(delta);
 730                 } else {
 731                     stackMap.putByte(SAME_FRAME_EXTENDED).putShort(delta);
 732                 }
 733                 break;
 734             case Opcodes.F_SAME1:
 735                 if (delta < 64) {
 736                     stackMap.putByte(SAME_LOCALS_1_STACK_ITEM_FRAME + delta);
 737                 } else {
 738                     stackMap.putByte(SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED)
 739                             .putShort(delta);
 740                 }
 741                 writeFrameType(stack[0]);
 742                 break;
 743             }
 744 
 745             previousFrameOffset = code.length;
 746             ++frameCount;
 747         }
 748 
 749         maxStack = Math.max(maxStack, nStack);
 750         maxLocals = Math.max(maxLocals, currentLocals);
 751     }
 752 
 753     @Override
 754     public void visitInsn(final int opcode) {
 755         lastCodeOffset = code.length;
 756         // adds the instruction to the bytecode of the method
 757         code.putByte(opcode);
 758         // update currentBlock
 759         // Label currentBlock = this.currentBlock;
 760         if (currentBlock != null) {
 761             if (compute == FRAMES || compute == INSERTED_FRAMES) {
 762                 currentBlock.frame.execute(opcode, 0, null, null);
 763             } else {
 764                 // updates current and max stack sizes
 765                 int size = stackSize + Frame.SIZE[opcode];
 766                 if (size > maxStackSize) {
 767                     maxStackSize = size;
 768                 }
 769                 stackSize = size;
 770             }
 771             // if opcode == ATHROW or xRETURN, ends current block (no successor)
 772             if ((opcode >= Opcodes.IRETURN && opcode <= Opcodes.RETURN)
 773                     || opcode == Opcodes.ATHROW) {
 774                 noSuccessor();
 775             }
 776         }
 777     }
 778 
 779     @Override
 780     public void visitIntInsn(final int opcode, final int operand) {
 781         lastCodeOffset = code.length;
 782         // Label currentBlock = this.currentBlock;
 783         if (currentBlock != null) {
 784             if (compute == FRAMES || compute == INSERTED_FRAMES) {
 785                 currentBlock.frame.execute(opcode, operand, null, null);
 786             } else if (opcode != Opcodes.NEWARRAY) {
 787                 // updates current and max stack sizes only for NEWARRAY
 788                 // (stack size variation = 0 for BIPUSH or SIPUSH)
 789                 int size = stackSize + 1;
 790                 if (size > maxStackSize) {
 791                     maxStackSize = size;
 792                 }
 793                 stackSize = size;
 794             }
 795         }
 796         // adds the instruction to the bytecode of the method
 797         if (opcode == Opcodes.SIPUSH) {
 798             code.put12(opcode, operand);
 799         } else { // BIPUSH or NEWARRAY
 800             code.put11(opcode, operand);
 801         }
 802     }
 803 
 804     @Override
 805     public void visitVarInsn(final int opcode, final int var) {
 806         lastCodeOffset = code.length;
 807         // Label currentBlock = this.currentBlock;
 808         if (currentBlock != null) {
 809             if (compute == FRAMES || compute == INSERTED_FRAMES) {
 810                 currentBlock.frame.execute(opcode, var, null, null);
 811             } else {
 812                 // updates current and max stack sizes
 813                 if (opcode == Opcodes.RET) {
 814                     // no stack change, but end of current block (no successor)
 815                     currentBlock.status |= Label.RET;
 816                     // save 'stackSize' here for future use
 817                     // (see {@link #findSubroutineSuccessors})
 818                     currentBlock.inputStackTop = stackSize;
 819                     noSuccessor();
 820                 } else { // xLOAD or xSTORE
 821                     int size = stackSize + Frame.SIZE[opcode];
 822                     if (size > maxStackSize) {
 823                         maxStackSize = size;
 824                     }
 825                     stackSize = size;
 826                 }
 827             }
 828         }
 829         if (compute != NOTHING) {
 830             // updates max locals
 831             int n;
 832             if (opcode == Opcodes.LLOAD || opcode == Opcodes.DLOAD
 833                     || opcode == Opcodes.LSTORE || opcode == Opcodes.DSTORE) {
 834                 n = var + 2;
 835             } else {
 836                 n = var + 1;
 837             }
 838             if (n > maxLocals) {
 839                 maxLocals = n;
 840             }
 841         }
 842         // adds the instruction to the bytecode of the method
 843         if (var < 4 && opcode != Opcodes.RET) {
 844             int opt;
 845             if (opcode < Opcodes.ISTORE) {
 846                 /* ILOAD_0 */
 847                 opt = 26 + ((opcode - Opcodes.ILOAD) << 2) + var;
 848             } else {
 849                 /* ISTORE_0 */
 850                 opt = 59 + ((opcode - Opcodes.ISTORE) << 2) + var;
 851             }
 852             code.putByte(opt);
 853         } else if (var >= 256) {
 854             code.putByte(196 /* WIDE */).put12(opcode, var);
 855         } else {
 856             code.put11(opcode, var);
 857         }
 858         if (opcode >= Opcodes.ISTORE && compute == FRAMES && handlerCount > 0) {
 859             visitLabel(new Label());
 860         }
 861     }
 862 
 863     @Override
 864     public void visitTypeInsn(final int opcode, final String type) {
 865         lastCodeOffset = code.length;
 866         Item i = cw.newStringishItem(ClassWriter.CLASS, type);
 867         // Label currentBlock = this.currentBlock;
 868         if (currentBlock != null) {
 869             if (compute == FRAMES || compute == INSERTED_FRAMES) {
 870                 currentBlock.frame.execute(opcode, code.length, cw, i);
 871             } else if (opcode == Opcodes.NEW) {
 872                 // updates current and max stack sizes only if opcode == NEW
 873                 // (no stack change for ANEWARRAY, CHECKCAST, INSTANCEOF)
 874                 int size = stackSize + 1;
 875                 if (size > maxStackSize) {
 876                     maxStackSize = size;
 877                 }
 878                 stackSize = size;
 879             }
 880         }
 881         // adds the instruction to the bytecode of the method
 882         code.put12(opcode, i.index);
 883     }
 884 
 885     @Override
 886     public void visitFieldInsn(final int opcode, final String owner,
 887             final String name, final String desc) {
 888         lastCodeOffset = code.length;
 889         Item i = cw.newFieldItem(owner, name, desc);
 890         // Label currentBlock = this.currentBlock;
 891         if (currentBlock != null) {
 892             if (compute == FRAMES || compute == INSERTED_FRAMES) {
 893                 currentBlock.frame.execute(opcode, 0, cw, i);
 894             } else {
 895                 int size;
 896                 // computes the stack size variation
 897                 char c = desc.charAt(0);
 898                 switch (opcode) {
 899                 case Opcodes.GETSTATIC:
 900                     size = stackSize + (c == 'D' || c == 'J' ? 2 : 1);
 901                     break;
 902                 case Opcodes.PUTSTATIC:
 903                     size = stackSize + (c == 'D' || c == 'J' ? -2 : -1);
 904                     break;
 905                 case Opcodes.GETFIELD:
 906                     size = stackSize + (c == 'D' || c == 'J' ? 1 : 0);
 907                     break;
 908                 // case Constants.PUTFIELD:
 909                 default:
 910                     size = stackSize + (c == 'D' || c == 'J' ? -3 : -2);
 911                     break;
 912                 }
 913                 // updates current and max stack sizes
 914                 if (size > maxStackSize) {
 915                     maxStackSize = size;
 916                 }
 917                 stackSize = size;
 918             }
 919         }
 920         // adds the instruction to the bytecode of the method
 921         code.put12(opcode, i.index);
 922     }
 923 
 924     @Override
 925     public void visitMethodInsn(final int opcode, final String owner,
 926             final String name, final String desc, final boolean itf) {
 927         lastCodeOffset = code.length;
 928         Item i = cw.newMethodItem(owner, name, desc, itf);
 929         int argSize = i.intVal;
 930         // Label currentBlock = this.currentBlock;
 931         if (currentBlock != null) {
 932             if (compute == FRAMES || compute == INSERTED_FRAMES) {
 933                 currentBlock.frame.execute(opcode, 0, cw, i);
 934             } else {
 935                 /*
 936                  * computes the stack size variation. In order not to recompute
 937                  * several times this variation for the same Item, we use the
 938                  * intVal field of this item to store this variation, once it
 939                  * has been computed. More precisely this intVal field stores
 940                  * the sizes of the arguments and of the return value
 941                  * corresponding to desc.
 942                  */
 943                 if (argSize == 0) {
 944                     // the above sizes have not been computed yet,
 945                     // so we compute them...
 946                     argSize = Type.getArgumentsAndReturnSizes(desc);
 947                     // ... and we save them in order
 948                     // not to recompute them in the future
 949                     i.intVal = argSize;
 950                 }
 951                 int size;
 952                 if (opcode == Opcodes.INVOKESTATIC) {
 953                     size = stackSize - (argSize >> 2) + (argSize & 0x03) + 1;
 954                 } else {
 955                     size = stackSize - (argSize >> 2) + (argSize & 0x03);
 956                 }
 957                 // updates current and max stack sizes
 958                 if (size > maxStackSize) {
 959                     maxStackSize = size;
 960                 }
 961                 stackSize = size;
 962             }
 963         }
 964         // adds the instruction to the bytecode of the method
 965         if (opcode == Opcodes.INVOKEINTERFACE) {
 966             if (argSize == 0) {
 967                 argSize = Type.getArgumentsAndReturnSizes(desc);
 968                 i.intVal = argSize;
 969             }
 970             code.put12(Opcodes.INVOKEINTERFACE, i.index).put11(argSize >> 2, 0);
 971         } else {
 972             code.put12(opcode, i.index);
 973         }
 974     }
 975 
 976     @Override
 977     public void visitInvokeDynamicInsn(final String name, final String desc,
 978             final Handle bsm, final Object... bsmArgs) {
 979         lastCodeOffset = code.length;
 980         Item i = cw.newInvokeDynamicItem(name, desc, bsm, bsmArgs);
 981         int argSize = i.intVal;
 982         // Label currentBlock = this.currentBlock;
 983         if (currentBlock != null) {
 984             if (compute == FRAMES || compute == INSERTED_FRAMES) {
 985                 currentBlock.frame.execute(Opcodes.INVOKEDYNAMIC, 0, cw, i);
 986             } else {
 987                 /*
 988                  * computes the stack size variation. In order not to recompute
 989                  * several times this variation for the same Item, we use the
 990                  * intVal field of this item to store this variation, once it
 991                  * has been computed. More precisely this intVal field stores
 992                  * the sizes of the arguments and of the return value
 993                  * corresponding to desc.
 994                  */
 995                 if (argSize == 0) {
 996                     // the above sizes have not been computed yet,
 997                     // so we compute them...
 998                     argSize = Type.getArgumentsAndReturnSizes(desc);
 999                     // ... and we save them in order
1000                     // not to recompute them in the future
1001                     i.intVal = argSize;
1002                 }
1003                 int size = stackSize - (argSize >> 2) + (argSize & 0x03) + 1;
1004 
1005                 // updates current and max stack sizes
1006                 if (size > maxStackSize) {
1007                     maxStackSize = size;
1008                 }
1009                 stackSize = size;
1010             }
1011         }
1012         // adds the instruction to the bytecode of the method
1013         code.put12(Opcodes.INVOKEDYNAMIC, i.index);
1014         code.putShort(0);
1015     }
1016 
1017     @Override
1018     public void visitJumpInsn(int opcode, final Label label) {
1019         boolean isWide = opcode >= 200; // GOTO_W
1020         opcode = isWide ? opcode - 33 : opcode;
1021         lastCodeOffset = code.length;
1022         Label nextInsn = null;
1023         // Label currentBlock = this.currentBlock;
1024         if (currentBlock != null) {
1025             if (compute == FRAMES) {
1026                 currentBlock.frame.execute(opcode, 0, null, null);
1027                 // 'label' is the target of a jump instruction
1028                 label.getFirst().status |= Label.TARGET;
1029                 // adds 'label' as a successor of this basic block
1030                 addSuccessor(Edge.NORMAL, label);
1031                 if (opcode != Opcodes.GOTO) {
1032                     // creates a Label for the next basic block
1033                     nextInsn = new Label();
1034                 }
1035             } else if (compute == INSERTED_FRAMES) {
1036                 currentBlock.frame.execute(opcode, 0, null, null);
1037             } else {
1038                 if (opcode == Opcodes.JSR) {
1039                     if ((label.status & Label.SUBROUTINE) == 0) {
1040                         label.status |= Label.SUBROUTINE;
1041                         ++subroutines;
1042                     }
1043                     currentBlock.status |= Label.JSR;
1044                     addSuccessor(stackSize + 1, label);
1045                     // creates a Label for the next basic block
1046                     nextInsn = new Label();
1047                     /*
1048                      * note that, by construction in this method, a JSR block
1049                      * has at least two successors in the control flow graph:
1050                      * the first one leads the next instruction after the JSR,
1051                      * while the second one leads to the JSR target.
1052                      */
1053                 } else {
1054                     // updates current stack size (max stack size unchanged
1055                     // because stack size variation always negative in this
1056                     // case)
1057                     stackSize += Frame.SIZE[opcode];
1058                     addSuccessor(stackSize, label);
1059                 }
1060             }
1061         }
1062         // adds the instruction to the bytecode of the method
1063         if ((label.status & Label.RESOLVED) != 0
1064                 && label.position - code.length < Short.MIN_VALUE) {
1065             /*
1066              * case of a backward jump with an offset < -32768. In this case we
1067              * automatically replace GOTO with GOTO_W, JSR with JSR_W and IFxxx
1068              * <l> with IFNOTxxx <L> GOTO_W <l> L:..., where IFNOTxxx is the
1069              * "opposite" opcode of IFxxx (i.e., IFNE for IFEQ) and where <L>
1070              * designates the instruction just after the GOTO_W.
1071              */
1072             if (opcode == Opcodes.GOTO) {
1073                 code.putByte(200); // GOTO_W
1074             } else if (opcode == Opcodes.JSR) {
1075                 code.putByte(201); // JSR_W
1076             } else {
1077                 // if the IF instruction is transformed into IFNOT GOTO_W the
1078                 // next instruction becomes the target of the IFNOT instruction
1079                 if (nextInsn != null) {
1080                     nextInsn.status |= Label.TARGET;
1081                 }
1082                 code.putByte(opcode <= 166 ? ((opcode + 1) ^ 1) - 1
1083                         : opcode ^ 1);
1084                 code.putShort(8); // jump offset
1085                 // ASM pseudo GOTO_W insn, see ClassReader. We don't use a real
1086                 // GOTO_W because we might need to insert a frame just after (as
1087                 // the target of the IFNOTxxx jump instruction).
1088                 code.putByte(220);
1089                 cw.hasAsmInsns = true;
1090             }
1091             label.put(this, code, code.length - 1, true);
1092         } else if (isWide) {
1093             /*
1094              * case of a GOTO_W or JSR_W specified by the user (normally
1095              * ClassReader when used to resize instructions). In this case we
1096              * keep the original instruction.
1097              */
1098             code.putByte(opcode + 33);
1099             label.put(this, code, code.length - 1, true);
1100         } else {
1101             /*
1102              * case of a backward jump with an offset >= -32768, or of a forward
1103              * jump with, of course, an unknown offset. In these cases we store
1104              * the offset in 2 bytes (which will be increased in
1105              * resizeInstructions, if needed).
1106              */
1107             code.putByte(opcode);
1108             label.put(this, code, code.length - 1, false);
1109         }
1110         if (currentBlock != null) {
1111             if (nextInsn != null) {
1112                 // if the jump instruction is not a GOTO, the next instruction
1113                 // is also a successor of this instruction. Calling visitLabel
1114                 // adds the label of this next instruction as a successor of the
1115                 // current block, and starts a new basic block
1116                 visitLabel(nextInsn);
1117             }
1118             if (opcode == Opcodes.GOTO) {
1119                 noSuccessor();
1120             }
1121         }
1122     }
1123 
1124     @Override
1125     public void visitLabel(final Label label) {
1126         // resolves previous forward references to label, if any
1127         cw.hasAsmInsns |= label.resolve(this, code.length, code.data);
1128         // updates currentBlock
1129         if ((label.status & Label.DEBUG) != 0) {
1130             return;
1131         }
1132         if (compute == FRAMES) {
1133             if (currentBlock != null) {
1134                 if (label.position == currentBlock.position) {
1135                     // successive labels, do not start a new basic block
1136                     currentBlock.status |= (label.status & Label.TARGET);
1137                     label.frame = currentBlock.frame;
1138                     return;
1139                 }
1140                 // ends current block (with one new successor)
1141                 addSuccessor(Edge.NORMAL, label);
1142             }
1143             // begins a new current block
1144             currentBlock = label;
1145             if (label.frame == null) {
1146                 label.frame = new Frame();
1147                 label.frame.owner = label;
1148             }
1149             // updates the basic block list
1150             if (previousBlock != null) {
1151                 if (label.position == previousBlock.position) {
1152                     previousBlock.status |= (label.status & Label.TARGET);
1153                     label.frame = previousBlock.frame;
1154                     currentBlock = previousBlock;
1155                     return;
1156                 }
1157                 previousBlock.successor = label;
1158             }
1159             previousBlock = label;
1160         } else if (compute == INSERTED_FRAMES) {
1161             if (currentBlock == null) {
1162                 // This case should happen only once, for the visitLabel call in
1163                 // the constructor. Indeed, if compute is equal to
1164                 // INSERTED_FRAMES currentBlock can not be set back to null (see
1165                 // #noSuccessor).
1166                 currentBlock = label;
1167             } else {
1168                 // Updates the frame owner so that a correct frame offset is
1169                 // computed in visitFrame(Frame).
1170                 currentBlock.frame.owner = label;
1171             }
1172         } else if (compute == MAXS) {
1173             if (currentBlock != null) {
1174                 // ends current block (with one new successor)
1175                 currentBlock.outputStackMax = maxStackSize;
1176                 addSuccessor(stackSize, label);
1177             }
1178             // begins a new current block
1179             currentBlock = label;
1180             // resets the relative current and max stack sizes
1181             stackSize = 0;
1182             maxStackSize = 0;
1183             // updates the basic block list
1184             if (previousBlock != null) {
1185                 previousBlock.successor = label;
1186             }
1187             previousBlock = label;
1188         }
1189     }
1190 
1191     @Override
1192     public void visitLdcInsn(final Object cst) {
1193         lastCodeOffset = code.length;
1194         Item i = cw.newConstItem(cst);
1195         // Label currentBlock = this.currentBlock;
1196         if (currentBlock != null) {
1197             if (compute == FRAMES || compute == INSERTED_FRAMES) {
1198                 currentBlock.frame.execute(Opcodes.LDC, 0, cw, i);
1199             } else {
1200                 int size;
1201                 // computes the stack size variation
1202                 if (i.type == ClassWriter.LONG || i.type == ClassWriter.DOUBLE) {
1203                     size = stackSize + 2;
1204                 } else {
1205                     size = stackSize + 1;
1206                 }
1207                 // updates current and max stack sizes
1208                 if (size > maxStackSize) {
1209                     maxStackSize = size;
1210                 }
1211                 stackSize = size;
1212             }
1213         }
1214         // adds the instruction to the bytecode of the method
1215         int index = i.index;
1216         if (i.type == ClassWriter.LONG || i.type == ClassWriter.DOUBLE) {
1217             code.put12(20 /* LDC2_W */, index);
1218         } else if (index >= 256) {
1219             code.put12(19 /* LDC_W */, index);
1220         } else {
1221             code.put11(Opcodes.LDC, index);
1222         }
1223     }
1224 
1225     @Override
1226     public void visitIincInsn(final int var, final int increment) {
1227         lastCodeOffset = code.length;
1228         if (currentBlock != null) {
1229             if (compute == FRAMES || compute == INSERTED_FRAMES) {
1230                 currentBlock.frame.execute(Opcodes.IINC, var, null, null);
1231             }
1232         }
1233         if (compute != NOTHING) {
1234             // updates max locals
1235             int n = var + 1;
1236             if (n > maxLocals) {
1237                 maxLocals = n;
1238             }
1239         }
1240         // adds the instruction to the bytecode of the method
1241         if ((var > 255) || (increment > 127) || (increment < -128)) {
1242             code.putByte(196 /* WIDE */).put12(Opcodes.IINC, var)
1243                     .putShort(increment);
1244         } else {
1245             code.putByte(Opcodes.IINC).put11(var, increment);
1246         }
1247     }
1248 
1249     @Override
1250     public void visitTableSwitchInsn(final int min, final int max,
1251             final Label dflt, final Label... labels) {
1252         lastCodeOffset = code.length;
1253         // adds the instruction to the bytecode of the method
1254         int source = code.length;
1255         code.putByte(Opcodes.TABLESWITCH);
1256         code.putByteArray(null, 0, (4 - code.length % 4) % 4);
1257         dflt.put(this, code, source, true);
1258         code.putInt(min).putInt(max);
1259         for (int i = 0; i < labels.length; ++i) {
1260             labels[i].put(this, code, source, true);
1261         }
1262         // updates currentBlock
1263         visitSwitchInsn(dflt, labels);
1264     }
1265 
1266     @Override
1267     public void visitLookupSwitchInsn(final Label dflt, final int[] keys,
1268             final Label[] labels) {
1269         lastCodeOffset = code.length;
1270         // adds the instruction to the bytecode of the method
1271         int source = code.length;
1272         code.putByte(Opcodes.LOOKUPSWITCH);
1273         code.putByteArray(null, 0, (4 - code.length % 4) % 4);
1274         dflt.put(this, code, source, true);
1275         code.putInt(labels.length);
1276         for (int i = 0; i < labels.length; ++i) {
1277             code.putInt(keys[i]);
1278             labels[i].put(this, code, source, true);
1279         }
1280         // updates currentBlock
1281         visitSwitchInsn(dflt, labels);
1282     }
1283 
1284     private void visitSwitchInsn(final Label dflt, final Label[] labels) {
1285         // Label currentBlock = this.currentBlock;
1286         if (currentBlock != null) {
1287             if (compute == FRAMES) {
1288                 currentBlock.frame.execute(Opcodes.LOOKUPSWITCH, 0, null, null);
1289                 // adds current block successors
1290                 addSuccessor(Edge.NORMAL, dflt);
1291                 dflt.getFirst().status |= Label.TARGET;
1292                 for (int i = 0; i < labels.length; ++i) {
1293                     addSuccessor(Edge.NORMAL, labels[i]);
1294                     labels[i].getFirst().status |= Label.TARGET;
1295                 }
1296             } else {
1297                 // updates current stack size (max stack size unchanged)
1298                 --stackSize;
1299                 // adds current block successors
1300                 addSuccessor(stackSize, dflt);
1301                 for (int i = 0; i < labels.length; ++i) {
1302                     addSuccessor(stackSize, labels[i]);
1303                 }
1304             }
1305             // ends current block
1306             noSuccessor();
1307         }
1308     }
1309 
1310     @Override
1311     public void visitMultiANewArrayInsn(final String desc, final int dims) {
1312         lastCodeOffset = code.length;
1313         Item i = cw.newStringishItem(ClassWriter.CLASS, desc);
1314         // Label currentBlock = this.currentBlock;
1315         if (currentBlock != null) {
1316             if (compute == FRAMES || compute == INSERTED_FRAMES) {
1317                 currentBlock.frame.execute(Opcodes.MULTIANEWARRAY, dims, cw, i);
1318             } else {
1319                 // updates current stack size (max stack size unchanged because
1320                 // stack size variation always negative or null)
1321                 stackSize += 1 - dims;
1322             }
1323         }
1324         // adds the instruction to the bytecode of the method
1325         code.put12(Opcodes.MULTIANEWARRAY, i.index).putByte(dims);
1326     }
1327 
1328     @Override
1329     public AnnotationVisitor visitInsnAnnotation(int typeRef,
1330             TypePath typePath, String desc, boolean visible) {



1331         ByteVector bv = new ByteVector();
1332         // write target_type and target_info
1333         typeRef = (typeRef & 0xFF0000FF) | (lastCodeOffset << 8);
1334         AnnotationWriter.putTarget(typeRef, typePath, bv);
1335         // write type, and reserve space for values count
1336         bv.putShort(cw.newUTF8(desc)).putShort(0);
1337         AnnotationWriter aw = new AnnotationWriter(cw, true, bv, bv,
1338                 bv.length - 2);
1339         if (visible) {
1340             aw.next = ctanns;
1341             ctanns = aw;
1342         } else {
1343             aw.next = ictanns;
1344             ictanns = aw;
1345         }
1346         return aw;
1347     }
1348 
1349     @Override
1350     public void visitTryCatchBlock(final Label start, final Label end,
1351             final Label handler, final String type) {
1352         ++handlerCount;
1353         Handler h = new Handler();
1354         h.start = start;
1355         h.end = end;
1356         h.handler = handler;
1357         h.desc = type;
1358         h.type = type != null ? cw.newClass(type) : 0;
1359         if (lastHandler == null) {
1360             firstHandler = h;
1361         } else {
1362             lastHandler.next = h;
1363         }
1364         lastHandler = h;
1365     }
1366 
1367     @Override
1368     public AnnotationVisitor visitTryCatchAnnotation(int typeRef,
1369             TypePath typePath, String desc, boolean visible) {



1370         ByteVector bv = new ByteVector();
1371         // write target_type and target_info
1372         AnnotationWriter.putTarget(typeRef, typePath, bv);
1373         // write type, and reserve space for values count
1374         bv.putShort(cw.newUTF8(desc)).putShort(0);
1375         AnnotationWriter aw = new AnnotationWriter(cw, true, bv, bv,
1376                 bv.length - 2);
1377         if (visible) {
1378             aw.next = ctanns;
1379             ctanns = aw;
1380         } else {
1381             aw.next = ictanns;
1382             ictanns = aw;
1383         }
1384         return aw;
1385     }
1386 
1387     @Override
1388     public void visitLocalVariable(final String name, final String desc,
1389             final String signature, final Label start, final Label end,
1390             final int index) {
1391         if (signature != null) {
1392             if (localVarType == null) {
1393                 localVarType = new ByteVector();
1394             }
1395             ++localVarTypeCount;
1396             localVarType.putShort(start.position)
1397                     .putShort(end.position - start.position)
1398                     .putShort(cw.newUTF8(name)).putShort(cw.newUTF8(signature))
1399                     .putShort(index);
1400         }
1401         if (localVar == null) {
1402             localVar = new ByteVector();
1403         }
1404         ++localVarCount;
1405         localVar.putShort(start.position)
1406                 .putShort(end.position - start.position)
1407                 .putShort(cw.newUTF8(name)).putShort(cw.newUTF8(desc))
1408                 .putShort(index);
1409         if (compute != NOTHING) {
1410             // updates max locals
1411             char c = desc.charAt(0);
1412             int n = index + (c == 'J' || c == 'D' ? 2 : 1);
1413             if (n > maxLocals) {
1414                 maxLocals = n;
1415             }
1416         }
1417     }
1418 
1419     @Override
1420     public AnnotationVisitor visitLocalVariableAnnotation(int typeRef,
1421             TypePath typePath, Label[] start, Label[] end, int[] index,
1422             String desc, boolean visible) {



1423         ByteVector bv = new ByteVector();
1424         // write target_type and target_info
1425         bv.putByte(typeRef >>> 24).putShort(start.length);
1426         for (int i = 0; i < start.length; ++i) {
1427             bv.putShort(start[i].position)
1428                     .putShort(end[i].position - start[i].position)
1429                     .putShort(index[i]);
1430         }
1431         if (typePath == null) {
1432             bv.putByte(0);
1433         } else {
1434             int length = typePath.b[typePath.offset] * 2 + 1;
1435             bv.putByteArray(typePath.b, typePath.offset, length);
1436         }
1437         // write type, and reserve space for values count
1438         bv.putShort(cw.newUTF8(desc)).putShort(0);
1439         AnnotationWriter aw = new AnnotationWriter(cw, true, bv, bv,
1440                 bv.length - 2);
1441         if (visible) {
1442             aw.next = ctanns;
1443             ctanns = aw;
1444         } else {
1445             aw.next = ictanns;
1446             ictanns = aw;
1447         }
1448         return aw;
1449     }
1450 
1451     @Override
1452     public void visitLineNumber(final int line, final Label start) {
1453         if (lineNumber == null) {
1454             lineNumber = new ByteVector();
1455         }
1456         ++lineNumberCount;
1457         lineNumber.putShort(start.position);
1458         lineNumber.putShort(line);
1459     }
1460 
1461     @Override
1462     public void visitMaxs(final int maxStack, final int maxLocals) {
1463         if (compute == FRAMES) {








1464             // completes the control flow graph with exception handler blocks
1465             Handler handler = firstHandler;
1466             while (handler != null) {
1467                 Label l = handler.start.getFirst();
1468                 Label h = handler.handler.getFirst();
1469                 Label e = handler.end.getFirst();
1470                 // computes the kind of the edges to 'h'
1471                 String t = handler.desc == null ? "java/lang/Throwable"
1472                         : handler.desc;
1473                 int kind = Frame.OBJECT | cw.addType(t);
1474                 // h is an exception handler
1475                 h.status |= Label.TARGET;
1476                 // adds 'h' as a successor of labels between 'start' and 'end'
1477                 while (l != e) {
1478                     // creates an edge to 'h'
1479                     Edge b = new Edge();
1480                     b.info = kind;
1481                     b.successor = h;
1482                     // adds it to the successors of 'l'
1483                     b.next = l.successors;
1484                     l.successors = b;
1485                     // goes to the next label
1486                     l = l.successor;
1487                 }
1488                 handler = handler.next;
1489             }
1490 
1491             // creates and visits the first (implicit) frame
1492             Frame f = labels.frame;
1493             f.initInputFrame(cw, access, Type.getArgumentTypes(descriptor),
1494                     this.maxLocals);
1495             visitFrame(f);
1496 
1497             /*
1498              * fix point algorithm: mark the first basic block as 'changed'
1499              * (i.e. put it in the 'changed' list) and, while there are changed
1500              * basic blocks, choose one, mark it as unchanged, and update its
1501              * successors (which can be changed in the process).
1502              */
1503             int max = 0;
1504             Label changed = labels;
1505             while (changed != null) {
1506                 // removes a basic block from the list of changed basic blocks
1507                 Label l = changed;
1508                 changed = changed.next;
1509                 l.next = null;
1510                 f = l.frame;
1511                 // a reachable jump target must be stored in the stack map
1512                 if ((l.status & Label.TARGET) != 0) {
1513                     l.status |= Label.STORE;
1514                 }
1515                 // all visited labels are reachable, by definition
1516                 l.status |= Label.REACHABLE;
1517                 // updates the (absolute) maximum stack size
1518                 int blockMax = f.inputStack.length + l.outputStackMax;
1519                 if (blockMax > max) {
1520                     max = blockMax;
1521                 }
1522                 // updates the successors of the current basic block
1523                 Edge e = l.successors;
1524                 while (e != null) {
1525                     Label n = e.successor.getFirst();
1526                     boolean change = f.merge(cw, n.frame, e.info);
1527                     if (change && n.next == null) {
1528                         // if n has changed and is not already in the 'changed'
1529                         // list, adds it to this list
1530                         n.next = changed;
1531                         changed = n;
1532                     }
1533                     e = e.next;
1534                 }
1535             }
1536 
1537             // visits all the frames that must be stored in the stack map
1538             Label l = labels;
1539             while (l != null) {
1540                 f = l.frame;
1541                 if ((l.status & Label.STORE) != 0) {
1542                     visitFrame(f);
1543                 }
1544                 if ((l.status & Label.REACHABLE) == 0) {
1545                     // finds start and end of dead basic block
1546                     Label k = l.successor;
1547                     int start = l.position;
1548                     int end = (k == null ? code.length : k.position) - 1;
1549                     // if non empty basic block
1550                     if (end >= start) {
1551                         max = Math.max(max, 1);
1552                         // replaces instructions with NOP ... NOP ATHROW
1553                         for (int i = start; i < end; ++i) {
1554                             code.data[i] = Opcodes.NOP;
1555                         }
1556                         code.data[end] = (byte) Opcodes.ATHROW;
1557                         // emits a frame for this unreachable block
1558                         int frameIndex = startFrame(start, 0, 1);
1559                         frame[frameIndex] = Frame.OBJECT
1560                                 | cw.addType("java/lang/Throwable");
1561                         endFrame();
1562                         // removes the start-end range from the exception
1563                         // handlers
1564                         firstHandler = Handler.remove(firstHandler, l, k);
1565                     }
1566                 }
1567                 l = l.successor;
1568             }
1569 
1570             handler = firstHandler;
1571             handlerCount = 0;
1572             while (handler != null) {
1573                 handlerCount += 1;
1574                 handler = handler.next;
1575             }
1576 
1577             this.maxStack = max;
1578         } else if (compute == MAXS) {
1579             // completes the control flow graph with exception handler blocks
1580             Handler handler = firstHandler;
1581             while (handler != null) {
1582                 Label l = handler.start;
1583                 Label h = handler.handler;
1584                 Label e = handler.end;
1585                 // adds 'h' as a successor of labels between 'start' and 'end'
1586                 while (l != e) {
1587                     // creates an edge to 'h'
1588                     Edge b = new Edge();
1589                     b.info = Edge.EXCEPTION;
1590                     b.successor = h;
1591                     // adds it to the successors of 'l'
1592                     if ((l.status & Label.JSR) == 0) {
1593                         b.next = l.successors;
1594                         l.successors = b;
1595                     } else {
1596                         // if l is a JSR block, adds b after the first two edges
1597                         // to preserve the hypothesis about JSR block successors
1598                         // order (see {@link #visitJumpInsn})
1599                         b.next = l.successors.next.next;
1600                         l.successors.next.next = b;
1601                     }
1602                     // goes to the next label
1603                     l = l.successor;
1604                 }
1605                 handler = handler.next;
1606             }
1607 
1608             if (subroutines > 0) {
1609                 // completes the control flow graph with the RET successors
1610                 /*
1611                  * first step: finds the subroutines. This step determines, for
1612                  * each basic block, to which subroutine(s) it belongs.
1613                  */
1614                 // finds the basic blocks that belong to the "main" subroutine
1615                 int id = 0;
1616                 labels.visitSubroutine(null, 1, subroutines);
1617                 // finds the basic blocks that belong to the real subroutines
1618                 Label l = labels;
1619                 while (l != null) {
1620                     if ((l.status & Label.JSR) != 0) {
1621                         // the subroutine is defined by l's TARGET, not by l
1622                         Label subroutine = l.successors.next.successor;
1623                         // if this subroutine has not been visited yet...
1624                         if ((subroutine.status & Label.VISITED) == 0) {
1625                             // ...assigns it a new id and finds its basic blocks
1626                             id += 1;
1627                             subroutine.visitSubroutine(null, (id / 32L) << 32
1628                                     | (1L << (id % 32)), subroutines);
1629                         }
1630                     }
1631                     l = l.successor;
1632                 }
1633                 // second step: finds the successors of RET blocks
1634                 l = labels;
1635                 while (l != null) {
1636                     if ((l.status & Label.JSR) != 0) {
1637                         Label L = labels;
1638                         while (L != null) {
1639                             L.status &= ~Label.VISITED2;
1640                             L = L.successor;
1641                         }
1642                         // the subroutine is defined by l's TARGET, not by l
1643                         Label subroutine = l.successors.next.successor;
1644                         subroutine.visitSubroutine(l, 0, subroutines);
1645                     }
1646                     l = l.successor;
1647                 }
1648             }
1649 
1650             /*
1651              * control flow analysis algorithm: while the block stack is not
1652              * empty, pop a block from this stack, update the max stack size,
1653              * compute the true (non relative) begin stack size of the
1654              * successors of this block, and push these successors onto the
1655              * stack (unless they have already been pushed onto the stack).
1656              * Note: by hypothesis, the {@link Label#inputStackTop} of the
1657              * blocks in the block stack are the true (non relative) beginning
1658              * stack sizes of these blocks.
1659              */
1660             int max = 0;
1661             Label stack = labels;
1662             while (stack != null) {
1663                 // pops a block from the stack
1664                 Label l = stack;
1665                 stack = stack.next;
1666                 // computes the true (non relative) max stack size of this block
1667                 int start = l.inputStackTop;
1668                 int blockMax = start + l.outputStackMax;
1669                 // updates the global max stack size
1670                 if (blockMax > max) {
1671                     max = blockMax;
1672                 }
1673                 // analyzes the successors of the block
1674                 Edge b = l.successors;
1675                 if ((l.status & Label.JSR) != 0) {
1676                     // ignores the first edge of JSR blocks (virtual successor)
1677                     b = b.next;
1678                 }
1679                 while (b != null) {
1680                     l = b.successor;
1681                     // if this successor has not already been pushed...
1682                     if ((l.status & Label.PUSHED) == 0) {
1683                         // computes its true beginning stack size...
1684                         l.inputStackTop = b.info == Edge.EXCEPTION ? 1 : start
1685                                 + b.info;
1686                         // ...and pushes it onto the stack
1687                         l.status |= Label.PUSHED;
1688                         l.next = stack;
1689                         stack = l;
1690                     }
1691                     b = b.next;
1692                 }
1693             }
1694             this.maxStack = Math.max(maxStack, max);
1695         } else {
1696             this.maxStack = maxStack;
1697             this.maxLocals = maxLocals;
1698         }
1699     }
1700 
1701     @Override
1702     public void visitEnd() {
1703     }
1704 
1705     // ------------------------------------------------------------------------
1706     // Utility methods: control flow analysis algorithm
1707     // ------------------------------------------------------------------------
1708 
1709     /**
1710      * Adds a successor to the {@link #currentBlock currentBlock} block.
1711      *
1712      * @param info
1713      *            information about the control flow edge to be added.
1714      * @param successor
1715      *            the successor block to be added to the current block.
1716      */
1717     private void addSuccessor(final int info, final Label successor) {
1718         // creates and initializes an Edge object...
1719         Edge b = new Edge();
1720         b.info = info;
1721         b.successor = successor;
1722         // ...and adds it to the successor list of the currentBlock block
1723         b.next = currentBlock.successors;
1724         currentBlock.successors = b;
1725     }
1726 
1727     /**
1728      * Ends the current basic block. This method must be used in the case where
1729      * the current basic block does not have any successor.
1730      */
1731     private void noSuccessor() {
1732         if (compute == FRAMES) {
1733             Label l = new Label();
1734             l.frame = new Frame();
1735             l.frame.owner = l;
1736             l.resolve(this, code.length, code.data);
1737             previousBlock.successor = l;
1738             previousBlock = l;
1739         } else {
1740             currentBlock.outputStackMax = maxStackSize;
1741         }
1742         if (compute != INSERTED_FRAMES) {
1743             currentBlock = null;
1744         }
1745     }
1746 
1747     // ------------------------------------------------------------------------
1748     // Utility methods: stack map frames
1749     // ------------------------------------------------------------------------
1750 
1751     /**
1752      * Visits a frame that has been computed from scratch.
1753      *
1754      * @param f
1755      *            the frame that must be visited.
1756      */
1757     private void visitFrame(final Frame f) {
1758         int i, t;
1759         int nTop = 0;
1760         int nLocal = 0;
1761         int nStack = 0;
1762         int[] locals = f.inputLocals;
1763         int[] stacks = f.inputStack;
1764         // computes the number of locals (ignores TOP types that are just after
1765         // a LONG or a DOUBLE, and all trailing TOP types)
1766         for (i = 0; i < locals.length; ++i) {
1767             t = locals[i];
1768             if (t == Frame.TOP) {
1769                 ++nTop;
1770             } else {
1771                 nLocal += nTop + 1;
1772                 nTop = 0;
1773             }
1774             if (t == Frame.LONG || t == Frame.DOUBLE) {
1775                 ++i;
1776             }
1777         }
1778         // computes the stack size (ignores TOP types that are just after
1779         // a LONG or a DOUBLE)
1780         for (i = 0; i < stacks.length; ++i) {
1781             t = stacks[i];
1782             ++nStack;
1783             if (t == Frame.LONG || t == Frame.DOUBLE) {
1784                 ++i;
1785             }
1786         }
1787         // visits the frame and its content
1788         int frameIndex = startFrame(f.owner.position, nLocal, nStack);
1789         for (i = 0; nLocal > 0; ++i, --nLocal) {
1790             t = locals[i];
1791             frame[frameIndex++] = t;
1792             if (t == Frame.LONG || t == Frame.DOUBLE) {
1793                 ++i;
1794             }
1795         }
1796         for (i = 0; i < stacks.length; ++i) {
1797             t = stacks[i];
1798             frame[frameIndex++] = t;
1799             if (t == Frame.LONG || t == Frame.DOUBLE) {
1800                 ++i;
1801             }
1802         }
1803         endFrame();
1804     }
1805 
1806     /**
1807      * Visit the implicit first frame of this method.
1808      */
1809     private void visitImplicitFirstFrame() {
1810         // There can be at most descriptor.length() + 1 locals
1811         int frameIndex = startFrame(0, descriptor.length() + 1, 0);
1812         if ((access & Opcodes.ACC_STATIC) == 0) {
1813             if ((access & ACC_CONSTRUCTOR) == 0) {
1814                 frame[frameIndex++] = Frame.OBJECT | cw.addType(cw.thisName);
1815             } else {
1816                 frame[frameIndex++] = Frame.UNINITIALIZED_THIS;
1817             }
1818         }
1819         int i = 1;
1820         loop: while (true) {
1821             int j = i;
1822             switch (descriptor.charAt(i++)) {
1823             case 'Z':
1824             case 'C':
1825             case 'B':
1826             case 'S':
1827             case 'I':
1828                 frame[frameIndex++] = Frame.INTEGER;
1829                 break;
1830             case 'F':
1831                 frame[frameIndex++] = Frame.FLOAT;
1832                 break;
1833             case 'J':
1834                 frame[frameIndex++] = Frame.LONG;
1835                 break;
1836             case 'D':
1837                 frame[frameIndex++] = Frame.DOUBLE;
1838                 break;
1839             case '[':
1840                 while (descriptor.charAt(i) == '[') {
1841                     ++i;
1842                 }
1843                 if (descriptor.charAt(i) == 'L') {
1844                     ++i;
1845                     while (descriptor.charAt(i) != ';') {
1846                         ++i;
1847                     }
1848                 }
1849                 frame[frameIndex++] = Frame.type(cw, descriptor.substring(j, ++i));

1850                 break;
1851             case 'L':
1852                 while (descriptor.charAt(i) != ';') {
1853                     ++i;
1854                 }
1855                 frame[frameIndex++] = Frame.OBJECT
1856                         | cw.addType(descriptor.substring(j + 1, i++));
1857                 break;
1858             default:
1859                 break loop;
1860             }
1861         }
1862         frame[1] = frameIndex - 3;
1863         endFrame();
1864     }
1865 
1866     /**
1867      * Starts the visit of a stack map frame.
1868      *
1869      * @param offset
1870      *            the offset of the instruction to which the frame corresponds.
1871      * @param nLocal
1872      *            the number of local variables in the frame.
1873      * @param nStack
1874      *            the number of stack elements in the frame.
1875      * @return the index of the next element to be written in this frame.
1876      */
1877     private int startFrame(final int offset, final int nLocal, final int nStack) {
1878         int n = 3 + nLocal + nStack;
1879         if (frame == null || frame.length < n) {
1880             frame = new int[n];
1881         }
1882         frame[0] = offset;
1883         frame[1] = nLocal;
1884         frame[2] = nStack;
1885         return 3;
1886     }
1887 
1888     /**
1889      * Checks if the visit of the current frame {@link #frame} is finished, and
1890      * if yes, write it in the StackMapTable attribute.
1891      */
1892     private void endFrame() {
1893         if (previousFrame != null) { // do not write the first frame
1894             if (stackMap == null) {
1895                 stackMap = new ByteVector();
1896             }
1897             writeFrame();
1898             ++frameCount;
1899         }
1900         previousFrame = frame;
1901         frame = null;
1902     }
1903 
1904     /**
1905      * Compress and writes the current frame {@link #frame} in the StackMapTable
1906      * attribute.
1907      */
1908     private void writeFrame() {
1909         int clocalsSize = frame[1];
1910         int cstackSize = frame[2];
1911         if ((cw.version & 0xFFFF) < Opcodes.V1_6) {
1912             stackMap.putShort(frame[0]).putShort(clocalsSize);
1913             writeFrameTypes(3, 3 + clocalsSize);
1914             stackMap.putShort(cstackSize);
1915             writeFrameTypes(3 + clocalsSize, 3 + clocalsSize + cstackSize);
1916             return;
1917         }
1918         int localsSize = previousFrame[1];
1919         int type = FULL_FRAME;
1920         int k = 0;
1921         int delta;
1922         if (frameCount == 0) {
1923             delta = frame[0];
1924         } else {
1925             delta = frame[0] - previousFrame[0] - 1;
1926         }
1927         if (cstackSize == 0) {
1928             k = clocalsSize - localsSize;
1929             switch (k) {
1930             case -3:
1931             case -2:
1932             case -1:
1933                 type = CHOP_FRAME;
1934                 localsSize = clocalsSize;
1935                 break;
1936             case 0:
1937                 type = delta < 64 ? SAME_FRAME : SAME_FRAME_EXTENDED;
1938                 break;
1939             case 1:
1940             case 2:
1941             case 3:
1942                 type = APPEND_FRAME;
1943                 break;
1944             }
1945         } else if (clocalsSize == localsSize && cstackSize == 1) {
1946             type = delta < 63 ? SAME_LOCALS_1_STACK_ITEM_FRAME
1947                     : SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED;
1948         }
1949         if (type != FULL_FRAME) {
1950             // verify if locals are the same
1951             int l = 3;
1952             for (int j = 0; j < localsSize; j++) {
1953                 if (frame[l] != previousFrame[l]) {
1954                     type = FULL_FRAME;
1955                     break;
1956                 }
1957                 l++;
1958             }
1959         }
1960         switch (type) {
1961         case SAME_FRAME:
1962             stackMap.putByte(delta);
1963             break;
1964         case SAME_LOCALS_1_STACK_ITEM_FRAME:
1965             stackMap.putByte(SAME_LOCALS_1_STACK_ITEM_FRAME + delta);
1966             writeFrameTypes(3 + clocalsSize, 4 + clocalsSize);
1967             break;
1968         case SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED:
1969             stackMap.putByte(SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED).putShort(
1970                     delta);
1971             writeFrameTypes(3 + clocalsSize, 4 + clocalsSize);
1972             break;
1973         case SAME_FRAME_EXTENDED:
1974             stackMap.putByte(SAME_FRAME_EXTENDED).putShort(delta);
1975             break;
1976         case CHOP_FRAME:
1977             stackMap.putByte(SAME_FRAME_EXTENDED + k).putShort(delta);
1978             break;
1979         case APPEND_FRAME:
1980             stackMap.putByte(SAME_FRAME_EXTENDED + k).putShort(delta);
1981             writeFrameTypes(3 + localsSize, 3 + clocalsSize);
1982             break;
1983         // case FULL_FRAME:
1984         default:
1985             stackMap.putByte(FULL_FRAME).putShort(delta).putShort(clocalsSize);
1986             writeFrameTypes(3, 3 + clocalsSize);
1987             stackMap.putShort(cstackSize);
1988             writeFrameTypes(3 + clocalsSize, 3 + clocalsSize + cstackSize);
1989         }
1990     }
1991 
1992     /**
1993      * Writes some types of the current frame {@link #frame} into the
1994      * StackMapTableAttribute. This method converts types from the format used
1995      * in {@link Label} to the format used in StackMapTable attributes. In
1996      * particular, it converts type table indexes to constant pool indexes.
1997      *
1998      * @param start
1999      *            index of the first type in {@link #frame} to write.
2000      * @param end
2001      *            index of last type in {@link #frame} to write (exclusive).
2002      */
2003     private void writeFrameTypes(final int start, final int end) {
2004         for (int i = start; i < end; ++i) {
2005             int t = frame[i];
2006             int d = t & Frame.DIM;
2007             if (d == 0) {
2008                 int v = t & Frame.BASE_VALUE;
2009                 switch (t & Frame.BASE_KIND) {
2010                 case Frame.OBJECT:
2011                     stackMap.putByte(7).putShort(
2012                             cw.newClass(cw.typeTable[v].strVal1));
2013                     break;
2014                 case Frame.UNINITIALIZED:
2015                     stackMap.putByte(8).putShort(cw.typeTable[v].intVal);
2016                     break;
2017                 default:
2018                     stackMap.putByte(v);
2019                 }
2020             } else {
2021                 StringBuilder sb = new StringBuilder();
2022                 d >>= 28;
2023                 while (d-- > 0) {
2024                     sb.append('[');
2025                 }
2026                 if ((t & Frame.BASE_KIND) == Frame.OBJECT) {
2027                     sb.append('L');
2028                     sb.append(cw.typeTable[t & Frame.BASE_VALUE].strVal1);
2029                     sb.append(';');
2030                 } else {
2031                     switch (t & 0xF) {
2032                     case 1:
2033                         sb.append('I');
2034                         break;
2035                     case 2:
2036                         sb.append('F');
2037                         break;
2038                     case 3:
2039                         sb.append('D');
2040                         break;
2041                     case 9:
2042                         sb.append('Z');
2043                         break;
2044                     case 10:
2045                         sb.append('B');
2046                         break;
2047                     case 11:
2048                         sb.append('C');
2049                         break;
2050                     case 12:
2051                         sb.append('S');
2052                         break;
2053                     default:
2054                         sb.append('J');
2055                     }
2056                 }
2057                 stackMap.putByte(7).putShort(cw.newClass(sb.toString()));
2058             }
2059         }
2060     }
2061 
2062     private void writeFrameType(final Object type) {
2063         if (type instanceof String) {
2064             stackMap.putByte(7).putShort(cw.newClass((String) type));
2065         } else if (type instanceof Integer) {
2066             stackMap.putByte(((Integer) type).intValue());
2067         } else {
2068             stackMap.putByte(8).putShort(((Label) type).position);
2069         }
2070     }
2071 
2072     // ------------------------------------------------------------------------
2073     // Utility methods: dump bytecode array
2074     // ------------------------------------------------------------------------
2075 
2076     /**
2077      * Returns the size of the bytecode of this method.
2078      *
2079      * @return the size of the bytecode of this method.
2080      */
2081     final int getSize() {
2082         if (classReaderOffset != 0) {
2083             return 6 + classReaderLength;
2084         }
2085         int size = 8;
2086         if (code.length > 0) {
2087             if (code.length > 65535) {
2088                 throw new RuntimeException("Method code too large!");
2089             }
2090             cw.newUTF8("Code");
2091             size += 18 + code.length + 8 * handlerCount;
2092             if (localVar != null) {
2093                 cw.newUTF8("LocalVariableTable");
2094                 size += 8 + localVar.length;
2095             }
2096             if (localVarType != null) {
2097                 cw.newUTF8("LocalVariableTypeTable");
2098                 size += 8 + localVarType.length;
2099             }
2100             if (lineNumber != null) {
2101                 cw.newUTF8("LineNumberTable");
2102                 size += 8 + lineNumber.length;
2103             }
2104             if (stackMap != null) {
2105                 boolean zip = (cw.version & 0xFFFF) >= Opcodes.V1_6;
2106                 cw.newUTF8(zip ? "StackMapTable" : "StackMap");
2107                 size += 8 + stackMap.length;
2108             }
2109             if (ctanns != null) {
2110                 cw.newUTF8("RuntimeVisibleTypeAnnotations");
2111                 size += 8 + ctanns.getSize();
2112             }
2113             if (ictanns != null) {
2114                 cw.newUTF8("RuntimeInvisibleTypeAnnotations");
2115                 size += 8 + ictanns.getSize();
2116             }
2117             if (cattrs != null) {
2118                 size += cattrs.getSize(cw, code.data, code.length, maxStack,
2119                         maxLocals);
2120             }
2121         }
2122         if (exceptionCount > 0) {
2123             cw.newUTF8("Exceptions");
2124             size += 8 + 2 * exceptionCount;
2125         }
2126         if ((access & Opcodes.ACC_SYNTHETIC) != 0) {
2127             if ((cw.version & 0xFFFF) < Opcodes.V1_5
2128                     || (access & ClassWriter.ACC_SYNTHETIC_ATTRIBUTE) != 0) {
2129                 cw.newUTF8("Synthetic");
2130                 size += 6;
2131             }
2132         }
2133         if ((access & Opcodes.ACC_DEPRECATED) != 0) {
2134             cw.newUTF8("Deprecated");
2135             size += 6;
2136         }
2137         if (signature != null) {
2138             cw.newUTF8("Signature");
2139             cw.newUTF8(signature);
2140             size += 8;
2141         }
2142         if (methodParameters != null) {
2143             cw.newUTF8("MethodParameters");
2144             size += 7 + methodParameters.length;
2145         }
2146         if (annd != null) {
2147             cw.newUTF8("AnnotationDefault");
2148             size += 6 + annd.length;
2149         }
2150         if (anns != null) {
2151             cw.newUTF8("RuntimeVisibleAnnotations");
2152             size += 8 + anns.getSize();
2153         }
2154         if (ianns != null) {
2155             cw.newUTF8("RuntimeInvisibleAnnotations");
2156             size += 8 + ianns.getSize();
2157         }
2158         if (tanns != null) {
2159             cw.newUTF8("RuntimeVisibleTypeAnnotations");
2160             size += 8 + tanns.getSize();
2161         }
2162         if (itanns != null) {
2163             cw.newUTF8("RuntimeInvisibleTypeAnnotations");
2164             size += 8 + itanns.getSize();
2165         }
2166         if (panns != null) {
2167             cw.newUTF8("RuntimeVisibleParameterAnnotations");
2168             size += 7 + 2 * (panns.length - synthetics);
2169             for (int i = panns.length - 1; i >= synthetics; --i) {
2170                 size += panns[i] == null ? 0 : panns[i].getSize();
2171             }
2172         }
2173         if (ipanns != null) {
2174             cw.newUTF8("RuntimeInvisibleParameterAnnotations");
2175             size += 7 + 2 * (ipanns.length - synthetics);
2176             for (int i = ipanns.length - 1; i >= synthetics; --i) {
2177                 size += ipanns[i] == null ? 0 : ipanns[i].getSize();
2178             }
2179         }
2180         if (attrs != null) {
2181             size += attrs.getSize(cw, null, 0, -1, -1);
2182         }
2183         return size;
2184     }
2185 
2186     /**
2187      * Puts the bytecode of this method in the given byte vector.
2188      *
2189      * @param out
2190      *            the byte vector into which the bytecode of this method must be
2191      *            copied.
2192      */
2193     final void put(final ByteVector out) {
2194         final int FACTOR = ClassWriter.TO_ACC_SYNTHETIC;
2195         int mask = ACC_CONSTRUCTOR | Opcodes.ACC_DEPRECATED
2196                 | ClassWriter.ACC_SYNTHETIC_ATTRIBUTE
2197                 | ((access & ClassWriter.ACC_SYNTHETIC_ATTRIBUTE) / FACTOR);
2198         out.putShort(access & ~mask).putShort(name).putShort(desc);
2199         if (classReaderOffset != 0) {
2200             out.putByteArray(cw.cr.b, classReaderOffset, classReaderLength);
2201             return;
2202         }
2203         int attributeCount = 0;
2204         if (code.length > 0) {
2205             ++attributeCount;
2206         }
2207         if (exceptionCount > 0) {
2208             ++attributeCount;
2209         }
2210         if ((access & Opcodes.ACC_SYNTHETIC) != 0) {
2211             if ((cw.version & 0xFFFF) < Opcodes.V1_5
2212                     || (access & ClassWriter.ACC_SYNTHETIC_ATTRIBUTE) != 0) {
2213                 ++attributeCount;
2214             }
2215         }
2216         if ((access & Opcodes.ACC_DEPRECATED) != 0) {
2217             ++attributeCount;
2218         }
2219         if (signature != null) {
2220             ++attributeCount;
2221         }
2222         if (methodParameters != null) {
2223             ++attributeCount;
2224         }
2225         if (annd != null) {
2226             ++attributeCount;
2227         }
2228         if (anns != null) {
2229             ++attributeCount;
2230         }
2231         if (ianns != null) {
2232             ++attributeCount;
2233         }
2234         if (tanns != null) {
2235             ++attributeCount;
2236         }
2237         if (itanns != null) {
2238             ++attributeCount;
2239         }
2240         if (panns != null) {
2241             ++attributeCount;
2242         }
2243         if (ipanns != null) {
2244             ++attributeCount;
2245         }
2246         if (attrs != null) {
2247             attributeCount += attrs.getCount();
2248         }
2249         out.putShort(attributeCount);
2250         if (code.length > 0) {
2251             int size = 12 + code.length + 8 * handlerCount;
2252             if (localVar != null) {
2253                 size += 8 + localVar.length;
2254             }
2255             if (localVarType != null) {
2256                 size += 8 + localVarType.length;
2257             }
2258             if (lineNumber != null) {
2259                 size += 8 + lineNumber.length;
2260             }
2261             if (stackMap != null) {
2262                 size += 8 + stackMap.length;
2263             }
2264             if (ctanns != null) {
2265                 size += 8 + ctanns.getSize();
2266             }
2267             if (ictanns != null) {
2268                 size += 8 + ictanns.getSize();
2269             }
2270             if (cattrs != null) {
2271                 size += cattrs.getSize(cw, code.data, code.length, maxStack,
2272                         maxLocals);
2273             }
2274             out.putShort(cw.newUTF8("Code")).putInt(size);
2275             out.putShort(maxStack).putShort(maxLocals);
2276             out.putInt(code.length).putByteArray(code.data, 0, code.length);
2277             out.putShort(handlerCount);
2278             if (handlerCount > 0) {
2279                 Handler h = firstHandler;
2280                 while (h != null) {
2281                     out.putShort(h.start.position).putShort(h.end.position)
2282                             .putShort(h.handler.position).putShort(h.type);
2283                     h = h.next;
2284                 }
2285             }
2286             attributeCount = 0;
2287             if (localVar != null) {
2288                 ++attributeCount;
2289             }
2290             if (localVarType != null) {
2291                 ++attributeCount;
2292             }
2293             if (lineNumber != null) {
2294                 ++attributeCount;
2295             }
2296             if (stackMap != null) {
2297                 ++attributeCount;
2298             }
2299             if (ctanns != null) {
2300                 ++attributeCount;
2301             }
2302             if (ictanns != null) {
2303                 ++attributeCount;
2304             }
2305             if (cattrs != null) {
2306                 attributeCount += cattrs.getCount();
2307             }
2308             out.putShort(attributeCount);
2309             if (localVar != null) {
2310                 out.putShort(cw.newUTF8("LocalVariableTable"));
2311                 out.putInt(localVar.length + 2).putShort(localVarCount);
2312                 out.putByteArray(localVar.data, 0, localVar.length);
2313             }
2314             if (localVarType != null) {
2315                 out.putShort(cw.newUTF8("LocalVariableTypeTable"));
2316                 out.putInt(localVarType.length + 2).putShort(localVarTypeCount);
2317                 out.putByteArray(localVarType.data, 0, localVarType.length);
2318             }
2319             if (lineNumber != null) {
2320                 out.putShort(cw.newUTF8("LineNumberTable"));
2321                 out.putInt(lineNumber.length + 2).putShort(lineNumberCount);
2322                 out.putByteArray(lineNumber.data, 0, lineNumber.length);
2323             }
2324             if (stackMap != null) {
2325                 boolean zip = (cw.version & 0xFFFF) >= Opcodes.V1_6;
2326                 out.putShort(cw.newUTF8(zip ? "StackMapTable" : "StackMap"));
2327                 out.putInt(stackMap.length + 2).putShort(frameCount);
2328                 out.putByteArray(stackMap.data, 0, stackMap.length);
2329             }
2330             if (ctanns != null) {
2331                 out.putShort(cw.newUTF8("RuntimeVisibleTypeAnnotations"));
2332                 ctanns.put(out);
2333             }
2334             if (ictanns != null) {
2335                 out.putShort(cw.newUTF8("RuntimeInvisibleTypeAnnotations"));
2336                 ictanns.put(out);
2337             }
2338             if (cattrs != null) {
2339                 cattrs.put(cw, code.data, code.length, maxLocals, maxStack, out);
2340             }
2341         }
2342         if (exceptionCount > 0) {
2343             out.putShort(cw.newUTF8("Exceptions")).putInt(
2344                     2 * exceptionCount + 2);
2345             out.putShort(exceptionCount);
2346             for (int i = 0; i < exceptionCount; ++i) {
2347                 out.putShort(exceptions[i]);
2348             }
2349         }
2350         if ((access & Opcodes.ACC_SYNTHETIC) != 0) {
2351             if ((cw.version & 0xFFFF) < Opcodes.V1_5
2352                     || (access & ClassWriter.ACC_SYNTHETIC_ATTRIBUTE) != 0) {
2353                 out.putShort(cw.newUTF8("Synthetic")).putInt(0);
2354             }
2355         }
2356         if ((access & Opcodes.ACC_DEPRECATED) != 0) {
2357             out.putShort(cw.newUTF8("Deprecated")).putInt(0);
2358         }
2359         if (signature != null) {
2360             out.putShort(cw.newUTF8("Signature")).putInt(2)
2361                     .putShort(cw.newUTF8(signature));
2362         }
2363         if (methodParameters != null) {
2364             out.putShort(cw.newUTF8("MethodParameters"));
2365             out.putInt(methodParameters.length + 1).putByte(
2366                     methodParametersCount);
2367             out.putByteArray(methodParameters.data, 0, methodParameters.length);
2368         }
2369         if (annd != null) {
2370             out.putShort(cw.newUTF8("AnnotationDefault"));
2371             out.putInt(annd.length);
2372             out.putByteArray(annd.data, 0, annd.length);
2373         }
2374         if (anns != null) {
2375             out.putShort(cw.newUTF8("RuntimeVisibleAnnotations"));
2376             anns.put(out);
2377         }
2378         if (ianns != null) {
2379             out.putShort(cw.newUTF8("RuntimeInvisibleAnnotations"));
2380             ianns.put(out);
2381         }
2382         if (tanns != null) {
2383             out.putShort(cw.newUTF8("RuntimeVisibleTypeAnnotations"));
2384             tanns.put(out);
2385         }
2386         if (itanns != null) {
2387             out.putShort(cw.newUTF8("RuntimeInvisibleTypeAnnotations"));
2388             itanns.put(out);
2389         }
2390         if (panns != null) {
2391             out.putShort(cw.newUTF8("RuntimeVisibleParameterAnnotations"));
2392             AnnotationWriter.put(panns, synthetics, out);
2393         }
2394         if (ipanns != null) {
2395             out.putShort(cw.newUTF8("RuntimeInvisibleParameterAnnotations"));
2396             AnnotationWriter.put(ipanns, synthetics, out);
2397         }
2398         if (attrs != null) {
2399             attrs.put(cw, null, 0, -1, -1, out);
2400         }
2401     }





















































































































































































































































































































































































































































































































































































2402 }
--- EOF ---