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 private static final int FRAMES = 0;
132
133 /**
134 * Indicates that the maximum stack size and number of local variables must
135 * be automatically computed.
136 *
137 * @see #compute
138 */
139 private static final int MAXS = 1;
140
141 /**
142 * Indicates that nothing must be automatically computed.
143 *
144 * @see #compute
145 */
146 private static final int NOTHING = 2;
147
148 /**
149 * The class writer to which this method must be added.
150 */
151 final ClassWriter cw;
152
153 /**
154 * Access flags of this method.
155 */
156 private int access;
157
158 /**
159 * The index of the constant pool item that contains the name of this
160 * method.
161 */
162 private final int name;
163
164 /**
165 * The index of the constant pool item that contains the descriptor of this
166 * method.
167 */
168 private final int desc;
169
170 /**
171 * The descriptor of this method.
172 */
173 private final String descriptor;
174
175 /**
176 * The signature of this method.
177 */
178 String signature;
179
180 /**
181 * If not zero, indicates that the code of this method must be copied from
182 * the ClassReader associated to this writer in <code>cw.cr</code>. More
183 * precisely, this field gives the index of the first byte to copied from
184 * <code>cw.cr.b</code>.
185 */
186 int classReaderOffset;
187
188 /**
189 * If not zero, indicates that the code of this method must be copied from
190 * the ClassReader associated to this writer in <code>cw.cr</code>. More
191 * precisely, this field gives the number of bytes to copied from
192 * <code>cw.cr.b</code>.
193 */
194 int classReaderLength;
195
196 /**
197 * Number of exceptions that can be thrown by this method.
198 */
199 int exceptionCount;
200
201 /**
202 * The exceptions that can be thrown by this method. More precisely, this
203 * array contains the indexes of the constant pool items that contain the
204 * internal names of these exception classes.
205 */
206 int[] exceptions;
207
208 /**
209 * The annotation default attribute of this method. May be <tt>null</tt>.
210 */
211 private ByteVector annd;
212
213 /**
214 * The runtime visible annotations of this method. May be <tt>null</tt>.
215 */
216 private AnnotationWriter anns;
217
218 /**
219 * The runtime invisible annotations of this method. May be <tt>null</tt>.
220 */
221 private AnnotationWriter ianns;
222
223 /**
224 * The runtime visible type annotations of this method. May be <tt>null</tt>
225 * .
226 */
227 private AnnotationWriter tanns;
228
229 /**
230 * The runtime invisible type annotations of this method. May be
231 * <tt>null</tt>.
232 */
233 private AnnotationWriter itanns;
234
235 /**
236 * The runtime visible parameter annotations of this method. May be
237 * <tt>null</tt>.
238 */
239 private AnnotationWriter[] panns;
240
241 /**
242 * The runtime invisible parameter annotations of this method. May be
243 * <tt>null</tt>.
244 */
245 private AnnotationWriter[] ipanns;
246
247 /**
248 * The number of synthetic parameters of this method.
249 */
250 private int synthetics;
251
252 /**
253 * The non standard attributes of the method.
254 */
255 private Attribute attrs;
256
257 /**
258 * The bytecode of this method.
259 */
260 private ByteVector code = new ByteVector();
261
262 /**
263 * Maximum stack size of this method.
264 */
265 private int maxStack;
266
267 /**
268 * Maximum number of local variables for this method.
269 */
270 private int maxLocals;
271
272 /**
273 * Number of local variables in the current stack map frame.
274 */
275 private int currentLocals;
276
277 /**
278 * Number of stack map frames in the StackMapTable attribute.
279 */
280 private int frameCount;
281
282 /**
283 * The StackMapTable attribute.
284 */
285 private ByteVector stackMap;
286
287 /**
288 * The offset of the last frame that was written in the StackMapTable
289 * attribute.
290 */
291 private int previousFrameOffset;
292
293 /**
294 * The last frame that was written in the StackMapTable attribute.
295 *
296 * @see #frame
297 */
298 private int[] previousFrame;
299
300 /**
301 * The current stack map frame. The first element contains the offset of the
302 * instruction to which the frame corresponds, the second element is the
303 * number of locals and the third one is the number of stack elements. The
304 * local variables start at index 3 and are followed by the operand stack
305 * values. In summary frame[0] = offset, frame[1] = nLocal, frame[2] =
306 * nStack, frame[3] = nLocal. All types are encoded as integers, with the
307 * same format as the one used in {@link Label}, but limited to BASE types.
308 */
309 private int[] frame;
310
311 /**
312 * Number of elements in the exception handler list.
313 */
314 private int handlerCount;
315
316 /**
317 * The first element in the exception handler list.
318 */
319 private Handler firstHandler;
320
321 /**
322 * The last element in the exception handler list.
323 */
324 private Handler lastHandler;
325
326 /**
327 * Number of entries in the MethodParameters attribute.
328 */
329 private int methodParametersCount;
330
331 /**
332 * The MethodParameters attribute.
333 */
334 private ByteVector methodParameters;
335
336 /**
337 * Number of entries in the LocalVariableTable attribute.
338 */
339 private int localVarCount;
340
341 /**
342 * The LocalVariableTable attribute.
343 */
344 private ByteVector localVar;
345
346 /**
347 * Number of entries in the LocalVariableTypeTable attribute.
348 */
349 private int localVarTypeCount;
350
351 /**
352 * The LocalVariableTypeTable attribute.
353 */
354 private ByteVector localVarType;
355
356 /**
357 * Number of entries in the LineNumberTable attribute.
358 */
359 private int lineNumberCount;
360
361 /**
362 * The LineNumberTable attribute.
363 */
364 private ByteVector lineNumber;
365
366 /**
367 * The start offset of the last visited instruction.
368 */
369 private int lastCodeOffset;
370
371 /**
372 * The runtime visible type annotations of the code. May be <tt>null</tt>.
373 */
374 private AnnotationWriter ctanns;
375
376 /**
377 * The runtime invisible type annotations of the code. May be <tt>null</tt>.
378 */
379 private AnnotationWriter ictanns;
380
381 /**
382 * The non standard attributes of the method's code.
383 */
384 private Attribute cattrs;
385
386 /**
387 * Indicates if some jump instructions are too small and need to be resized.
388 */
389 private boolean resize;
390
391 /**
392 * The number of subroutines in this method.
393 */
394 private int subroutines;
395
396 // ------------------------------------------------------------------------
397
398 /*
399 * Fields for the control flow graph analysis algorithm (used to compute the
400 * maximum stack size). A control flow graph contains one node per "basic
401 * block", and one edge per "jump" from one basic block to another. Each
402 * node (i.e., each basic block) is represented by the Label object that
403 * corresponds to the first instruction of this basic block. Each node also
404 * stores the list of its successors in the graph, as a linked list of Edge
405 * objects.
406 */
407
408 /**
409 * Indicates what must be automatically computed.
410 *
411 * @see #FRAMES
412 * @see #MAXS
413 * @see #NOTHING
414 */
415 private final int compute;
416
417 /**
418 * A list of labels. This list is the list of basic blocks in the method,
419 * i.e. a list of Label objects linked to each other by their
420 * {@link Label#successor} field, in the order they are visited by
421 * {@link MethodVisitor#visitLabel}, and starting with the first basic
422 * block.
423 */
424 private Label labels;
425
426 /**
427 * The previous basic block.
428 */
429 private Label previousBlock;
430
431 /**
432 * The current basic block.
433 */
434 private Label currentBlock;
435
436 /**
437 * The (relative) stack size after the last visited instruction. This size
438 * is relative to the beginning of the current basic block, i.e., the true
439 * stack size after the last visited instruction is equal to the
440 * {@link Label#inputStackTop beginStackSize} of the current basic block
441 * plus <tt>stackSize</tt>.
442 */
443 private int stackSize;
444
445 /**
446 * The (relative) maximum stack size after the last visited instruction.
447 * This size is relative to the beginning of the current basic block, i.e.,
448 * the true maximum stack size after the last visited instruction is equal
449 * to the {@link Label#inputStackTop beginStackSize} of the current basic
450 * block plus <tt>stackSize</tt>.
451 */
452 private int maxStackSize;
453
454 // ------------------------------------------------------------------------
455 // Constructor
456 // ------------------------------------------------------------------------
457
458 /**
459 * Constructs a new {@link MethodWriter}.
460 *
461 * @param cw
462 * the class writer in which the method must be added.
463 * @param access
464 * the method's access flags (see {@link Opcodes}).
465 * @param name
466 * the method's name.
467 * @param desc
468 * the method's descriptor (see {@link Type}).
469 * @param signature
470 * the method's signature. May be <tt>null</tt>.
471 * @param exceptions
472 * the internal names of the method's exceptions. May be
473 * <tt>null</tt>.
474 * @param computeMaxs
475 * <tt>true</tt> if the maximum stack size and number of local
476 * variables must be automatically computed.
477 * @param computeFrames
478 * <tt>true</tt> if the stack map tables must be recomputed from
479 * scratch.
480 */
481 MethodWriter(final ClassWriter cw, final int access, final String name,
482 final String desc, final String signature,
483 final String[] exceptions, final boolean computeMaxs,
484 final boolean computeFrames) {
485 super(Opcodes.ASM5);
486 if (cw.firstMethod == null) {
487 cw.firstMethod = this;
488 } else {
489 cw.lastMethod.mv = this;
490 }
491 cw.lastMethod = this;
492 this.cw = cw;
493 this.access = access;
494 if ("<init>".equals(name)) {
495 this.access |= ACC_CONSTRUCTOR;
496 }
497 this.name = cw.newUTF8(name);
498 this.desc = cw.newUTF8(desc);
499 this.descriptor = desc;
500 if (ClassReader.SIGNATURES) {
501 this.signature = signature;
502 }
503 if (exceptions != null && exceptions.length > 0) {
504 exceptionCount = exceptions.length;
505 this.exceptions = new int[exceptionCount];
506 for (int i = 0; i < exceptionCount; ++i) {
507 this.exceptions[i] = cw.newClass(exceptions[i]);
508 }
509 }
510 this.compute = computeFrames ? FRAMES : (computeMaxs ? MAXS : NOTHING);
511 if (computeMaxs || computeFrames) {
512 // updates maxLocals
513 int size = Type.getArgumentsAndReturnSizes(descriptor) >> 2;
514 if ((access & Opcodes.ACC_STATIC) != 0) {
515 --size;
516 }
517 maxLocals = size;
518 currentLocals = size;
519 // creates and visits the label for the first basic block
520 labels = new Label();
521 labels.status |= Label.PUSHED;
522 visitLabel(labels);
523 }
524 }
525
526 // ------------------------------------------------------------------------
527 // Implementation of the MethodVisitor abstract class
528 // ------------------------------------------------------------------------
529
530 @Override
531 public void visitParameter(String name, int access) {
532 if (methodParameters == null) {
533 methodParameters = new ByteVector();
534 }
535 ++methodParametersCount;
536 methodParameters.putShort((name == null) ? 0 : cw.newUTF8(name))
537 .putShort(access);
538 }
539
540 @Override
541 public AnnotationVisitor visitAnnotationDefault() {
542 if (!ClassReader.ANNOTATIONS) {
543 return null;
544 }
545 annd = new ByteVector();
546 return new AnnotationWriter(cw, false, annd, null, 0);
547 }
548
549 @Override
550 public AnnotationVisitor visitAnnotation(final String desc,
551 final boolean visible) {
552 if (!ClassReader.ANNOTATIONS) {
553 return null;
554 }
555 ByteVector bv = new ByteVector();
556 // write type, and reserve space for values count
557 bv.putShort(cw.newUTF8(desc)).putShort(0);
558 AnnotationWriter aw = new AnnotationWriter(cw, true, bv, bv, 2);
559 if (visible) {
560 aw.next = anns;
561 anns = aw;
562 } else {
563 aw.next = ianns;
564 ianns = aw;
565 }
566 return aw;
567 }
568
569 @Override
570 public AnnotationVisitor visitTypeAnnotation(final int typeRef,
571 final TypePath typePath, final String desc, final boolean visible) {
572 if (!ClassReader.ANNOTATIONS) {
573 return null;
574 }
575 ByteVector bv = new ByteVector();
576 // write target_type and target_info
577 AnnotationWriter.putTarget(typeRef, typePath, bv);
578 // write type, and reserve space for values count
579 bv.putShort(cw.newUTF8(desc)).putShort(0);
580 AnnotationWriter aw = new AnnotationWriter(cw, true, bv, bv,
581 bv.length - 2);
582 if (visible) {
583 aw.next = tanns;
584 tanns = aw;
585 } else {
586 aw.next = itanns;
587 itanns = aw;
588 }
589 return aw;
590 }
591
592 @Override
593 public AnnotationVisitor visitParameterAnnotation(final int parameter,
594 final String desc, final boolean visible) {
595 if (!ClassReader.ANNOTATIONS) {
596 return null;
597 }
598 ByteVector bv = new ByteVector();
599 if ("Ljava/lang/Synthetic;".equals(desc)) {
600 // workaround for a bug in javac with synthetic parameters
601 // see ClassReader.readParameterAnnotations
602 synthetics = Math.max(synthetics, parameter + 1);
603 return new AnnotationWriter(cw, false, bv, null, 0);
604 }
605 // write type, and reserve space for values count
606 bv.putShort(cw.newUTF8(desc)).putShort(0);
607 AnnotationWriter aw = new AnnotationWriter(cw, true, bv, bv, 2);
608 if (visible) {
609 if (panns == null) {
610 panns = new AnnotationWriter[Type.getArgumentTypes(descriptor).length];
611 }
612 aw.next = panns[parameter];
613 panns[parameter] = aw;
614 } else {
615 if (ipanns == null) {
616 ipanns = new AnnotationWriter[Type.getArgumentTypes(descriptor).length];
617 }
618 aw.next = ipanns[parameter];
619 ipanns[parameter] = aw;
620 }
621 return aw;
622 }
623
624 @Override
625 public void visitAttribute(final Attribute attr) {
626 if (attr.isCodeAttribute()) {
627 attr.next = cattrs;
628 cattrs = attr;
629 } else {
630 attr.next = attrs;
631 attrs = attr;
632 }
633 }
634
635 @Override
636 public void visitCode() {
637 }
638
639 @Override
640 public void visitFrame(final int type, final int nLocal,
641 final Object[] local, final int nStack, final Object[] stack) {
642 if (!ClassReader.FRAMES || compute == FRAMES) {
643 return;
644 }
645
646 if (type == Opcodes.F_NEW) {
647 if (previousFrame == null) {
648 visitImplicitFirstFrame();
649 }
650 currentLocals = nLocal;
651 int frameIndex = startFrame(code.length, nLocal, nStack);
652 for (int i = 0; i < nLocal; ++i) {
653 if (local[i] instanceof String) {
654 frame[frameIndex++] = Frame.OBJECT
655 | cw.addType((String) local[i]);
656 } else if (local[i] instanceof Integer) {
657 frame[frameIndex++] = ((Integer) local[i]).intValue();
658 } else {
659 frame[frameIndex++] = Frame.UNINITIALIZED
660 | cw.addUninitializedType("",
661 ((Label) local[i]).position);
662 }
663 }
664 for (int i = 0; i < nStack; ++i) {
665 if (stack[i] instanceof String) {
666 frame[frameIndex++] = Frame.OBJECT
667 | cw.addType((String) stack[i]);
668 } else if (stack[i] instanceof Integer) {
669 frame[frameIndex++] = ((Integer) stack[i]).intValue();
670 } else {
671 frame[frameIndex++] = Frame.UNINITIALIZED
672 | cw.addUninitializedType("",
673 ((Label) stack[i]).position);
674 }
675 }
676 endFrame();
677 } else {
678 int delta;
679 if (stackMap == null) {
680 stackMap = new ByteVector();
681 delta = code.length;
682 } else {
683 delta = code.length - previousFrameOffset - 1;
684 if (delta < 0) {
685 if (type == Opcodes.F_SAME) {
686 return;
687 } else {
688 throw new IllegalStateException();
689 }
690 }
691 }
692
693 switch (type) {
694 case Opcodes.F_FULL:
695 currentLocals = nLocal;
696 stackMap.putByte(FULL_FRAME).putShort(delta).putShort(nLocal);
697 for (int i = 0; i < nLocal; ++i) {
698 writeFrameType(local[i]);
699 }
700 stackMap.putShort(nStack);
701 for (int i = 0; i < nStack; ++i) {
702 writeFrameType(stack[i]);
703 }
704 break;
705 case Opcodes.F_APPEND:
706 currentLocals += nLocal;
707 stackMap.putByte(SAME_FRAME_EXTENDED + nLocal).putShort(delta);
708 for (int i = 0; i < nLocal; ++i) {
709 writeFrameType(local[i]);
710 }
711 break;
712 case Opcodes.F_CHOP:
713 currentLocals -= nLocal;
714 stackMap.putByte(SAME_FRAME_EXTENDED - nLocal).putShort(delta);
715 break;
716 case Opcodes.F_SAME:
717 if (delta < 64) {
718 stackMap.putByte(delta);
719 } else {
720 stackMap.putByte(SAME_FRAME_EXTENDED).putShort(delta);
721 }
722 break;
723 case Opcodes.F_SAME1:
724 if (delta < 64) {
725 stackMap.putByte(SAME_LOCALS_1_STACK_ITEM_FRAME + delta);
726 } else {
727 stackMap.putByte(SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED)
728 .putShort(delta);
729 }
730 writeFrameType(stack[0]);
731 break;
732 }
733
734 previousFrameOffset = code.length;
735 ++frameCount;
736 }
737
738 maxStack = Math.max(maxStack, nStack);
739 maxLocals = Math.max(maxLocals, currentLocals);
740 }
741
742 @Override
743 public void visitInsn(final int opcode) {
744 lastCodeOffset = code.length;
745 // adds the instruction to the bytecode of the method
746 code.putByte(opcode);
747 // update currentBlock
748 // Label currentBlock = this.currentBlock;
749 if (currentBlock != null) {
750 if (compute == FRAMES) {
751 currentBlock.frame.execute(opcode, 0, null, null);
752 } else {
753 // updates current and max stack sizes
754 int size = stackSize + Frame.SIZE[opcode];
755 if (size > maxStackSize) {
756 maxStackSize = size;
757 }
758 stackSize = size;
759 }
760 // if opcode == ATHROW or xRETURN, ends current block (no successor)
761 if ((opcode >= Opcodes.IRETURN && opcode <= Opcodes.RETURN)
762 || opcode == Opcodes.ATHROW) {
763 noSuccessor();
764 }
765 }
766 }
767
768 @Override
769 public void visitIntInsn(final int opcode, final int operand) {
770 lastCodeOffset = code.length;
771 // Label currentBlock = this.currentBlock;
772 if (currentBlock != null) {
773 if (compute == FRAMES) {
774 currentBlock.frame.execute(opcode, operand, null, null);
775 } else if (opcode != Opcodes.NEWARRAY) {
776 // updates current and max stack sizes only for NEWARRAY
777 // (stack size variation = 0 for BIPUSH or SIPUSH)
778 int size = stackSize + 1;
779 if (size > maxStackSize) {
780 maxStackSize = size;
781 }
782 stackSize = size;
783 }
784 }
785 // adds the instruction to the bytecode of the method
786 if (opcode == Opcodes.SIPUSH) {
787 code.put12(opcode, operand);
788 } else { // BIPUSH or NEWARRAY
789 code.put11(opcode, operand);
790 }
791 }
792
793 @Override
794 public void visitVarInsn(final int opcode, final int var) {
795 lastCodeOffset = code.length;
796 // Label currentBlock = this.currentBlock;
797 if (currentBlock != null) {
798 if (compute == FRAMES) {
799 currentBlock.frame.execute(opcode, var, null, null);
800 } else {
801 // updates current and max stack sizes
802 if (opcode == Opcodes.RET) {
803 // no stack change, but end of current block (no successor)
804 currentBlock.status |= Label.RET;
805 // save 'stackSize' here for future use
806 // (see {@link #findSubroutineSuccessors})
807 currentBlock.inputStackTop = stackSize;
808 noSuccessor();
809 } else { // xLOAD or xSTORE
810 int size = stackSize + Frame.SIZE[opcode];
811 if (size > maxStackSize) {
812 maxStackSize = size;
813 }
814 stackSize = size;
815 }
816 }
817 }
818 if (compute != NOTHING) {
819 // updates max locals
820 int n;
821 if (opcode == Opcodes.LLOAD || opcode == Opcodes.DLOAD
822 || opcode == Opcodes.LSTORE || opcode == Opcodes.DSTORE) {
823 n = var + 2;
824 } else {
825 n = var + 1;
826 }
827 if (n > maxLocals) {
828 maxLocals = n;
829 }
830 }
831 // adds the instruction to the bytecode of the method
832 if (var < 4 && opcode != Opcodes.RET) {
833 int opt;
834 if (opcode < Opcodes.ISTORE) {
835 /* ILOAD_0 */
836 opt = 26 + ((opcode - Opcodes.ILOAD) << 2) + var;
837 } else {
838 /* ISTORE_0 */
839 opt = 59 + ((opcode - Opcodes.ISTORE) << 2) + var;
840 }
841 code.putByte(opt);
842 } else if (var >= 256) {
843 code.putByte(196 /* WIDE */).put12(opcode, var);
844 } else {
845 code.put11(opcode, var);
846 }
847 if (opcode >= Opcodes.ISTORE && compute == FRAMES && handlerCount > 0) {
848 visitLabel(new Label());
849 }
850 }
851
852 @Override
853 public void visitTypeInsn(final int opcode, final String type) {
854 lastCodeOffset = code.length;
855 Item i = cw.newClassItem(type);
856 // Label currentBlock = this.currentBlock;
857 if (currentBlock != null) {
858 if (compute == FRAMES) {
859 currentBlock.frame.execute(opcode, code.length, cw, i);
860 } else if (opcode == Opcodes.NEW) {
861 // updates current and max stack sizes only if opcode == NEW
862 // (no stack change for ANEWARRAY, CHECKCAST, INSTANCEOF)
863 int size = stackSize + 1;
864 if (size > maxStackSize) {
865 maxStackSize = size;
866 }
867 stackSize = size;
868 }
869 }
870 // adds the instruction to the bytecode of the method
871 code.put12(opcode, i.index);
872 }
873
874 @Override
875 public void visitFieldInsn(final int opcode, final String owner,
876 final String name, final String desc) {
877 lastCodeOffset = code.length;
878 Item i = cw.newFieldItem(owner, name, desc);
879 // Label currentBlock = this.currentBlock;
880 if (currentBlock != null) {
881 if (compute == FRAMES) {
882 currentBlock.frame.execute(opcode, 0, cw, i);
883 } else {
884 int size;
885 // computes the stack size variation
886 char c = desc.charAt(0);
887 switch (opcode) {
888 case Opcodes.GETSTATIC:
889 size = stackSize + (c == 'D' || c == 'J' ? 2 : 1);
890 break;
891 case Opcodes.PUTSTATIC:
892 size = stackSize + (c == 'D' || c == 'J' ? -2 : -1);
893 break;
894 case Opcodes.GETFIELD:
895 size = stackSize + (c == 'D' || c == 'J' ? 1 : 0);
896 break;
897 // case Constants.PUTFIELD:
898 default:
899 size = stackSize + (c == 'D' || c == 'J' ? -3 : -2);
900 break;
901 }
902 // updates current and max stack sizes
903 if (size > maxStackSize) {
904 maxStackSize = size;
905 }
906 stackSize = size;
907 }
908 }
909 // adds the instruction to the bytecode of the method
910 code.put12(opcode, i.index);
911 }
912
913 @Override
914 public void visitMethodInsn(final int opcode, final String owner,
915 final String name, final String desc, final boolean itf) {
916 lastCodeOffset = code.length;
917 Item i = cw.newMethodItem(owner, name, desc, itf);
918 int argSize = i.intVal;
919 // Label currentBlock = this.currentBlock;
920 if (currentBlock != null) {
921 if (compute == FRAMES) {
922 currentBlock.frame.execute(opcode, 0, cw, i);
923 } else {
924 /*
925 * computes the stack size variation. In order not to recompute
926 * several times this variation for the same Item, we use the
927 * intVal field of this item to store this variation, once it
928 * has been computed. More precisely this intVal field stores
929 * the sizes of the arguments and of the return value
930 * corresponding to desc.
931 */
932 if (argSize == 0) {
933 // the above sizes have not been computed yet,
934 // so we compute them...
935 argSize = Type.getArgumentsAndReturnSizes(desc);
936 // ... and we save them in order
937 // not to recompute them in the future
938 i.intVal = argSize;
939 }
940 int size;
941 if (opcode == Opcodes.INVOKESTATIC) {
942 size = stackSize - (argSize >> 2) + (argSize & 0x03) + 1;
943 } else {
944 size = stackSize - (argSize >> 2) + (argSize & 0x03);
945 }
946 // updates current and max stack sizes
947 if (size > maxStackSize) {
948 maxStackSize = size;
949 }
950 stackSize = size;
951 }
952 }
953 // adds the instruction to the bytecode of the method
954 if (opcode == Opcodes.INVOKEINTERFACE) {
955 if (argSize == 0) {
956 argSize = Type.getArgumentsAndReturnSizes(desc);
957 i.intVal = argSize;
958 }
959 code.put12(Opcodes.INVOKEINTERFACE, i.index).put11(argSize >> 2, 0);
960 } else {
961 code.put12(opcode, i.index);
962 }
963 }
964
965 @Override
966 public void visitInvokeDynamicInsn(final String name, final String desc,
967 final Handle bsm, final Object... bsmArgs) {
968 lastCodeOffset = code.length;
969 Item i = cw.newInvokeDynamicItem(name, desc, bsm, bsmArgs);
970 int argSize = i.intVal;
971 // Label currentBlock = this.currentBlock;
972 if (currentBlock != null) {
973 if (compute == FRAMES) {
974 currentBlock.frame.execute(Opcodes.INVOKEDYNAMIC, 0, cw, i);
975 } else {
976 /*
977 * computes the stack size variation. In order not to recompute
978 * several times this variation for the same Item, we use the
979 * intVal field of this item to store this variation, once it
980 * has been computed. More precisely this intVal field stores
981 * the sizes of the arguments and of the return value
982 * corresponding to desc.
983 */
984 if (argSize == 0) {
985 // the above sizes have not been computed yet,
986 // so we compute them...
987 argSize = Type.getArgumentsAndReturnSizes(desc);
988 // ... and we save them in order
989 // not to recompute them in the future
990 i.intVal = argSize;
991 }
992 int size = stackSize - (argSize >> 2) + (argSize & 0x03) + 1;
993
994 // updates current and max stack sizes
995 if (size > maxStackSize) {
996 maxStackSize = size;
997 }
998 stackSize = size;
999 }
1000 }
1001 // adds the instruction to the bytecode of the method
1002 code.put12(Opcodes.INVOKEDYNAMIC, i.index);
1003 code.putShort(0);
1004 }
1005
1006 @Override
1007 public void visitJumpInsn(final int opcode, final Label label) {
1008 lastCodeOffset = code.length;
1009 Label nextInsn = null;
1010 // Label currentBlock = this.currentBlock;
1011 if (currentBlock != null) {
1012 if (compute == FRAMES) {
1013 currentBlock.frame.execute(opcode, 0, null, null);
1014 // 'label' is the target of a jump instruction
1015 label.getFirst().status |= Label.TARGET;
1016 // adds 'label' as a successor of this basic block
1017 addSuccessor(Edge.NORMAL, label);
1018 if (opcode != Opcodes.GOTO) {
1019 // creates a Label for the next basic block
1020 nextInsn = new Label();
1021 }
1022 } else {
1023 if (opcode == Opcodes.JSR) {
1024 if ((label.status & Label.SUBROUTINE) == 0) {
1025 label.status |= Label.SUBROUTINE;
1026 ++subroutines;
1027 }
1028 currentBlock.status |= Label.JSR;
1029 addSuccessor(stackSize + 1, label);
1030 // creates a Label for the next basic block
1031 nextInsn = new Label();
1032 /*
1033 * note that, by construction in this method, a JSR block
1034 * has at least two successors in the control flow graph:
1035 * the first one leads the next instruction after the JSR,
1036 * while the second one leads to the JSR target.
1037 */
1038 } else {
1039 // updates current stack size (max stack size unchanged
1040 // because stack size variation always negative in this
1041 // case)
1042 stackSize += Frame.SIZE[opcode];
1043 addSuccessor(stackSize, label);
1044 }
1045 }
1046 }
1047 // adds the instruction to the bytecode of the method
1048 if ((label.status & Label.RESOLVED) != 0
1049 && label.position - code.length < Short.MIN_VALUE) {
1050 /*
1051 * case of a backward jump with an offset < -32768. In this case we
1052 * automatically replace GOTO with GOTO_W, JSR with JSR_W and IFxxx
1053 * <l> with IFNOTxxx <l'> GOTO_W <l>, where IFNOTxxx is the
1054 * "opposite" opcode of IFxxx (i.e., IFNE for IFEQ) and where <l'>
1055 * designates the instruction just after the GOTO_W.
1056 */
1057 if (opcode == Opcodes.GOTO) {
1058 code.putByte(200); // GOTO_W
1059 } else if (opcode == Opcodes.JSR) {
1060 code.putByte(201); // JSR_W
1061 } else {
1062 // if the IF instruction is transformed into IFNOT GOTO_W the
1063 // next instruction becomes the target of the IFNOT instruction
1064 if (nextInsn != null) {
1065 nextInsn.status |= Label.TARGET;
1066 }
1067 code.putByte(opcode <= 166 ? ((opcode + 1) ^ 1) - 1
1068 : opcode ^ 1);
1069 code.putShort(8); // jump offset
1070 code.putByte(200); // GOTO_W
1071 }
1072 label.put(this, code, code.length - 1, true);
1073 } else {
1074 /*
1075 * case of a backward jump with an offset >= -32768, or of a forward
1076 * jump with, of course, an unknown offset. In these cases we store
1077 * the offset in 2 bytes (which will be increased in
1078 * resizeInstructions, if needed).
1079 */
1080 code.putByte(opcode);
1081 label.put(this, code, code.length - 1, false);
1082 }
1083 if (currentBlock != null) {
1084 if (nextInsn != null) {
1085 // if the jump instruction is not a GOTO, the next instruction
1086 // is also a successor of this instruction. Calling visitLabel
1087 // adds the label of this next instruction as a successor of the
1088 // current block, and starts a new basic block
1089 visitLabel(nextInsn);
1090 }
1091 if (opcode == Opcodes.GOTO) {
1092 noSuccessor();
1093 }
1094 }
1095 }
1096
1097 @Override
1098 public void visitLabel(final Label label) {
1099 // resolves previous forward references to label, if any
1100 resize |= label.resolve(this, code.length, code.data);
1101 // updates currentBlock
1102 if ((label.status & Label.DEBUG) != 0) {
1103 return;
1104 }
1105 if (compute == FRAMES) {
1106 if (currentBlock != null) {
1107 if (label.position == currentBlock.position) {
1108 // successive labels, do not start a new basic block
1109 currentBlock.status |= (label.status & Label.TARGET);
1110 label.frame = currentBlock.frame;
1111 return;
1112 }
1113 // ends current block (with one new successor)
1114 addSuccessor(Edge.NORMAL, label);
1115 }
1116 // begins a new current block
1117 currentBlock = label;
1118 if (label.frame == null) {
1119 label.frame = new Frame();
1120 label.frame.owner = label;
1121 }
1122 // updates the basic block list
1123 if (previousBlock != null) {
1124 if (label.position == previousBlock.position) {
1125 previousBlock.status |= (label.status & Label.TARGET);
1126 label.frame = previousBlock.frame;
1127 currentBlock = previousBlock;
1128 return;
1129 }
1130 previousBlock.successor = label;
1131 }
1132 previousBlock = label;
1133 } else if (compute == MAXS) {
1134 if (currentBlock != null) {
1135 // ends current block (with one new successor)
1136 currentBlock.outputStackMax = maxStackSize;
1137 addSuccessor(stackSize, label);
1138 }
1139 // begins a new current block
1140 currentBlock = label;
1141 // resets the relative current and max stack sizes
1142 stackSize = 0;
1143 maxStackSize = 0;
1144 // updates the basic block list
1145 if (previousBlock != null) {
1146 previousBlock.successor = label;
1147 }
1148 previousBlock = label;
1149 }
1150 }
1151
1152 @Override
1153 public void visitLdcInsn(final Object cst) {
1154 lastCodeOffset = code.length;
1155 Item i = cw.newConstItem(cst);
1156 // Label currentBlock = this.currentBlock;
1157 if (currentBlock != null) {
1158 if (compute == FRAMES) {
1159 currentBlock.frame.execute(Opcodes.LDC, 0, cw, i);
1160 } else {
1161 int size;
1162 // computes the stack size variation
1163 if (i.type == ClassWriter.LONG || i.type == ClassWriter.DOUBLE) {
1164 size = stackSize + 2;
1165 } else {
1166 size = stackSize + 1;
1167 }
1168 // updates current and max stack sizes
1169 if (size > maxStackSize) {
1170 maxStackSize = size;
1171 }
1172 stackSize = size;
1173 }
1174 }
1175 // adds the instruction to the bytecode of the method
1176 int index = i.index;
1177 if (i.type == ClassWriter.LONG || i.type == ClassWriter.DOUBLE) {
1178 code.put12(20 /* LDC2_W */, index);
1179 } else if (index >= 256) {
1180 code.put12(19 /* LDC_W */, index);
1181 } else {
1182 code.put11(Opcodes.LDC, index);
1183 }
1184 }
1185
1186 @Override
1187 public void visitIincInsn(final int var, final int increment) {
1188 lastCodeOffset = code.length;
1189 if (currentBlock != null) {
1190 if (compute == FRAMES) {
1191 currentBlock.frame.execute(Opcodes.IINC, var, null, null);
1192 }
1193 }
1194 if (compute != NOTHING) {
1195 // updates max locals
1196 int n = var + 1;
1197 if (n > maxLocals) {
1198 maxLocals = n;
1199 }
1200 }
1201 // adds the instruction to the bytecode of the method
1202 if ((var > 255) || (increment > 127) || (increment < -128)) {
1203 code.putByte(196 /* WIDE */).put12(Opcodes.IINC, var)
1204 .putShort(increment);
1205 } else {
1206 code.putByte(Opcodes.IINC).put11(var, increment);
1207 }
1208 }
1209
1210 @Override
1211 public void visitTableSwitchInsn(final int min, final int max,
1212 final Label dflt, final Label... labels) {
1213 lastCodeOffset = code.length;
1214 // adds the instruction to the bytecode of the method
1215 int source = code.length;
1216 code.putByte(Opcodes.TABLESWITCH);
1217 code.putByteArray(null, 0, (4 - code.length % 4) % 4);
1218 dflt.put(this, code, source, true);
1219 code.putInt(min).putInt(max);
1220 for (int i = 0; i < labels.length; ++i) {
1221 labels[i].put(this, code, source, true);
1222 }
1223 // updates currentBlock
1224 visitSwitchInsn(dflt, labels);
1225 }
1226
1227 @Override
1228 public void visitLookupSwitchInsn(final Label dflt, final int[] keys,
1229 final Label[] labels) {
1230 lastCodeOffset = code.length;
1231 // adds the instruction to the bytecode of the method
1232 int source = code.length;
1233 code.putByte(Opcodes.LOOKUPSWITCH);
1234 code.putByteArray(null, 0, (4 - code.length % 4) % 4);
1235 dflt.put(this, code, source, true);
1236 code.putInt(labels.length);
1237 for (int i = 0; i < labels.length; ++i) {
1238 code.putInt(keys[i]);
1239 labels[i].put(this, code, source, true);
1240 }
1241 // updates currentBlock
1242 visitSwitchInsn(dflt, labels);
1243 }
1244
1245 private void visitSwitchInsn(final Label dflt, final Label[] labels) {
1246 // Label currentBlock = this.currentBlock;
1247 if (currentBlock != null) {
1248 if (compute == FRAMES) {
1249 currentBlock.frame.execute(Opcodes.LOOKUPSWITCH, 0, null, null);
1250 // adds current block successors
1251 addSuccessor(Edge.NORMAL, dflt);
1252 dflt.getFirst().status |= Label.TARGET;
1253 for (int i = 0; i < labels.length; ++i) {
1254 addSuccessor(Edge.NORMAL, labels[i]);
1255 labels[i].getFirst().status |= Label.TARGET;
1256 }
1257 } else {
1258 // updates current stack size (max stack size unchanged)
1259 --stackSize;
1260 // adds current block successors
1261 addSuccessor(stackSize, dflt);
1262 for (int i = 0; i < labels.length; ++i) {
1263 addSuccessor(stackSize, labels[i]);
1264 }
1265 }
1266 // ends current block
1267 noSuccessor();
1268 }
1269 }
1270
1271 @Override
1272 public void visitMultiANewArrayInsn(final String desc, final int dims) {
1273 lastCodeOffset = code.length;
1274 Item i = cw.newClassItem(desc);
1275 // Label currentBlock = this.currentBlock;
1276 if (currentBlock != null) {
1277 if (compute == FRAMES) {
1278 currentBlock.frame.execute(Opcodes.MULTIANEWARRAY, dims, cw, i);
1279 } else {
1280 // updates current stack size (max stack size unchanged because
1281 // stack size variation always negative or null)
1282 stackSize += 1 - dims;
1283 }
1284 }
1285 // adds the instruction to the bytecode of the method
1286 code.put12(Opcodes.MULTIANEWARRAY, i.index).putByte(dims);
1287 }
1288
1289 @Override
1290 public AnnotationVisitor visitInsnAnnotation(int typeRef,
1291 TypePath typePath, String desc, boolean visible) {
1292 if (!ClassReader.ANNOTATIONS) {
1293 return null;
1294 }
1295 ByteVector bv = new ByteVector();
1296 // write target_type and target_info
1297 typeRef = (typeRef & 0xFF0000FF) | (lastCodeOffset << 8);
1298 AnnotationWriter.putTarget(typeRef, typePath, bv);
1299 // write type, and reserve space for values count
1300 bv.putShort(cw.newUTF8(desc)).putShort(0);
1301 AnnotationWriter aw = new AnnotationWriter(cw, true, bv, bv,
1302 bv.length - 2);
1303 if (visible) {
1304 aw.next = ctanns;
1305 ctanns = aw;
1306 } else {
1307 aw.next = ictanns;
1308 ictanns = aw;
1309 }
1310 return aw;
1311 }
1312
1313 @Override
1314 public void visitTryCatchBlock(final Label start, final Label end,
1315 final Label handler, final String type) {
1316 ++handlerCount;
1317 Handler h = new Handler();
1318 h.start = start;
1319 h.end = end;
1320 h.handler = handler;
1321 h.desc = type;
1322 h.type = type != null ? cw.newClass(type) : 0;
1323 if (lastHandler == null) {
1324 firstHandler = h;
1325 } else {
1326 lastHandler.next = h;
1327 }
1328 lastHandler = h;
1329 }
1330
1331 @Override
1332 public AnnotationVisitor visitTryCatchAnnotation(int typeRef,
1333 TypePath typePath, String desc, boolean visible) {
1334 if (!ClassReader.ANNOTATIONS) {
1335 return null;
1336 }
1337 ByteVector bv = new ByteVector();
1338 // write target_type and target_info
1339 AnnotationWriter.putTarget(typeRef, typePath, bv);
1340 // write type, and reserve space for values count
1341 bv.putShort(cw.newUTF8(desc)).putShort(0);
1342 AnnotationWriter aw = new AnnotationWriter(cw, true, bv, bv,
1343 bv.length - 2);
1344 if (visible) {
1345 aw.next = ctanns;
1346 ctanns = aw;
1347 } else {
1348 aw.next = ictanns;
1349 ictanns = aw;
1350 }
1351 return aw;
1352 }
1353
1354 @Override
1355 public void visitLocalVariable(final String name, final String desc,
1356 final String signature, final Label start, final Label end,
1357 final int index) {
1358 if (signature != null) {
1359 if (localVarType == null) {
1360 localVarType = new ByteVector();
1361 }
1362 ++localVarTypeCount;
1363 localVarType.putShort(start.position)
1364 .putShort(end.position - start.position)
1365 .putShort(cw.newUTF8(name)).putShort(cw.newUTF8(signature))
1366 .putShort(index);
1367 }
1368 if (localVar == null) {
1369 localVar = new ByteVector();
1370 }
1371 ++localVarCount;
1372 localVar.putShort(start.position)
1373 .putShort(end.position - start.position)
1374 .putShort(cw.newUTF8(name)).putShort(cw.newUTF8(desc))
1375 .putShort(index);
1376 if (compute != NOTHING) {
1377 // updates max locals
1378 char c = desc.charAt(0);
1379 int n = index + (c == 'J' || c == 'D' ? 2 : 1);
1380 if (n > maxLocals) {
1381 maxLocals = n;
1382 }
1383 }
1384 }
1385
1386 @Override
1387 public AnnotationVisitor visitLocalVariableAnnotation(int typeRef,
1388 TypePath typePath, Label[] start, Label[] end, int[] index,
1389 String desc, boolean visible) {
1390 if (!ClassReader.ANNOTATIONS) {
1391 return null;
1392 }
1393 ByteVector bv = new ByteVector();
1394 // write target_type and target_info
1395 bv.putByte(typeRef >>> 24).putShort(start.length);
1396 for (int i = 0; i < start.length; ++i) {
1397 bv.putShort(start[i].position)
1398 .putShort(end[i].position - start[i].position)
1399 .putShort(index[i]);
1400 }
1401 if (typePath == null) {
1402 bv.putByte(0);
1403 } else {
1404 int length = typePath.b[typePath.offset] * 2 + 1;
1405 bv.putByteArray(typePath.b, typePath.offset, length);
1406 }
1407 // write type, and reserve space for values count
1408 bv.putShort(cw.newUTF8(desc)).putShort(0);
1409 AnnotationWriter aw = new AnnotationWriter(cw, true, bv, bv,
1410 bv.length - 2);
1411 if (visible) {
1412 aw.next = ctanns;
1413 ctanns = aw;
1414 } else {
1415 aw.next = ictanns;
1416 ictanns = aw;
1417 }
1418 return aw;
1419 }
1420
1421 @Override
1422 public void visitLineNumber(final int line, final Label start) {
1423 if (lineNumber == null) {
1424 lineNumber = new ByteVector();
1425 }
1426 ++lineNumberCount;
1427 lineNumber.putShort(start.position);
1428 lineNumber.putShort(line);
1429 }
1430
1431 @Override
1432 public void visitMaxs(final int maxStack, final int maxLocals) {
1433 if (resize) {
1434 // replaces the temporary jump opcodes introduced by Label.resolve.
1435 if (ClassReader.RESIZE) {
1436 resizeInstructions();
1437 } else {
1438 throw new RuntimeException("Method code too large!");
1439 }
1440 }
1441 if (ClassReader.FRAMES && compute == FRAMES) {
1442 // completes the control flow graph with exception handler blocks
1443 Handler handler = firstHandler;
1444 while (handler != null) {
1445 Label l = handler.start.getFirst();
1446 Label h = handler.handler.getFirst();
1447 Label e = handler.end.getFirst();
1448 // computes the kind of the edges to 'h'
1449 String t = handler.desc == null ? "java/lang/Throwable"
1450 : handler.desc;
1451 int kind = Frame.OBJECT | cw.addType(t);
1452 // h is an exception handler
1453 h.status |= Label.TARGET;
1454 // adds 'h' as a successor of labels between 'start' and 'end'
1455 while (l != e) {
1456 // creates an edge to 'h'
1457 Edge b = new Edge();
1458 b.info = kind;
1459 b.successor = h;
1460 // adds it to the successors of 'l'
1461 b.next = l.successors;
1462 l.successors = b;
1463 // goes to the next label
1464 l = l.successor;
1465 }
1466 handler = handler.next;
1467 }
1468
1469 // creates and visits the first (implicit) frame
1470 Frame f = labels.frame;
1471 Type[] args = Type.getArgumentTypes(descriptor);
1472 f.initInputFrame(cw, access, args, this.maxLocals);
1473 visitFrame(f);
1474
1475 /*
1476 * fix point algorithm: mark the first basic block as 'changed'
1477 * (i.e. put it in the 'changed' list) and, while there are changed
1478 * basic blocks, choose one, mark it as unchanged, and update its
1479 * successors (which can be changed in the process).
1480 */
1481 int max = 0;
1482 Label changed = labels;
1483 while (changed != null) {
1484 // removes a basic block from the list of changed basic blocks
1485 Label l = changed;
1486 changed = changed.next;
1487 l.next = null;
1488 f = l.frame;
1489 // a reachable jump target must be stored in the stack map
1490 if ((l.status & Label.TARGET) != 0) {
1491 l.status |= Label.STORE;
1492 }
1493 // all visited labels are reachable, by definition
1494 l.status |= Label.REACHABLE;
1495 // updates the (absolute) maximum stack size
1496 int blockMax = f.inputStack.length + l.outputStackMax;
1497 if (blockMax > max) {
1498 max = blockMax;
1499 }
1500 // updates the successors of the current basic block
1501 Edge e = l.successors;
1502 while (e != null) {
1503 Label n = e.successor.getFirst();
1504 boolean change = f.merge(cw, n.frame, e.info);
1505 if (change && n.next == null) {
1506 // if n has changed and is not already in the 'changed'
1507 // list, adds it to this list
1508 n.next = changed;
1509 changed = n;
1510 }
1511 e = e.next;
1512 }
1513 }
1514
1515 // visits all the frames that must be stored in the stack map
1516 Label l = labels;
1517 while (l != null) {
1518 f = l.frame;
1519 if ((l.status & Label.STORE) != 0) {
1520 visitFrame(f);
1521 }
1522 if ((l.status & Label.REACHABLE) == 0) {
1523 // finds start and end of dead basic block
1524 Label k = l.successor;
1525 int start = l.position;
1526 int end = (k == null ? code.length : k.position) - 1;
1527 // if non empty basic block
1528 if (end >= start) {
1529 max = Math.max(max, 1);
1530 // replaces instructions with NOP ... NOP ATHROW
1531 for (int i = start; i < end; ++i) {
1532 code.data[i] = Opcodes.NOP;
1533 }
1534 code.data[end] = (byte) Opcodes.ATHROW;
1535 // emits a frame for this unreachable block
1536 int frameIndex = startFrame(start, 0, 1);
1537 frame[frameIndex] = Frame.OBJECT
1538 | cw.addType("java/lang/Throwable");
1539 endFrame();
1540 // removes the start-end range from the exception
1541 // handlers
1542 firstHandler = Handler.remove(firstHandler, l, k);
1543 }
1544 }
1545 l = l.successor;
1546 }
1547
1548 handler = firstHandler;
1549 handlerCount = 0;
1550 while (handler != null) {
1551 handlerCount += 1;
1552 handler = handler.next;
1553 }
1554
1555 this.maxStack = max;
1556 } else if (compute == MAXS) {
1557 // completes the control flow graph with exception handler blocks
1558 Handler handler = firstHandler;
1559 while (handler != null) {
1560 Label l = handler.start;
1561 Label h = handler.handler;
1562 Label e = handler.end;
1563 // adds 'h' as a successor of labels between 'start' and 'end'
1564 while (l != e) {
1565 // creates an edge to 'h'
1566 Edge b = new Edge();
1567 b.info = Edge.EXCEPTION;
1568 b.successor = h;
1569 // adds it to the successors of 'l'
1570 if ((l.status & Label.JSR) == 0) {
1571 b.next = l.successors;
1572 l.successors = b;
1573 } else {
1574 // if l is a JSR block, adds b after the first two edges
1575 // to preserve the hypothesis about JSR block successors
1576 // order (see {@link #visitJumpInsn})
1577 b.next = l.successors.next.next;
1578 l.successors.next.next = b;
1579 }
1580 // goes to the next label
1581 l = l.successor;
1582 }
1583 handler = handler.next;
1584 }
1585
1586 if (subroutines > 0) {
1587 // completes the control flow graph with the RET successors
1588 /*
1589 * first step: finds the subroutines. This step determines, for
1590 * each basic block, to which subroutine(s) it belongs.
1591 */
1592 // finds the basic blocks that belong to the "main" subroutine
1593 int id = 0;
1594 labels.visitSubroutine(null, 1, subroutines);
1595 // finds the basic blocks that belong to the real subroutines
1596 Label l = labels;
1597 while (l != null) {
1598 if ((l.status & Label.JSR) != 0) {
1599 // the subroutine is defined by l's TARGET, not by l
1600 Label subroutine = l.successors.next.successor;
1601 // if this subroutine has not been visited yet...
1602 if ((subroutine.status & Label.VISITED) == 0) {
1603 // ...assigns it a new id and finds its basic blocks
1604 id += 1;
1605 subroutine.visitSubroutine(null, (id / 32L) << 32
1606 | (1L << (id % 32)), subroutines);
1607 }
1608 }
1609 l = l.successor;
1610 }
1611 // second step: finds the successors of RET blocks
1612 l = labels;
1613 while (l != null) {
1614 if ((l.status & Label.JSR) != 0) {
1615 Label L = labels;
1616 while (L != null) {
1617 L.status &= ~Label.VISITED2;
1618 L = L.successor;
1619 }
1620 // the subroutine is defined by l's TARGET, not by l
1621 Label subroutine = l.successors.next.successor;
1622 subroutine.visitSubroutine(l, 0, subroutines);
1623 }
1624 l = l.successor;
1625 }
1626 }
1627
1628 /*
1629 * control flow analysis algorithm: while the block stack is not
1630 * empty, pop a block from this stack, update the max stack size,
1631 * compute the true (non relative) begin stack size of the
1632 * successors of this block, and push these successors onto the
1633 * stack (unless they have already been pushed onto the stack).
1634 * Note: by hypothesis, the {@link Label#inputStackTop} of the
1635 * blocks in the block stack are the true (non relative) beginning
1636 * stack sizes of these blocks.
1637 */
1638 int max = 0;
1639 Label stack = labels;
1640 while (stack != null) {
1641 // pops a block from the stack
1642 Label l = stack;
1643 stack = stack.next;
1644 // computes the true (non relative) max stack size of this block
1645 int start = l.inputStackTop;
1646 int blockMax = start + l.outputStackMax;
1647 // updates the global max stack size
1648 if (blockMax > max) {
1649 max = blockMax;
1650 }
1651 // analyzes the successors of the block
1652 Edge b = l.successors;
1653 if ((l.status & Label.JSR) != 0) {
1654 // ignores the first edge of JSR blocks (virtual successor)
1655 b = b.next;
1656 }
1657 while (b != null) {
1658 l = b.successor;
1659 // if this successor has not already been pushed...
1660 if ((l.status & Label.PUSHED) == 0) {
1661 // computes its true beginning stack size...
1662 l.inputStackTop = b.info == Edge.EXCEPTION ? 1 : start
1663 + b.info;
1664 // ...and pushes it onto the stack
1665 l.status |= Label.PUSHED;
1666 l.next = stack;
1667 stack = l;
1668 }
1669 b = b.next;
1670 }
1671 }
1672 this.maxStack = Math.max(maxStack, max);
1673 } else {
1674 this.maxStack = maxStack;
1675 this.maxLocals = maxLocals;
1676 }
1677 }
1678
1679 @Override
1680 public void visitEnd() {
1681 }
1682
1683 // ------------------------------------------------------------------------
1684 // Utility methods: control flow analysis algorithm
1685 // ------------------------------------------------------------------------
1686
1687 /**
1688 * Adds a successor to the {@link #currentBlock currentBlock} block.
1689 *
1690 * @param info
1691 * information about the control flow edge to be added.
1692 * @param successor
1693 * the successor block to be added to the current block.
1694 */
1695 private void addSuccessor(final int info, final Label successor) {
1696 // creates and initializes an Edge object...
1697 Edge b = new Edge();
1698 b.info = info;
1699 b.successor = successor;
1700 // ...and adds it to the successor list of the currentBlock block
1701 b.next = currentBlock.successors;
1702 currentBlock.successors = b;
1703 }
1704
1705 /**
1706 * Ends the current basic block. This method must be used in the case where
1707 * the current basic block does not have any successor.
1708 */
1709 private void noSuccessor() {
1710 if (compute == FRAMES) {
1711 Label l = new Label();
1712 l.frame = new Frame();
1713 l.frame.owner = l;
1714 l.resolve(this, code.length, code.data);
1715 previousBlock.successor = l;
1716 previousBlock = l;
1717 } else {
1718 currentBlock.outputStackMax = maxStackSize;
1719 }
1720 currentBlock = null;
1721 }
1722
1723 // ------------------------------------------------------------------------
1724 // Utility methods: stack map frames
1725 // ------------------------------------------------------------------------
1726
1727 /**
1728 * Visits a frame that has been computed from scratch.
1729 *
1730 * @param f
1731 * the frame that must be visited.
1732 */
1733 private void visitFrame(final Frame f) {
1734 int i, t;
1735 int nTop = 0;
1736 int nLocal = 0;
1737 int nStack = 0;
1738 int[] locals = f.inputLocals;
1739 int[] stacks = f.inputStack;
1740 // computes the number of locals (ignores TOP types that are just after
1741 // a LONG or a DOUBLE, and all trailing TOP types)
1742 for (i = 0; i < locals.length; ++i) {
1743 t = locals[i];
1744 if (t == Frame.TOP) {
1745 ++nTop;
1746 } else {
1747 nLocal += nTop + 1;
1748 nTop = 0;
1749 }
1750 if (t == Frame.LONG || t == Frame.DOUBLE) {
1751 ++i;
1752 }
1753 }
1754 // computes the stack size (ignores TOP types that are just after
1755 // a LONG or a DOUBLE)
1756 for (i = 0; i < stacks.length; ++i) {
1757 t = stacks[i];
1758 ++nStack;
1759 if (t == Frame.LONG || t == Frame.DOUBLE) {
1760 ++i;
1761 }
1762 }
1763 // visits the frame and its content
1764 int frameIndex = startFrame(f.owner.position, nLocal, nStack);
1765 for (i = 0; nLocal > 0; ++i, --nLocal) {
1766 t = locals[i];
1767 frame[frameIndex++] = t;
1768 if (t == Frame.LONG || t == Frame.DOUBLE) {
1769 ++i;
1770 }
1771 }
1772 for (i = 0; i < stacks.length; ++i) {
1773 t = stacks[i];
1774 frame[frameIndex++] = t;
1775 if (t == Frame.LONG || t == Frame.DOUBLE) {
1776 ++i;
1777 }
1778 }
1779 endFrame();
1780 }
1781
1782 /**
1783 * Visit the implicit first frame of this method.
1784 */
1785 private void visitImplicitFirstFrame() {
1786 // There can be at most descriptor.length() + 1 locals
1787 int frameIndex = startFrame(0, descriptor.length() + 1, 0);
1788 if ((access & Opcodes.ACC_STATIC) == 0) {
1789 if ((access & ACC_CONSTRUCTOR) == 0) {
1790 frame[frameIndex++] = Frame.OBJECT | cw.addType(cw.thisName);
1791 } else {
1792 frame[frameIndex++] = 6; // Opcodes.UNINITIALIZED_THIS;
1793 }
1794 }
1795 int i = 1;
1796 loop: while (true) {
1797 int j = i;
1798 switch (descriptor.charAt(i++)) {
1799 case 'Z':
1800 case 'C':
1801 case 'B':
1802 case 'S':
1803 case 'I':
1804 frame[frameIndex++] = 1; // Opcodes.INTEGER;
1805 break;
1806 case 'F':
1807 frame[frameIndex++] = 2; // Opcodes.FLOAT;
1808 break;
1809 case 'J':
1810 frame[frameIndex++] = 4; // Opcodes.LONG;
1811 break;
1812 case 'D':
1813 frame[frameIndex++] = 3; // Opcodes.DOUBLE;
1814 break;
1815 case '[':
1816 while (descriptor.charAt(i) == '[') {
1817 ++i;
1818 }
1819 if (descriptor.charAt(i) == 'L') {
1820 ++i;
1821 while (descriptor.charAt(i) != ';') {
1822 ++i;
1823 }
1824 }
1825 frame[frameIndex++] = Frame.OBJECT
1826 | cw.addType(descriptor.substring(j, ++i));
1827 break;
1828 case 'L':
1829 while (descriptor.charAt(i) != ';') {
1830 ++i;
1831 }
1832 frame[frameIndex++] = Frame.OBJECT
1833 | cw.addType(descriptor.substring(j + 1, i++));
1834 break;
1835 default:
1836 break loop;
1837 }
1838 }
1839 frame[1] = frameIndex - 3;
1840 endFrame();
1841 }
1842
1843 /**
1844 * Starts the visit of a stack map frame.
1845 *
1846 * @param offset
1847 * the offset of the instruction to which the frame corresponds.
1848 * @param nLocal
1849 * the number of local variables in the frame.
1850 * @param nStack
1851 * the number of stack elements in the frame.
1852 * @return the index of the next element to be written in this frame.
1853 */
1854 private int startFrame(final int offset, final int nLocal, final int nStack) {
1855 int n = 3 + nLocal + nStack;
1856 if (frame == null || frame.length < n) {
1857 frame = new int[n];
1858 }
1859 frame[0] = offset;
1860 frame[1] = nLocal;
1861 frame[2] = nStack;
1862 return 3;
1863 }
1864
1865 /**
1866 * Checks if the visit of the current frame {@link #frame} is finished, and
1867 * if yes, write it in the StackMapTable attribute.
1868 */
1869 private void endFrame() {
1870 if (previousFrame != null) { // do not write the first frame
1871 if (stackMap == null) {
1872 stackMap = new ByteVector();
1873 }
1874 writeFrame();
1875 ++frameCount;
1876 }
1877 previousFrame = frame;
1878 frame = null;
1879 }
1880
1881 /**
1882 * Compress and writes the current frame {@link #frame} in the StackMapTable
1883 * attribute.
1884 */
1885 private void writeFrame() {
1886 int clocalsSize = frame[1];
1887 int cstackSize = frame[2];
1888 if ((cw.version & 0xFFFF) < Opcodes.V1_6) {
1889 stackMap.putShort(frame[0]).putShort(clocalsSize);
1890 writeFrameTypes(3, 3 + clocalsSize);
1891 stackMap.putShort(cstackSize);
1892 writeFrameTypes(3 + clocalsSize, 3 + clocalsSize + cstackSize);
1893 return;
1894 }
1895 int localsSize = previousFrame[1];
1896 int type = FULL_FRAME;
1897 int k = 0;
1898 int delta;
1899 if (frameCount == 0) {
1900 delta = frame[0];
1901 } else {
1902 delta = frame[0] - previousFrame[0] - 1;
1903 }
1904 if (cstackSize == 0) {
1905 k = clocalsSize - localsSize;
1906 switch (k) {
1907 case -3:
1908 case -2:
1909 case -1:
1910 type = CHOP_FRAME;
1911 localsSize = clocalsSize;
1912 break;
1913 case 0:
1914 type = delta < 64 ? SAME_FRAME : SAME_FRAME_EXTENDED;
1915 break;
1916 case 1:
1917 case 2:
1918 case 3:
1919 type = APPEND_FRAME;
1920 break;
1921 }
1922 } else if (clocalsSize == localsSize && cstackSize == 1) {
1923 type = delta < 63 ? SAME_LOCALS_1_STACK_ITEM_FRAME
1924 : SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED;
1925 }
1926 if (type != FULL_FRAME) {
1927 // verify if locals are the same
1928 int l = 3;
1929 for (int j = 0; j < localsSize; j++) {
1930 if (frame[l] != previousFrame[l]) {
1931 type = FULL_FRAME;
1932 break;
1933 }
1934 l++;
1935 }
1936 }
1937 switch (type) {
1938 case SAME_FRAME:
1939 stackMap.putByte(delta);
1940 break;
1941 case SAME_LOCALS_1_STACK_ITEM_FRAME:
1942 stackMap.putByte(SAME_LOCALS_1_STACK_ITEM_FRAME + delta);
1943 writeFrameTypes(3 + clocalsSize, 4 + clocalsSize);
1944 break;
1945 case SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED:
1946 stackMap.putByte(SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED).putShort(
1947 delta);
1948 writeFrameTypes(3 + clocalsSize, 4 + clocalsSize);
1949 break;
1950 case SAME_FRAME_EXTENDED:
1951 stackMap.putByte(SAME_FRAME_EXTENDED).putShort(delta);
1952 break;
1953 case CHOP_FRAME:
1954 stackMap.putByte(SAME_FRAME_EXTENDED + k).putShort(delta);
1955 break;
1956 case APPEND_FRAME:
1957 stackMap.putByte(SAME_FRAME_EXTENDED + k).putShort(delta);
1958 writeFrameTypes(3 + localsSize, 3 + clocalsSize);
1959 break;
1960 // case FULL_FRAME:
1961 default:
1962 stackMap.putByte(FULL_FRAME).putShort(delta).putShort(clocalsSize);
1963 writeFrameTypes(3, 3 + clocalsSize);
1964 stackMap.putShort(cstackSize);
1965 writeFrameTypes(3 + clocalsSize, 3 + clocalsSize + cstackSize);
1966 }
1967 }
1968
1969 /**
1970 * Writes some types of the current frame {@link #frame} into the
1971 * StackMapTableAttribute. This method converts types from the format used
1972 * in {@link Label} to the format used in StackMapTable attributes. In
1973 * particular, it converts type table indexes to constant pool indexes.
1974 *
1975 * @param start
1976 * index of the first type in {@link #frame} to write.
1977 * @param end
1978 * index of last type in {@link #frame} to write (exclusive).
1979 */
1980 private void writeFrameTypes(final int start, final int end) {
1981 for (int i = start; i < end; ++i) {
1982 int t = frame[i];
1983 int d = t & Frame.DIM;
1984 if (d == 0) {
1985 int v = t & Frame.BASE_VALUE;
1986 switch (t & Frame.BASE_KIND) {
1987 case Frame.OBJECT:
1988 stackMap.putByte(7).putShort(
1989 cw.newClass(cw.typeTable[v].strVal1));
1990 break;
1991 case Frame.UNINITIALIZED:
1992 stackMap.putByte(8).putShort(cw.typeTable[v].intVal);
1993 break;
1994 default:
1995 stackMap.putByte(v);
1996 }
1997 } else {
1998 StringBuilder sb = new StringBuilder();
1999 d >>= 28;
2000 while (d-- > 0) {
2001 sb.append('[');
2002 }
2003 if ((t & Frame.BASE_KIND) == Frame.OBJECT) {
2004 sb.append('L');
2005 sb.append(cw.typeTable[t & Frame.BASE_VALUE].strVal1);
2006 sb.append(';');
2007 } else {
2008 switch (t & 0xF) {
2009 case 1:
2010 sb.append('I');
2011 break;
2012 case 2:
2013 sb.append('F');
2014 break;
2015 case 3:
2016 sb.append('D');
2017 break;
2018 case 9:
2019 sb.append('Z');
2020 break;
2021 case 10:
2022 sb.append('B');
2023 break;
2024 case 11:
2025 sb.append('C');
2026 break;
2027 case 12:
2028 sb.append('S');
2029 break;
2030 default:
2031 sb.append('J');
2032 }
2033 }
2034 stackMap.putByte(7).putShort(cw.newClass(sb.toString()));
2035 }
2036 }
2037 }
2038
2039 private void writeFrameType(final Object type) {
2040 if (type instanceof String) {
2041 stackMap.putByte(7).putShort(cw.newClass((String) type));
2042 } else if (type instanceof Integer) {
2043 stackMap.putByte(((Integer) type).intValue());
2044 } else {
2045 stackMap.putByte(8).putShort(((Label) type).position);
2046 }
2047 }
2048
2049 // ------------------------------------------------------------------------
2050 // Utility methods: dump bytecode array
2051 // ------------------------------------------------------------------------
2052
2053 /**
2054 * Returns the size of the bytecode of this method.
2055 *
2056 * @return the size of the bytecode of this method.
2057 */
2058 final int getSize() {
2059 if (classReaderOffset != 0) {
2060 return 6 + classReaderLength;
2061 }
2062 int size = 8;
2063 if (code.length > 0) {
2064 if (code.length > 65535) {
2065 throw new RuntimeException("Method code too large!");
2066 }
2067 cw.newUTF8("Code");
2068 size += 18 + code.length + 8 * handlerCount;
2069 if (localVar != null) {
2070 cw.newUTF8("LocalVariableTable");
2071 size += 8 + localVar.length;
2072 }
2073 if (localVarType != null) {
2074 cw.newUTF8("LocalVariableTypeTable");
2075 size += 8 + localVarType.length;
2076 }
2077 if (lineNumber != null) {
2078 cw.newUTF8("LineNumberTable");
2079 size += 8 + lineNumber.length;
2080 }
2081 if (stackMap != null) {
2082 boolean zip = (cw.version & 0xFFFF) >= Opcodes.V1_6;
2083 cw.newUTF8(zip ? "StackMapTable" : "StackMap");
2084 size += 8 + stackMap.length;
2085 }
2086 if (ClassReader.ANNOTATIONS && ctanns != null) {
2087 cw.newUTF8("RuntimeVisibleTypeAnnotations");
2088 size += 8 + ctanns.getSize();
2089 }
2090 if (ClassReader.ANNOTATIONS && ictanns != null) {
2091 cw.newUTF8("RuntimeInvisibleTypeAnnotations");
2092 size += 8 + ictanns.getSize();
2093 }
2094 if (cattrs != null) {
2095 size += cattrs.getSize(cw, code.data, code.length, maxStack,
2096 maxLocals);
2097 }
2098 }
2099 if (exceptionCount > 0) {
2100 cw.newUTF8("Exceptions");
2101 size += 8 + 2 * exceptionCount;
2102 }
2103 if ((access & Opcodes.ACC_SYNTHETIC) != 0) {
2104 if ((cw.version & 0xFFFF) < Opcodes.V1_5
2105 || (access & ClassWriter.ACC_SYNTHETIC_ATTRIBUTE) != 0) {
2106 cw.newUTF8("Synthetic");
2107 size += 6;
2108 }
2109 }
2110 if ((access & Opcodes.ACC_DEPRECATED) != 0) {
2111 cw.newUTF8("Deprecated");
2112 size += 6;
2113 }
2114 if (ClassReader.SIGNATURES && signature != null) {
2115 cw.newUTF8("Signature");
2116 cw.newUTF8(signature);
2117 size += 8;
2118 }
2119 if (methodParameters != null) {
2120 cw.newUTF8("MethodParameters");
2121 size += 7 + methodParameters.length;
2122 }
2123 if (ClassReader.ANNOTATIONS && annd != null) {
2124 cw.newUTF8("AnnotationDefault");
2125 size += 6 + annd.length;
2126 }
2127 if (ClassReader.ANNOTATIONS && anns != null) {
2128 cw.newUTF8("RuntimeVisibleAnnotations");
2129 size += 8 + anns.getSize();
2130 }
2131 if (ClassReader.ANNOTATIONS && ianns != null) {
2132 cw.newUTF8("RuntimeInvisibleAnnotations");
2133 size += 8 + ianns.getSize();
2134 }
2135 if (ClassReader.ANNOTATIONS && tanns != null) {
2136 cw.newUTF8("RuntimeVisibleTypeAnnotations");
2137 size += 8 + tanns.getSize();
2138 }
2139 if (ClassReader.ANNOTATIONS && itanns != null) {
2140 cw.newUTF8("RuntimeInvisibleTypeAnnotations");
2141 size += 8 + itanns.getSize();
2142 }
2143 if (ClassReader.ANNOTATIONS && panns != null) {
2144 cw.newUTF8("RuntimeVisibleParameterAnnotations");
2145 size += 7 + 2 * (panns.length - synthetics);
2146 for (int i = panns.length - 1; i >= synthetics; --i) {
2147 size += panns[i] == null ? 0 : panns[i].getSize();
2148 }
2149 }
2150 if (ClassReader.ANNOTATIONS && ipanns != null) {
2151 cw.newUTF8("RuntimeInvisibleParameterAnnotations");
2152 size += 7 + 2 * (ipanns.length - synthetics);
2153 for (int i = ipanns.length - 1; i >= synthetics; --i) {
2154 size += ipanns[i] == null ? 0 : ipanns[i].getSize();
2155 }
2156 }
2157 if (attrs != null) {
2158 size += attrs.getSize(cw, null, 0, -1, -1);
2159 }
2160 return size;
2161 }
2162
2163 /**
2164 * Puts the bytecode of this method in the given byte vector.
2165 *
2166 * @param out
2167 * the byte vector into which the bytecode of this method must be
2168 * copied.
2169 */
2170 final void put(final ByteVector out) {
2171 final int FACTOR = ClassWriter.TO_ACC_SYNTHETIC;
2172 int mask = ACC_CONSTRUCTOR | Opcodes.ACC_DEPRECATED
2173 | ClassWriter.ACC_SYNTHETIC_ATTRIBUTE
2174 | ((access & ClassWriter.ACC_SYNTHETIC_ATTRIBUTE) / FACTOR);
2175 out.putShort(access & ~mask).putShort(name).putShort(desc);
2176 if (classReaderOffset != 0) {
2177 out.putByteArray(cw.cr.b, classReaderOffset, classReaderLength);
2178 return;
2179 }
2180 int attributeCount = 0;
2181 if (code.length > 0) {
2182 ++attributeCount;
2183 }
2184 if (exceptionCount > 0) {
2185 ++attributeCount;
2186 }
2187 if ((access & Opcodes.ACC_SYNTHETIC) != 0) {
2188 if ((cw.version & 0xFFFF) < Opcodes.V1_5
2189 || (access & ClassWriter.ACC_SYNTHETIC_ATTRIBUTE) != 0) {
2190 ++attributeCount;
2191 }
2192 }
2193 if ((access & Opcodes.ACC_DEPRECATED) != 0) {
2194 ++attributeCount;
2195 }
2196 if (ClassReader.SIGNATURES && signature != null) {
2197 ++attributeCount;
2198 }
2199 if (methodParameters != null) {
2200 ++attributeCount;
2201 }
2202 if (ClassReader.ANNOTATIONS && annd != null) {
2203 ++attributeCount;
2204 }
2205 if (ClassReader.ANNOTATIONS && anns != null) {
2206 ++attributeCount;
2207 }
2208 if (ClassReader.ANNOTATIONS && ianns != null) {
2209 ++attributeCount;
2210 }
2211 if (ClassReader.ANNOTATIONS && tanns != null) {
2212 ++attributeCount;
2213 }
2214 if (ClassReader.ANNOTATIONS && itanns != null) {
2215 ++attributeCount;
2216 }
2217 if (ClassReader.ANNOTATIONS && panns != null) {
2218 ++attributeCount;
2219 }
2220 if (ClassReader.ANNOTATIONS && ipanns != null) {
2221 ++attributeCount;
2222 }
2223 if (attrs != null) {
2224 attributeCount += attrs.getCount();
2225 }
2226 out.putShort(attributeCount);
2227 if (code.length > 0) {
2228 int size = 12 + code.length + 8 * handlerCount;
2229 if (localVar != null) {
2230 size += 8 + localVar.length;
2231 }
2232 if (localVarType != null) {
2233 size += 8 + localVarType.length;
2234 }
2235 if (lineNumber != null) {
2236 size += 8 + lineNumber.length;
2237 }
2238 if (stackMap != null) {
2239 size += 8 + stackMap.length;
2240 }
2241 if (ClassReader.ANNOTATIONS && ctanns != null) {
2242 size += 8 + ctanns.getSize();
2243 }
2244 if (ClassReader.ANNOTATIONS && ictanns != null) {
2245 size += 8 + ictanns.getSize();
2246 }
2247 if (cattrs != null) {
2248 size += cattrs.getSize(cw, code.data, code.length, maxStack,
2249 maxLocals);
2250 }
2251 out.putShort(cw.newUTF8("Code")).putInt(size);
2252 out.putShort(maxStack).putShort(maxLocals);
2253 out.putInt(code.length).putByteArray(code.data, 0, code.length);
2254 out.putShort(handlerCount);
2255 if (handlerCount > 0) {
2256 Handler h = firstHandler;
2257 while (h != null) {
2258 out.putShort(h.start.position).putShort(h.end.position)
2259 .putShort(h.handler.position).putShort(h.type);
2260 h = h.next;
2261 }
2262 }
2263 attributeCount = 0;
2264 if (localVar != null) {
2265 ++attributeCount;
2266 }
2267 if (localVarType != null) {
2268 ++attributeCount;
2269 }
2270 if (lineNumber != null) {
2271 ++attributeCount;
2272 }
2273 if (stackMap != null) {
2274 ++attributeCount;
2275 }
2276 if (ClassReader.ANNOTATIONS && ctanns != null) {
2277 ++attributeCount;
2278 }
2279 if (ClassReader.ANNOTATIONS && ictanns != null) {
2280 ++attributeCount;
2281 }
2282 if (cattrs != null) {
2283 attributeCount += cattrs.getCount();
2284 }
2285 out.putShort(attributeCount);
2286 if (localVar != null) {
2287 out.putShort(cw.newUTF8("LocalVariableTable"));
2288 out.putInt(localVar.length + 2).putShort(localVarCount);
2289 out.putByteArray(localVar.data, 0, localVar.length);
2290 }
2291 if (localVarType != null) {
2292 out.putShort(cw.newUTF8("LocalVariableTypeTable"));
2293 out.putInt(localVarType.length + 2).putShort(localVarTypeCount);
2294 out.putByteArray(localVarType.data, 0, localVarType.length);
2295 }
2296 if (lineNumber != null) {
2297 out.putShort(cw.newUTF8("LineNumberTable"));
2298 out.putInt(lineNumber.length + 2).putShort(lineNumberCount);
2299 out.putByteArray(lineNumber.data, 0, lineNumber.length);
2300 }
2301 if (stackMap != null) {
2302 boolean zip = (cw.version & 0xFFFF) >= Opcodes.V1_6;
2303 out.putShort(cw.newUTF8(zip ? "StackMapTable" : "StackMap"));
2304 out.putInt(stackMap.length + 2).putShort(frameCount);
2305 out.putByteArray(stackMap.data, 0, stackMap.length);
2306 }
2307 if (ClassReader.ANNOTATIONS && ctanns != null) {
2308 out.putShort(cw.newUTF8("RuntimeVisibleTypeAnnotations"));
2309 ctanns.put(out);
2310 }
2311 if (ClassReader.ANNOTATIONS && ictanns != null) {
2312 out.putShort(cw.newUTF8("RuntimeInvisibleTypeAnnotations"));
2313 ictanns.put(out);
2314 }
2315 if (cattrs != null) {
2316 cattrs.put(cw, code.data, code.length, maxLocals, maxStack, out);
2317 }
2318 }
2319 if (exceptionCount > 0) {
2320 out.putShort(cw.newUTF8("Exceptions")).putInt(
2321 2 * exceptionCount + 2);
2322 out.putShort(exceptionCount);
2323 for (int i = 0; i < exceptionCount; ++i) {
2324 out.putShort(exceptions[i]);
2325 }
2326 }
2327 if ((access & Opcodes.ACC_SYNTHETIC) != 0) {
2328 if ((cw.version & 0xFFFF) < Opcodes.V1_5
2329 || (access & ClassWriter.ACC_SYNTHETIC_ATTRIBUTE) != 0) {
2330 out.putShort(cw.newUTF8("Synthetic")).putInt(0);
2331 }
2332 }
2333 if ((access & Opcodes.ACC_DEPRECATED) != 0) {
2334 out.putShort(cw.newUTF8("Deprecated")).putInt(0);
2335 }
2336 if (ClassReader.SIGNATURES && signature != null) {
2337 out.putShort(cw.newUTF8("Signature")).putInt(2)
2338 .putShort(cw.newUTF8(signature));
2339 }
2340 if (methodParameters != null) {
2341 out.putShort(cw.newUTF8("MethodParameters"));
2342 out.putInt(methodParameters.length + 1).putByte(
2343 methodParametersCount);
2344 out.putByteArray(methodParameters.data, 0, methodParameters.length);
2345 }
2346 if (ClassReader.ANNOTATIONS && annd != null) {
2347 out.putShort(cw.newUTF8("AnnotationDefault"));
2348 out.putInt(annd.length);
2349 out.putByteArray(annd.data, 0, annd.length);
2350 }
2351 if (ClassReader.ANNOTATIONS && anns != null) {
2352 out.putShort(cw.newUTF8("RuntimeVisibleAnnotations"));
2353 anns.put(out);
2354 }
2355 if (ClassReader.ANNOTATIONS && ianns != null) {
2356 out.putShort(cw.newUTF8("RuntimeInvisibleAnnotations"));
2357 ianns.put(out);
2358 }
2359 if (ClassReader.ANNOTATIONS && tanns != null) {
2360 out.putShort(cw.newUTF8("RuntimeVisibleTypeAnnotations"));
2361 tanns.put(out);
2362 }
2363 if (ClassReader.ANNOTATIONS && itanns != null) {
2364 out.putShort(cw.newUTF8("RuntimeInvisibleTypeAnnotations"));
2365 itanns.put(out);
2366 }
2367 if (ClassReader.ANNOTATIONS && panns != null) {
2368 out.putShort(cw.newUTF8("RuntimeVisibleParameterAnnotations"));
2369 AnnotationWriter.put(panns, synthetics, out);
2370 }
2371 if (ClassReader.ANNOTATIONS && ipanns != null) {
2372 out.putShort(cw.newUTF8("RuntimeInvisibleParameterAnnotations"));
2373 AnnotationWriter.put(ipanns, synthetics, out);
2374 }
2375 if (attrs != null) {
2376 attrs.put(cw, null, 0, -1, -1, out);
2377 }
2378 }
2379
2380 // ------------------------------------------------------------------------
2381 // Utility methods: instruction resizing (used to handle GOTO_W and JSR_W)
2382 // ------------------------------------------------------------------------
2383
2384 /**
2385 * Resizes and replaces the temporary instructions inserted by
2386 * {@link Label#resolve} for wide forward jumps, while keeping jump offsets
2387 * and instruction addresses consistent. This may require to resize other
2388 * existing instructions, or even to introduce new instructions: for
2389 * example, increasing the size of an instruction by 2 at the middle of a
2390 * method can increases the offset of an IFEQ instruction from 32766 to
2391 * 32768, in which case IFEQ 32766 must be replaced with IFNEQ 8 GOTO_W
2392 * 32765. This, in turn, may require to increase the size of another jump
2393 * instruction, and so on... All these operations are handled automatically
2394 * by this method.
2395 * <p>
2396 * <i>This method must be called after all the method that is being built
2397 * has been visited</i>. In particular, the {@link Label Label} objects used
2398 * to construct the method are no longer valid after this method has been
2399 * called.
2400 */
2401 private void resizeInstructions() {
2402 byte[] b = code.data; // bytecode of the method
2403 int u, v, label; // indexes in b
2404 int i, j; // loop indexes
2405 /*
2406 * 1st step: As explained above, resizing an instruction may require to
2407 * resize another one, which may require to resize yet another one, and
2408 * so on. The first step of the algorithm consists in finding all the
2409 * instructions that need to be resized, without modifying the code.
2410 * This is done by the following "fix point" algorithm:
2411 *
2412 * Parse the code to find the jump instructions whose offset will need
2413 * more than 2 bytes to be stored (the future offset is computed from
2414 * the current offset and from the number of bytes that will be inserted
2415 * or removed between the source and target instructions). For each such
2416 * instruction, adds an entry in (a copy of) the indexes and sizes
2417 * arrays (if this has not already been done in a previous iteration!).
2418 *
2419 * If at least one entry has been added during the previous step, go
2420 * back to the beginning, otherwise stop.
2421 *
2422 * In fact the real algorithm is complicated by the fact that the size
2423 * of TABLESWITCH and LOOKUPSWITCH instructions depends on their
2424 * position in the bytecode (because of padding). In order to ensure the
2425 * convergence of the algorithm, the number of bytes to be added or
2426 * removed from these instructions is over estimated during the previous
2427 * loop, and computed exactly only after the loop is finished (this
2428 * requires another pass to parse the bytecode of the method).
2429 */
2430 int[] allIndexes = new int[0]; // copy of indexes
2431 int[] allSizes = new int[0]; // copy of sizes
2432 boolean[] resize; // instructions to be resized
2433 int newOffset; // future offset of a jump instruction
2434
2435 resize = new boolean[code.length];
2436
2437 // 3 = loop again, 2 = loop ended, 1 = last pass, 0 = done
2438 int state = 3;
2439 do {
2440 if (state == 3) {
2441 state = 2;
2442 }
2443 u = 0;
2444 while (u < b.length) {
2445 int opcode = b[u] & 0xFF; // opcode of current instruction
2446 int insert = 0; // bytes to be added after this instruction
2447
2448 switch (ClassWriter.TYPE[opcode]) {
2449 case ClassWriter.NOARG_INSN:
2450 case ClassWriter.IMPLVAR_INSN:
2451 u += 1;
2452 break;
2453 case ClassWriter.LABEL_INSN:
2454 if (opcode > 201) {
2455 // converts temporary opcodes 202 to 217, 218 and
2456 // 219 to IFEQ ... JSR (inclusive), IFNULL and
2457 // IFNONNULL
2458 opcode = opcode < 218 ? opcode - 49 : opcode - 20;
2459 label = u + readUnsignedShort(b, u + 1);
2460 } else {
2461 label = u + readShort(b, u + 1);
2462 }
2463 newOffset = getNewOffset(allIndexes, allSizes, u, label);
2464 if (newOffset < Short.MIN_VALUE
2465 || newOffset > Short.MAX_VALUE) {
2466 if (!resize[u]) {
2467 if (opcode == Opcodes.GOTO || opcode == Opcodes.JSR) {
2468 // two additional bytes will be required to
2469 // replace this GOTO or JSR instruction with
2470 // a GOTO_W or a JSR_W
2471 insert = 2;
2472 } else {
2473 // five additional bytes will be required to
2474 // replace this IFxxx <l> instruction with
2475 // IFNOTxxx <l'> GOTO_W <l>, where IFNOTxxx
2476 // is the "opposite" opcode of IFxxx (i.e.,
2477 // IFNE for IFEQ) and where <l'> designates
2478 // the instruction just after the GOTO_W.
2479 insert = 5;
2480 }
2481 resize[u] = true;
2482 }
2483 }
2484 u += 3;
2485 break;
2486 case ClassWriter.LABELW_INSN:
2487 u += 5;
2488 break;
2489 case ClassWriter.TABL_INSN:
2490 if (state == 1) {
2491 // true number of bytes to be added (or removed)
2492 // from this instruction = (future number of padding
2493 // bytes - current number of padding byte) -
2494 // previously over estimated variation =
2495 // = ((3 - newOffset%4) - (3 - u%4)) - u%4
2496 // = (-newOffset%4 + u%4) - u%4
2497 // = -(newOffset & 3)
2498 newOffset = getNewOffset(allIndexes, allSizes, 0, u);
2499 insert = -(newOffset & 3);
2500 } else if (!resize[u]) {
2501 // over estimation of the number of bytes to be
2502 // added to this instruction = 3 - current number
2503 // of padding bytes = 3 - (3 - u%4) = u%4 = u & 3
2504 insert = u & 3;
2505 resize[u] = true;
2506 }
2507 // skips instruction
2508 u = u + 4 - (u & 3);
2509 u += 4 * (readInt(b, u + 8) - readInt(b, u + 4) + 1) + 12;
2510 break;
2511 case ClassWriter.LOOK_INSN:
2512 if (state == 1) {
2513 // like TABL_INSN
2514 newOffset = getNewOffset(allIndexes, allSizes, 0, u);
2515 insert = -(newOffset & 3);
2516 } else if (!resize[u]) {
2517 // like TABL_INSN
2518 insert = u & 3;
2519 resize[u] = true;
2520 }
2521 // skips instruction
2522 u = u + 4 - (u & 3);
2523 u += 8 * readInt(b, u + 4) + 8;
2524 break;
2525 case ClassWriter.WIDE_INSN:
2526 opcode = b[u + 1] & 0xFF;
2527 if (opcode == Opcodes.IINC) {
2528 u += 6;
2529 } else {
2530 u += 4;
2531 }
2532 break;
2533 case ClassWriter.VAR_INSN:
2534 case ClassWriter.SBYTE_INSN:
2535 case ClassWriter.LDC_INSN:
2536 u += 2;
2537 break;
2538 case ClassWriter.SHORT_INSN:
2539 case ClassWriter.LDCW_INSN:
2540 case ClassWriter.FIELDORMETH_INSN:
2541 case ClassWriter.TYPE_INSN:
2542 case ClassWriter.IINC_INSN:
2543 u += 3;
2544 break;
2545 case ClassWriter.ITFMETH_INSN:
2546 case ClassWriter.INDYMETH_INSN:
2547 u += 5;
2548 break;
2549 // case ClassWriter.MANA_INSN:
2550 default:
2551 u += 4;
2552 break;
2553 }
2554 if (insert != 0) {
2555 // adds a new (u, insert) entry in the allIndexes and
2556 // allSizes arrays
2557 int[] newIndexes = new int[allIndexes.length + 1];
2558 int[] newSizes = new int[allSizes.length + 1];
2559 System.arraycopy(allIndexes, 0, newIndexes, 0,
2560 allIndexes.length);
2561 System.arraycopy(allSizes, 0, newSizes, 0, allSizes.length);
2562 newIndexes[allIndexes.length] = u;
2563 newSizes[allSizes.length] = insert;
2564 allIndexes = newIndexes;
2565 allSizes = newSizes;
2566 if (insert > 0) {
2567 state = 3;
2568 }
2569 }
2570 }
2571 if (state < 3) {
2572 --state;
2573 }
2574 } while (state != 0);
2575
2576 // 2nd step:
2577 // copies the bytecode of the method into a new bytevector, updates the
2578 // offsets, and inserts (or removes) bytes as requested.
2579
2580 ByteVector newCode = new ByteVector(code.length);
2581
2582 u = 0;
2583 while (u < code.length) {
2584 int opcode = b[u] & 0xFF;
2585 switch (ClassWriter.TYPE[opcode]) {
2586 case ClassWriter.NOARG_INSN:
2587 case ClassWriter.IMPLVAR_INSN:
2588 newCode.putByte(opcode);
2589 u += 1;
2590 break;
2591 case ClassWriter.LABEL_INSN:
2592 if (opcode > 201) {
2593 // changes temporary opcodes 202 to 217 (inclusive), 218
2594 // and 219 to IFEQ ... JSR (inclusive), IFNULL and
2595 // IFNONNULL
2596 opcode = opcode < 218 ? opcode - 49 : opcode - 20;
2597 label = u + readUnsignedShort(b, u + 1);
2598 } else {
2599 label = u + readShort(b, u + 1);
2600 }
2601 newOffset = getNewOffset(allIndexes, allSizes, u, label);
2602 if (resize[u]) {
2603 // replaces GOTO with GOTO_W, JSR with JSR_W and IFxxx
2604 // <l> with IFNOTxxx <l'> GOTO_W <l>, where IFNOTxxx is
2605 // the "opposite" opcode of IFxxx (i.e., IFNE for IFEQ)
2606 // and where <l'> designates the instruction just after
2607 // the GOTO_W.
2608 if (opcode == Opcodes.GOTO) {
2609 newCode.putByte(200); // GOTO_W
2610 } else if (opcode == Opcodes.JSR) {
2611 newCode.putByte(201); // JSR_W
2612 } else {
2613 newCode.putByte(opcode <= 166 ? ((opcode + 1) ^ 1) - 1
2614 : opcode ^ 1);
2615 newCode.putShort(8); // jump offset
2616 newCode.putByte(200); // GOTO_W
2617 // newOffset now computed from start of GOTO_W
2618 newOffset -= 3;
2619 }
2620 newCode.putInt(newOffset);
2621 } else {
2622 newCode.putByte(opcode);
2623 newCode.putShort(newOffset);
2624 }
2625 u += 3;
2626 break;
2627 case ClassWriter.LABELW_INSN:
2628 label = u + readInt(b, u + 1);
2629 newOffset = getNewOffset(allIndexes, allSizes, u, label);
2630 newCode.putByte(opcode);
2631 newCode.putInt(newOffset);
2632 u += 5;
2633 break;
2634 case ClassWriter.TABL_INSN:
2635 // skips 0 to 3 padding bytes
2636 v = u;
2637 u = u + 4 - (v & 3);
2638 // reads and copies instruction
2639 newCode.putByte(Opcodes.TABLESWITCH);
2640 newCode.putByteArray(null, 0, (4 - newCode.length % 4) % 4);
2641 label = v + readInt(b, u);
2642 u += 4;
2643 newOffset = getNewOffset(allIndexes, allSizes, v, label);
2644 newCode.putInt(newOffset);
2645 j = readInt(b, u);
2646 u += 4;
2647 newCode.putInt(j);
2648 j = readInt(b, u) - j + 1;
2649 u += 4;
2650 newCode.putInt(readInt(b, u - 4));
2651 for (; j > 0; --j) {
2652 label = v + readInt(b, u);
2653 u += 4;
2654 newOffset = getNewOffset(allIndexes, allSizes, v, label);
2655 newCode.putInt(newOffset);
2656 }
2657 break;
2658 case ClassWriter.LOOK_INSN:
2659 // skips 0 to 3 padding bytes
2660 v = u;
2661 u = u + 4 - (v & 3);
2662 // reads and copies instruction
2663 newCode.putByte(Opcodes.LOOKUPSWITCH);
2664 newCode.putByteArray(null, 0, (4 - newCode.length % 4) % 4);
2665 label = v + readInt(b, u);
2666 u += 4;
2667 newOffset = getNewOffset(allIndexes, allSizes, v, label);
2668 newCode.putInt(newOffset);
2669 j = readInt(b, u);
2670 u += 4;
2671 newCode.putInt(j);
2672 for (; j > 0; --j) {
2673 newCode.putInt(readInt(b, u));
2674 u += 4;
2675 label = v + readInt(b, u);
2676 u += 4;
2677 newOffset = getNewOffset(allIndexes, allSizes, v, label);
2678 newCode.putInt(newOffset);
2679 }
2680 break;
2681 case ClassWriter.WIDE_INSN:
2682 opcode = b[u + 1] & 0xFF;
2683 if (opcode == Opcodes.IINC) {
2684 newCode.putByteArray(b, u, 6);
2685 u += 6;
2686 } else {
2687 newCode.putByteArray(b, u, 4);
2688 u += 4;
2689 }
2690 break;
2691 case ClassWriter.VAR_INSN:
2692 case ClassWriter.SBYTE_INSN:
2693 case ClassWriter.LDC_INSN:
2694 newCode.putByteArray(b, u, 2);
2695 u += 2;
2696 break;
2697 case ClassWriter.SHORT_INSN:
2698 case ClassWriter.LDCW_INSN:
2699 case ClassWriter.FIELDORMETH_INSN:
2700 case ClassWriter.TYPE_INSN:
2701 case ClassWriter.IINC_INSN:
2702 newCode.putByteArray(b, u, 3);
2703 u += 3;
2704 break;
2705 case ClassWriter.ITFMETH_INSN:
2706 case ClassWriter.INDYMETH_INSN:
2707 newCode.putByteArray(b, u, 5);
2708 u += 5;
2709 break;
2710 // case MANA_INSN:
2711 default:
2712 newCode.putByteArray(b, u, 4);
2713 u += 4;
2714 break;
2715 }
2716 }
2717
2718 // updates the stack map frame labels
2719 if (compute == FRAMES) {
2720 Label l = labels;
2721 while (l != null) {
2722 /*
2723 * Detects the labels that are just after an IF instruction that
2724 * has been resized with the IFNOT GOTO_W pattern. These labels
2725 * are now the target of a jump instruction (the IFNOT
2726 * instruction). Note that we need the original label position
2727 * here. getNewOffset must therefore never have been called for
2728 * this label.
2729 */
2730 u = l.position - 3;
2731 if (u >= 0 && resize[u]) {
2732 l.status |= Label.TARGET;
2733 }
2734 getNewOffset(allIndexes, allSizes, l);
2735 l = l.successor;
2736 }
2737 // Update the offsets in the uninitialized types
2738 if (cw.typeTable != null) {
2739 for (i = 0; i < cw.typeTable.length; ++i) {
2740 Item item = cw.typeTable[i];
2741 if (item != null && item.type == ClassWriter.TYPE_UNINIT) {
2742 item.intVal = getNewOffset(allIndexes, allSizes, 0,
2743 item.intVal);
2744 }
2745 }
2746 }
2747 // The stack map frames are not serialized yet, so we don't need
2748 // to update them. They will be serialized in visitMaxs.
2749 } else if (frameCount > 0) {
2750 /*
2751 * Resizing an existing stack map frame table is really hard. Not
2752 * only the table must be parsed to update the offets, but new
2753 * frames may be needed for jump instructions that were inserted by
2754 * this method. And updating the offsets or inserting frames can
2755 * change the format of the following frames, in case of packed
2756 * frames. In practice the whole table must be recomputed. For this
2757 * the frames are marked as potentially invalid. This will cause the
2758 * whole class to be reread and rewritten with the COMPUTE_FRAMES
2759 * option (see the ClassWriter.toByteArray method). This is not very
2760 * efficient but is much easier and requires much less code than any
2761 * other method I can think of.
2762 */
2763 cw.invalidFrames = true;
2764 }
2765 // updates the exception handler block labels
2766 Handler h = firstHandler;
2767 while (h != null) {
2768 getNewOffset(allIndexes, allSizes, h.start);
2769 getNewOffset(allIndexes, allSizes, h.end);
2770 getNewOffset(allIndexes, allSizes, h.handler);
2771 h = h.next;
2772 }
2773 // updates the instructions addresses in the
2774 // local var and line number tables
2775 for (i = 0; i < 2; ++i) {
2776 ByteVector bv = i == 0 ? localVar : localVarType;
2777 if (bv != null) {
2778 b = bv.data;
2779 u = 0;
2780 while (u < bv.length) {
2781 label = readUnsignedShort(b, u);
2782 newOffset = getNewOffset(allIndexes, allSizes, 0, label);
2783 writeShort(b, u, newOffset);
2784 label += readUnsignedShort(b, u + 2);
2785 newOffset = getNewOffset(allIndexes, allSizes, 0, label)
2786 - newOffset;
2787 writeShort(b, u + 2, newOffset);
2788 u += 10;
2789 }
2790 }
2791 }
2792 if (lineNumber != null) {
2793 b = lineNumber.data;
2794 u = 0;
2795 while (u < lineNumber.length) {
2796 writeShort(
2797 b,
2798 u,
2799 getNewOffset(allIndexes, allSizes, 0,
2800 readUnsignedShort(b, u)));
2801 u += 4;
2802 }
2803 }
2804 // updates the labels of the other attributes
2805 Attribute attr = cattrs;
2806 while (attr != null) {
2807 Label[] labels = attr.getLabels();
2808 if (labels != null) {
2809 for (i = labels.length - 1; i >= 0; --i) {
2810 getNewOffset(allIndexes, allSizes, labels[i]);
2811 }
2812 }
2813 attr = attr.next;
2814 }
2815
2816 // replaces old bytecodes with new ones
2817 code = newCode;
2818 }
2819
2820 /**
2821 * Reads an unsigned short value in the given byte array.
2822 *
2823 * @param b
2824 * a byte array.
2825 * @param index
2826 * the start index of the value to be read.
2827 * @return the read value.
2828 */
2829 static int readUnsignedShort(final byte[] b, final int index) {
2830 return ((b[index] & 0xFF) << 8) | (b[index + 1] & 0xFF);
2831 }
2832
2833 /**
2834 * Reads a signed short value in the given byte array.
2835 *
2836 * @param b
2837 * a byte array.
2838 * @param index
2839 * the start index of the value to be read.
2840 * @return the read value.
2841 */
2842 static short readShort(final byte[] b, final int index) {
2843 return (short) (((b[index] & 0xFF) << 8) | (b[index + 1] & 0xFF));
2844 }
2845
2846 /**
2847 * Reads a signed int value in the given byte array.
2848 *
2849 * @param b
2850 * a byte array.
2851 * @param index
2852 * the start index of the value to be read.
2853 * @return the read value.
2854 */
2855 static int readInt(final byte[] b, final int index) {
2856 return ((b[index] & 0xFF) << 24) | ((b[index + 1] & 0xFF) << 16)
2857 | ((b[index + 2] & 0xFF) << 8) | (b[index + 3] & 0xFF);
2858 }
2859
2860 /**
2861 * Writes a short value in the given byte array.
2862 *
2863 * @param b
2864 * a byte array.
2865 * @param index
2866 * where the first byte of the short value must be written.
2867 * @param s
2868 * the value to be written in the given byte array.
2869 */
2870 static void writeShort(final byte[] b, final int index, final int s) {
2871 b[index] = (byte) (s >>> 8);
2872 b[index + 1] = (byte) s;
2873 }
2874
2875 /**
2876 * Computes the future value of a bytecode offset.
2877 * <p>
2878 * Note: it is possible to have several entries for the same instruction in
2879 * the <tt>indexes</tt> and <tt>sizes</tt>: two entries (index=a,size=b) and
2880 * (index=a,size=b') are equivalent to a single entry (index=a,size=b+b').
2881 *
2882 * @param indexes
2883 * current positions of the instructions to be resized. Each
2884 * instruction must be designated by the index of its <i>last</i>
2885 * byte, plus one (or, in other words, by the index of the
2886 * <i>first</i> byte of the <i>next</i> instruction).
2887 * @param sizes
2888 * the number of bytes to be <i>added</i> to the above
2889 * instructions. More precisely, for each i < <tt>len</tt>,
2890 * <tt>sizes</tt>[i] bytes will be added at the end of the
2891 * instruction designated by <tt>indexes</tt>[i] or, if
2892 * <tt>sizes</tt>[i] is negative, the <i>last</i> |
2893 * <tt>sizes[i]</tt>| bytes of the instruction will be removed
2894 * (the instruction size <i>must not</i> become negative or
2895 * null).
2896 * @param begin
2897 * index of the first byte of the source instruction.
2898 * @param end
2899 * index of the first byte of the target instruction.
2900 * @return the future value of the given bytecode offset.
2901 */
2902 static int getNewOffset(final int[] indexes, final int[] sizes,
2903 final int begin, final int end) {
2904 int offset = end - begin;
2905 for (int i = 0; i < indexes.length; ++i) {
2906 if (begin < indexes[i] && indexes[i] <= end) {
2907 // forward jump
2908 offset += sizes[i];
2909 } else if (end < indexes[i] && indexes[i] <= begin) {
2910 // backward jump
2911 offset -= sizes[i];
2912 }
2913 }
2914 return offset;
2915 }
2916
2917 /**
2918 * Updates the offset of the given label.
2919 *
2920 * @param indexes
2921 * current positions of the instructions to be resized. Each
2922 * instruction must be designated by the index of its <i>last</i>
2923 * byte, plus one (or, in other words, by the index of the
2924 * <i>first</i> byte of the <i>next</i> instruction).
2925 * @param sizes
2926 * the number of bytes to be <i>added</i> to the above
2927 * instructions. More precisely, for each i < <tt>len</tt>,
2928 * <tt>sizes</tt>[i] bytes will be added at the end of the
2929 * instruction designated by <tt>indexes</tt>[i] or, if
2930 * <tt>sizes</tt>[i] is negative, the <i>last</i> |
2931 * <tt>sizes[i]</tt>| bytes of the instruction will be removed
2932 * (the instruction size <i>must not</i> become negative or
2933 * null).
2934 * @param label
2935 * the label whose offset must be updated.
2936 */
2937 static void getNewOffset(final int[] indexes, final int[] sizes,
2938 final Label label) {
2939 if ((label.status & Label.RESIZED) == 0) {
2940 label.position = getNewOffset(indexes, sizes, 0, label.position);
2941 label.status |= Label.RESIZED;
2942 }
2943 }
2944 }