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.util;
60
61 import java.io.PrintWriter;
62 import java.io.StringWriter;
63 import java.lang.reflect.Field;
64 import java.util.ArrayList;
65 import java.util.HashMap;
66 import java.util.HashSet;
67 import java.util.List;
68 import java.util.Map;
69 import java.util.Set;
70
71 import jdk.internal.org.objectweb.asm.AnnotationVisitor;
72 import jdk.internal.org.objectweb.asm.Attribute;
73 import jdk.internal.org.objectweb.asm.Handle;
74 import jdk.internal.org.objectweb.asm.Label;
75 import jdk.internal.org.objectweb.asm.MethodVisitor;
76 import jdk.internal.org.objectweb.asm.Opcodes;
77 import jdk.internal.org.objectweb.asm.Type;
78 import jdk.internal.org.objectweb.asm.TypePath;
79 import jdk.internal.org.objectweb.asm.TypeReference;
80 import jdk.internal.org.objectweb.asm.tree.MethodNode;
81 import jdk.internal.org.objectweb.asm.tree.analysis.Analyzer;
82 import jdk.internal.org.objectweb.asm.tree.analysis.BasicValue;
83 import jdk.internal.org.objectweb.asm.tree.analysis.BasicVerifier;
84
85 /**
86 * A {@link MethodVisitor} that checks that its methods are properly used. More
87 * precisely this method adapter checks each instruction individually, i.e.,
88 * each visit method checks some preconditions based <i>only</i> on its
89 * arguments - such as the fact that the given opcode is correct for a given
90 * visit method. This adapter can also perform some basic data flow checks (more
91 * precisely those that can be performed without the full class hierarchy - see
92 * {@link jdk.internal.org.objectweb.asm.tree.analysis.BasicVerifier}). For instance in a
93 * method whose signature is <tt>void m ()</tt>, the invalid instruction
94 * IRETURN, or the invalid sequence IADD L2I will be detected if the data flow
95 * checks are enabled. These checks are enabled by using the
96 * {@link #CheckMethodAdapter(int,String,String,MethodVisitor,Map)} constructor.
97 * They are not performed if any other constructor is used.
98 *
99 * @author Eric Bruneton
100 */
101 public class CheckMethodAdapter extends MethodVisitor {
102
103 /**
104 * The class version number.
105 */
106 public int version;
107
108 /**
109 * The access flags of the method.
110 */
111 private int access;
112
113 /**
114 * <tt>true</tt> if the visitCode method has been called.
115 */
116 private boolean startCode;
117
118 /**
119 * <tt>true</tt> if the visitMaxs method has been called.
120 */
121 private boolean endCode;
122
123 /**
124 * <tt>true</tt> if the visitEnd method has been called.
125 */
126 private boolean endMethod;
127
128 /**
129 * Number of visited instructions.
130 */
131 private int insnCount;
132
133 /**
134 * The already visited labels. This map associate Integer values to pseudo
135 * code offsets.
136 */
137 private final Map<Label, Integer> labels;
138
139 /**
140 * The labels used in this method. Every used label must be visited with
141 * visitLabel before the end of the method (i.e. should be in #labels).
142 */
143 private Set<Label> usedLabels;
144
145 /**
146 * Number of visited frames in expanded form.
147 */
148 private int expandedFrames;
149
150 /**
151 * Number of visited frames in compressed form.
152 */
153 private int compressedFrames;
154
155 /**
156 * Number of instructions before the last visited frame.
157 */
158 private int lastFrame = -1;
159
160 /**
161 * The exception handler ranges. Each pair of list element contains the
162 * start and end labels of an exception handler block.
163 */
164 private List<Label> handlers;
165
166 /**
167 * Code of the visit method to be used for each opcode.
168 */
169 private static final int[] TYPE;
170
171 /**
172 * The Label.status field.
173 */
174 private static Field labelStatusField;
175
176 static {
177 String s = "BBBBBBBBBBBBBBBBCCIAADDDDDAAAAAAAAAAAAAAAAAAAABBBBBBBBDD"
178 + "DDDAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
179 + "BBBBBBBBBBBBBBBBBBBJBBBBBBBBBBBBBBBBBBBBHHHHHHHHHHHHHHHHD"
180 + "KLBBBBBBFFFFGGGGAECEBBEEBBAMHHAA";
181 TYPE = new int[s.length()];
182 for (int i = 0; i < TYPE.length; ++i) {
183 TYPE[i] = s.charAt(i) - 'A' - 1;
184 }
185 }
186
187 // code to generate the above string
188 // public static void main (String[] args) {
189 // int[] TYPE = new int[] {
190 // 0, //NOP
191 // 0, //ACONST_NULL
192 // 0, //ICONST_M1
193 // 0, //ICONST_0
194 // 0, //ICONST_1
195 // 0, //ICONST_2
196 // 0, //ICONST_3
197 // 0, //ICONST_4
198 // 0, //ICONST_5
199 // 0, //LCONST_0
200 // 0, //LCONST_1
201 // 0, //FCONST_0
202 // 0, //FCONST_1
203 // 0, //FCONST_2
204 // 0, //DCONST_0
205 // 0, //DCONST_1
206 // 1, //BIPUSH
207 // 1, //SIPUSH
208 // 7, //LDC
209 // -1, //LDC_W
210 // -1, //LDC2_W
211 // 2, //ILOAD
212 // 2, //LLOAD
213 // 2, //FLOAD
214 // 2, //DLOAD
215 // 2, //ALOAD
216 // -1, //ILOAD_0
217 // -1, //ILOAD_1
218 // -1, //ILOAD_2
219 // -1, //ILOAD_3
220 // -1, //LLOAD_0
221 // -1, //LLOAD_1
222 // -1, //LLOAD_2
223 // -1, //LLOAD_3
224 // -1, //FLOAD_0
225 // -1, //FLOAD_1
226 // -1, //FLOAD_2
227 // -1, //FLOAD_3
228 // -1, //DLOAD_0
229 // -1, //DLOAD_1
230 // -1, //DLOAD_2
231 // -1, //DLOAD_3
232 // -1, //ALOAD_0
233 // -1, //ALOAD_1
234 // -1, //ALOAD_2
235 // -1, //ALOAD_3
236 // 0, //IALOAD
237 // 0, //LALOAD
238 // 0, //FALOAD
239 // 0, //DALOAD
240 // 0, //AALOAD
241 // 0, //BALOAD
242 // 0, //CALOAD
243 // 0, //SALOAD
244 // 2, //ISTORE
245 // 2, //LSTORE
246 // 2, //FSTORE
247 // 2, //DSTORE
248 // 2, //ASTORE
249 // -1, //ISTORE_0
250 // -1, //ISTORE_1
251 // -1, //ISTORE_2
252 // -1, //ISTORE_3
253 // -1, //LSTORE_0
254 // -1, //LSTORE_1
255 // -1, //LSTORE_2
256 // -1, //LSTORE_3
257 // -1, //FSTORE_0
258 // -1, //FSTORE_1
259 // -1, //FSTORE_2
260 // -1, //FSTORE_3
261 // -1, //DSTORE_0
262 // -1, //DSTORE_1
263 // -1, //DSTORE_2
264 // -1, //DSTORE_3
265 // -1, //ASTORE_0
266 // -1, //ASTORE_1
267 // -1, //ASTORE_2
268 // -1, //ASTORE_3
269 // 0, //IASTORE
270 // 0, //LASTORE
271 // 0, //FASTORE
272 // 0, //DASTORE
273 // 0, //AASTORE
274 // 0, //BASTORE
275 // 0, //CASTORE
276 // 0, //SASTORE
277 // 0, //POP
278 // 0, //POP2
279 // 0, //DUP
280 // 0, //DUP_X1
281 // 0, //DUP_X2
282 // 0, //DUP2
283 // 0, //DUP2_X1
284 // 0, //DUP2_X2
285 // 0, //SWAP
286 // 0, //IADD
287 // 0, //LADD
288 // 0, //FADD
289 // 0, //DADD
290 // 0, //ISUB
291 // 0, //LSUB
292 // 0, //FSUB
293 // 0, //DSUB
294 // 0, //IMUL
295 // 0, //LMUL
296 // 0, //FMUL
297 // 0, //DMUL
298 // 0, //IDIV
299 // 0, //LDIV
300 // 0, //FDIV
301 // 0, //DDIV
302 // 0, //IREM
303 // 0, //LREM
304 // 0, //FREM
305 // 0, //DREM
306 // 0, //INEG
307 // 0, //LNEG
308 // 0, //FNEG
309 // 0, //DNEG
310 // 0, //ISHL
311 // 0, //LSHL
312 // 0, //ISHR
313 // 0, //LSHR
314 // 0, //IUSHR
315 // 0, //LUSHR
316 // 0, //IAND
317 // 0, //LAND
318 // 0, //IOR
319 // 0, //LOR
320 // 0, //IXOR
321 // 0, //LXOR
322 // 8, //IINC
323 // 0, //I2L
324 // 0, //I2F
325 // 0, //I2D
326 // 0, //L2I
327 // 0, //L2F
328 // 0, //L2D
329 // 0, //F2I
330 // 0, //F2L
331 // 0, //F2D
332 // 0, //D2I
333 // 0, //D2L
334 // 0, //D2F
335 // 0, //I2B
336 // 0, //I2C
337 // 0, //I2S
338 // 0, //LCMP
339 // 0, //FCMPL
340 // 0, //FCMPG
341 // 0, //DCMPL
342 // 0, //DCMPG
343 // 6, //IFEQ
344 // 6, //IFNE
345 // 6, //IFLT
346 // 6, //IFGE
347 // 6, //IFGT
348 // 6, //IFLE
349 // 6, //IF_ICMPEQ
350 // 6, //IF_ICMPNE
351 // 6, //IF_ICMPLT
352 // 6, //IF_ICMPGE
353 // 6, //IF_ICMPGT
354 // 6, //IF_ICMPLE
355 // 6, //IF_ACMPEQ
356 // 6, //IF_ACMPNE
357 // 6, //GOTO
358 // 6, //JSR
359 // 2, //RET
360 // 9, //TABLESWITCH
361 // 10, //LOOKUPSWITCH
362 // 0, //IRETURN
363 // 0, //LRETURN
364 // 0, //FRETURN
365 // 0, //DRETURN
366 // 0, //ARETURN
367 // 0, //RETURN
368 // 4, //GETSTATIC
369 // 4, //PUTSTATIC
370 // 4, //GETFIELD
371 // 4, //PUTFIELD
372 // 5, //INVOKEVIRTUAL
373 // 5, //INVOKESPECIAL
374 // 5, //INVOKESTATIC
375 // 5, //INVOKEINTERFACE
376 // -1, //INVOKEDYNAMIC
377 // 3, //NEW
378 // 1, //NEWARRAY
379 // 3, //ANEWARRAY
380 // 0, //ARRAYLENGTH
381 // 0, //ATHROW
382 // 3, //CHECKCAST
383 // 3, //INSTANCEOF
384 // 0, //MONITORENTER
385 // 0, //MONITOREXIT
386 // -1, //WIDE
387 // 11, //MULTIANEWARRAY
388 // 6, //IFNULL
389 // 6, //IFNONNULL
390 // -1, //GOTO_W
391 // -1 //JSR_W
392 // };
393 // for (int i = 0; i < TYPE.length; ++i) {
394 // System.out.print((char)(TYPE[i] + 1 + 'A'));
395 // }
396 // System.out.println();
397 // }
398
399 /**
400 * Constructs a new {@link CheckMethodAdapter} object. This method adapter
401 * will not perform any data flow check (see
402 * {@link #CheckMethodAdapter(int,String,String,MethodVisitor,Map)}).
403 * <i>Subclasses must not use this constructor</i>. Instead, they must use
404 * the {@link #CheckMethodAdapter(int, MethodVisitor, Map)} version.
405 *
406 * @param mv
407 * the method visitor to which this adapter must delegate calls.
408 */
409 public CheckMethodAdapter(final MethodVisitor mv) {
410 this(mv, new HashMap<Label, Integer>());
411 }
412
413 /**
414 * Constructs a new {@link CheckMethodAdapter} object. This method adapter
415 * will not perform any data flow check (see
416 * {@link #CheckMethodAdapter(int,String,String,MethodVisitor,Map)}).
417 * <i>Subclasses must not use this constructor</i>. Instead, they must use
418 * the {@link #CheckMethodAdapter(int, MethodVisitor, Map)} version.
419 *
420 * @param mv
421 * the method visitor to which this adapter must delegate calls.
422 * @param labels
423 * a map of already visited labels (in other methods).
424 * @throws IllegalStateException
425 * If a subclass calls this constructor.
426 */
427 public CheckMethodAdapter(final MethodVisitor mv,
428 final Map<Label, Integer> labels) {
429 this(Opcodes.ASM5, mv, labels);
430 if (getClass() != CheckMethodAdapter.class) {
431 throw new IllegalStateException();
432 }
433 }
434
435 /**
436 * Constructs a new {@link CheckMethodAdapter} object. This method adapter
437 * will not perform any data flow check (see
438 * {@link #CheckMethodAdapter(int,String,String,MethodVisitor,Map)}).
439 *
440 * @param api
441 * the ASM API version implemented by this CheckMethodAdapter.
442 * Must be one of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}.
443 * @param mv
444 * the method visitor to which this adapter must delegate calls.
445 * @param labels
446 * a map of already visited labels (in other methods).
447 */
448 protected CheckMethodAdapter(final int api, final MethodVisitor mv,
449 final Map<Label, Integer> labels) {
450 super(api, mv);
451 this.labels = labels;
452 this.usedLabels = new HashSet<Label>();
453 this.handlers = new ArrayList<Label>();
454 }
455
456 /**
457 * Constructs a new {@link CheckMethodAdapter} object. This method adapter
458 * will perform basic data flow checks. For instance in a method whose
459 * signature is <tt>void m ()</tt>, the invalid instruction IRETURN, or the
460 * invalid sequence IADD L2I will be detected.
461 *
462 * @param access
463 * the method's access flags.
464 * @param name
465 * the method's name.
466 * @param desc
467 * the method's descriptor (see {@link Type Type}).
468 * @param cmv
469 * the method visitor to which this adapter must delegate calls.
470 * @param labels
471 * a map of already visited labels (in other methods).
472 */
473 public CheckMethodAdapter(final int access, final String name,
474 final String desc, final MethodVisitor cmv,
475 final Map<Label, Integer> labels) {
476 this(new MethodNode(Opcodes.ASM5, access, name, desc, null, null) {
477 @Override
478 public void visitEnd() {
479 Analyzer<BasicValue> a = new Analyzer<BasicValue>(
480 new BasicVerifier());
481 try {
482 a.analyze("dummy", this);
483 } catch (Exception e) {
484 if (e instanceof IndexOutOfBoundsException
485 && maxLocals == 0 && maxStack == 0) {
486 throw new RuntimeException(
487 "Data flow checking option requires valid, non zero maxLocals and maxStack values.");
488 }
489 e.printStackTrace();
490 StringWriter sw = new StringWriter();
491 PrintWriter pw = new PrintWriter(sw, true);
492 CheckClassAdapter.printAnalyzerResult(this, a, pw);
493 pw.close();
494 throw new RuntimeException(e.getMessage() + ' '
495 + sw.toString());
496 }
497 accept(cmv);
498 }
499 }, labels);
500 this.access = access;
501 }
502
503 @Override
504 public void visitParameter(String name, int access) {
505 if (name != null) {
506 checkUnqualifiedName(version, name, "name");
507 }
508 CheckClassAdapter.checkAccess(access, Opcodes.ACC_FINAL
509 + Opcodes.ACC_MANDATED + Opcodes.ACC_SYNTHETIC);
510 super.visitParameter(name, access);
511 }
512
513 @Override
514 public AnnotationVisitor visitAnnotation(final String desc,
515 final boolean visible) {
516 checkEndMethod();
517 checkDesc(desc, false);
518 return new CheckAnnotationAdapter(super.visitAnnotation(desc, visible));
519 }
520
521 @Override
522 public AnnotationVisitor visitTypeAnnotation(final int typeRef,
523 final TypePath typePath, final String desc, final boolean visible) {
524 checkEndMethod();
525 int sort = typeRef >>> 24;
526 if (sort != TypeReference.METHOD_TYPE_PARAMETER
527 && sort != TypeReference.METHOD_TYPE_PARAMETER_BOUND
528 && sort != TypeReference.METHOD_RETURN
529 && sort != TypeReference.METHOD_RECEIVER
530 && sort != TypeReference.METHOD_FORMAL_PARAMETER
531 && sort != TypeReference.THROWS) {
532 throw new IllegalArgumentException("Invalid type reference sort 0x"
533 + Integer.toHexString(sort));
534 }
535 CheckClassAdapter.checkTypeRefAndPath(typeRef, typePath);
536 CheckMethodAdapter.checkDesc(desc, false);
537 return new CheckAnnotationAdapter(super.visitTypeAnnotation(typeRef,
538 typePath, desc, visible));
539 }
540
541 @Override
542 public AnnotationVisitor visitAnnotationDefault() {
543 checkEndMethod();
544 return new CheckAnnotationAdapter(super.visitAnnotationDefault(), false);
545 }
546
547 @Override
548 public AnnotationVisitor visitParameterAnnotation(final int parameter,
549 final String desc, final boolean visible) {
550 checkEndMethod();
551 checkDesc(desc, false);
552 return new CheckAnnotationAdapter(super.visitParameterAnnotation(
553 parameter, desc, visible));
554 }
555
556 @Override
557 public void visitAttribute(final Attribute attr) {
558 checkEndMethod();
559 if (attr == null) {
560 throw new IllegalArgumentException(
561 "Invalid attribute (must not be null)");
562 }
563 super.visitAttribute(attr);
564 }
565
566 @Override
567 public void visitCode() {
568 if ((access & Opcodes.ACC_ABSTRACT) != 0) {
569 throw new RuntimeException("Abstract methods cannot have code");
570 }
571 startCode = true;
572 super.visitCode();
573 }
574
575 @Override
576 public void visitFrame(final int type, final int nLocal,
577 final Object[] local, final int nStack, final Object[] stack) {
578 if (insnCount == lastFrame) {
579 throw new IllegalStateException(
580 "At most one frame can be visited at a given code location.");
581 }
582 lastFrame = insnCount;
583 int mLocal;
584 int mStack;
585 switch (type) {
586 case Opcodes.F_NEW:
587 case Opcodes.F_FULL:
588 mLocal = Integer.MAX_VALUE;
589 mStack = Integer.MAX_VALUE;
590 break;
591
592 case Opcodes.F_SAME:
593 mLocal = 0;
594 mStack = 0;
595 break;
596
597 case Opcodes.F_SAME1:
598 mLocal = 0;
599 mStack = 1;
600 break;
601
602 case Opcodes.F_APPEND:
603 case Opcodes.F_CHOP:
604 mLocal = 3;
605 mStack = 0;
606 break;
607
608 default:
609 throw new IllegalArgumentException("Invalid frame type " + type);
610 }
611
612 if (nLocal > mLocal) {
613 throw new IllegalArgumentException("Invalid nLocal=" + nLocal
614 + " for frame type " + type);
615 }
616 if (nStack > mStack) {
617 throw new IllegalArgumentException("Invalid nStack=" + nStack
618 + " for frame type " + type);
619 }
620
621 if (type != Opcodes.F_CHOP) {
622 if (nLocal > 0 && (local == null || local.length < nLocal)) {
623 throw new IllegalArgumentException(
624 "Array local[] is shorter than nLocal");
625 }
626 for (int i = 0; i < nLocal; ++i) {
627 checkFrameValue(local[i]);
628 }
629 }
630 if (nStack > 0 && (stack == null || stack.length < nStack)) {
631 throw new IllegalArgumentException(
632 "Array stack[] is shorter than nStack");
633 }
634 for (int i = 0; i < nStack; ++i) {
635 checkFrameValue(stack[i]);
636 }
637 if (type == Opcodes.F_NEW) {
638 ++expandedFrames;
639 } else {
640 ++compressedFrames;
641 }
642 if (expandedFrames > 0 && compressedFrames > 0) {
643 throw new RuntimeException(
644 "Expanded and compressed frames must not be mixed.");
645 }
646 super.visitFrame(type, nLocal, local, nStack, stack);
647 }
648
649 @Override
650 public void visitInsn(final int opcode) {
651 checkStartCode();
652 checkEndCode();
653 checkOpcode(opcode, 0);
654 super.visitInsn(opcode);
655 ++insnCount;
656 }
657
658 @Override
659 public void visitIntInsn(final int opcode, final int operand) {
660 checkStartCode();
661 checkEndCode();
662 checkOpcode(opcode, 1);
663 switch (opcode) {
664 case Opcodes.BIPUSH:
665 checkSignedByte(operand, "Invalid operand");
666 break;
667 case Opcodes.SIPUSH:
668 checkSignedShort(operand, "Invalid operand");
669 break;
670 // case Constants.NEWARRAY:
671 default:
672 if (operand < Opcodes.T_BOOLEAN || operand > Opcodes.T_LONG) {
673 throw new IllegalArgumentException(
674 "Invalid operand (must be an array type code T_...): "
675 + operand);
676 }
677 }
678 super.visitIntInsn(opcode, operand);
679 ++insnCount;
680 }
681
682 @Override
683 public void visitVarInsn(final int opcode, final int var) {
684 checkStartCode();
685 checkEndCode();
686 checkOpcode(opcode, 2);
687 checkUnsignedShort(var, "Invalid variable index");
688 super.visitVarInsn(opcode, var);
689 ++insnCount;
690 }
691
692 @Override
693 public void visitTypeInsn(final int opcode, final String type) {
694 checkStartCode();
695 checkEndCode();
696 checkOpcode(opcode, 3);
697 checkInternalName(type, "type");
698 if (opcode == Opcodes.NEW && type.charAt(0) == '[') {
699 throw new IllegalArgumentException(
700 "NEW cannot be used to create arrays: " + type);
701 }
702 super.visitTypeInsn(opcode, type);
703 ++insnCount;
704 }
705
706 @Override
707 public void visitFieldInsn(final int opcode, final String owner,
708 final String name, final String desc) {
709 checkStartCode();
710 checkEndCode();
711 checkOpcode(opcode, 4);
712 checkInternalName(owner, "owner");
713 checkUnqualifiedName(version, name, "name");
714 checkDesc(desc, false);
715 super.visitFieldInsn(opcode, owner, name, desc);
716 ++insnCount;
717 }
718
719 @Deprecated
720 @Override
721 public void visitMethodInsn(int opcode, String owner, String name,
722 String desc) {
723 if (api >= Opcodes.ASM5) {
724 super.visitMethodInsn(opcode, owner, name, desc);
725 return;
726 }
727 doVisitMethodInsn(opcode, owner, name, desc,
728 opcode == Opcodes.INVOKEINTERFACE);
729 }
730
731 @Override
732 public void visitMethodInsn(int opcode, String owner, String name,
733 String desc, boolean itf) {
734 if (api < Opcodes.ASM5) {
735 super.visitMethodInsn(opcode, owner, name, desc, itf);
736 return;
737 }
738 doVisitMethodInsn(opcode, owner, name, desc, itf);
739 }
740
741 private void doVisitMethodInsn(int opcode, final String owner,
742 final String name, final String desc, final boolean itf) {
743 checkStartCode();
744 checkEndCode();
745 checkOpcode(opcode, 5);
746 if (opcode != Opcodes.INVOKESPECIAL || !"<init>".equals(name)) {
747 checkMethodIdentifier(version, name, "name");
748 }
749 checkInternalName(owner, "owner");
750 checkMethodDesc(desc);
751 if (opcode == Opcodes.INVOKEVIRTUAL && itf) {
752 throw new IllegalArgumentException(
753 "INVOKEVIRTUAL can't be used with interfaces");
754 }
755 if (opcode == Opcodes.INVOKEINTERFACE && !itf) {
756 throw new IllegalArgumentException(
757 "INVOKEINTERFACE can't be used with classes");
758 }
759 // Calling super.visitMethodInsn requires to call the correct version
760 // depending on this.api (otherwise infinite loops can occur). To
761 // simplify and to make it easier to automatically remove the backward
762 // compatibility code, we inline the code of the overridden method here.
763 if (mv != null) {
764 mv.visitMethodInsn(opcode, owner, name, desc, itf);
765 }
766 ++insnCount;
767 }
768
769 @Override
770 public void visitInvokeDynamicInsn(String name, String desc, Handle bsm,
771 Object... bsmArgs) {
772 checkStartCode();
773 checkEndCode();
774 checkMethodIdentifier(version, name, "name");
775 checkMethodDesc(desc);
776 if (bsm.getTag() != Opcodes.H_INVOKESTATIC
777 && bsm.getTag() != Opcodes.H_NEWINVOKESPECIAL) {
778 throw new IllegalArgumentException("invalid handle tag "
779 + bsm.getTag());
780 }
781 for (int i = 0; i < bsmArgs.length; i++) {
782 checkLDCConstant(bsmArgs[i]);
783 }
784 super.visitInvokeDynamicInsn(name, desc, bsm, bsmArgs);
785 ++insnCount;
786 }
787
788 @Override
789 public void visitJumpInsn(final int opcode, final Label label) {
790 checkStartCode();
791 checkEndCode();
792 checkOpcode(opcode, 6);
793 checkLabel(label, false, "label");
794 checkNonDebugLabel(label);
795 super.visitJumpInsn(opcode, label);
796 usedLabels.add(label);
797 ++insnCount;
798 }
799
800 @Override
801 public void visitLabel(final Label label) {
802 checkStartCode();
803 checkEndCode();
804 checkLabel(label, false, "label");
805 if (labels.get(label) != null) {
806 throw new IllegalArgumentException("Already visited label");
807 }
808 labels.put(label, insnCount);
809 super.visitLabel(label);
810 }
811
812 @Override
813 public void visitLdcInsn(final Object cst) {
814 checkStartCode();
815 checkEndCode();
816 checkLDCConstant(cst);
817 super.visitLdcInsn(cst);
818 ++insnCount;
819 }
820
821 @Override
822 public void visitIincInsn(final int var, final int increment) {
823 checkStartCode();
824 checkEndCode();
825 checkUnsignedShort(var, "Invalid variable index");
826 checkSignedShort(increment, "Invalid increment");
827 super.visitIincInsn(var, increment);
828 ++insnCount;
829 }
830
831 @Override
832 public void visitTableSwitchInsn(final int min, final int max,
833 final Label dflt, final Label... labels) {
834 checkStartCode();
835 checkEndCode();
836 if (max < min) {
837 throw new IllegalArgumentException("Max = " + max
838 + " must be greater than or equal to min = " + min);
839 }
840 checkLabel(dflt, false, "default label");
841 checkNonDebugLabel(dflt);
842 if (labels == null || labels.length != max - min + 1) {
843 throw new IllegalArgumentException(
844 "There must be max - min + 1 labels");
845 }
846 for (int i = 0; i < labels.length; ++i) {
847 checkLabel(labels[i], false, "label at index " + i);
848 checkNonDebugLabel(labels[i]);
849 }
850 super.visitTableSwitchInsn(min, max, dflt, labels);
851 for (int i = 0; i < labels.length; ++i) {
852 usedLabels.add(labels[i]);
853 }
854 ++insnCount;
855 }
856
857 @Override
858 public void visitLookupSwitchInsn(final Label dflt, final int[] keys,
859 final Label[] labels) {
860 checkEndCode();
861 checkStartCode();
862 checkLabel(dflt, false, "default label");
863 checkNonDebugLabel(dflt);
864 if (keys == null || labels == null || keys.length != labels.length) {
865 throw new IllegalArgumentException(
866 "There must be the same number of keys and labels");
867 }
868 for (int i = 0; i < labels.length; ++i) {
869 checkLabel(labels[i], false, "label at index " + i);
870 checkNonDebugLabel(labels[i]);
871 }
872 super.visitLookupSwitchInsn(dflt, keys, labels);
873 usedLabels.add(dflt);
874 for (int i = 0; i < labels.length; ++i) {
875 usedLabels.add(labels[i]);
876 }
877 ++insnCount;
878 }
879
880 @Override
881 public void visitMultiANewArrayInsn(final String desc, final int dims) {
882 checkStartCode();
883 checkEndCode();
884 checkDesc(desc, false);
885 if (desc.charAt(0) != '[') {
886 throw new IllegalArgumentException(
887 "Invalid descriptor (must be an array type descriptor): "
888 + desc);
889 }
890 if (dims < 1) {
891 throw new IllegalArgumentException(
892 "Invalid dimensions (must be greater than 0): " + dims);
893 }
894 if (dims > desc.lastIndexOf('[') + 1) {
895 throw new IllegalArgumentException(
896 "Invalid dimensions (must not be greater than dims(desc)): "
897 + dims);
898 }
899 super.visitMultiANewArrayInsn(desc, dims);
900 ++insnCount;
901 }
902
903 @Override
904 public AnnotationVisitor visitInsnAnnotation(final int typeRef,
905 final TypePath typePath, final String desc, final boolean visible) {
906 checkStartCode();
907 checkEndCode();
908 int sort = typeRef >>> 24;
909 if (sort != TypeReference.INSTANCEOF && sort != TypeReference.NEW
910 && sort != TypeReference.CONSTRUCTOR_REFERENCE
911 && sort != TypeReference.METHOD_REFERENCE
912 && sort != TypeReference.CAST
913 && sort != TypeReference.CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT
914 && sort != TypeReference.METHOD_INVOCATION_TYPE_ARGUMENT
915 && sort != TypeReference.CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT
916 && sort != TypeReference.METHOD_REFERENCE_TYPE_ARGUMENT) {
917 throw new IllegalArgumentException("Invalid type reference sort 0x"
918 + Integer.toHexString(sort));
919 }
920 CheckClassAdapter.checkTypeRefAndPath(typeRef, typePath);
921 CheckMethodAdapter.checkDesc(desc, false);
922 return new CheckAnnotationAdapter(super.visitInsnAnnotation(typeRef,
923 typePath, desc, visible));
924 }
925
926 @Override
927 public void visitTryCatchBlock(final Label start, final Label end,
928 final Label handler, final String type) {
929 checkStartCode();
930 checkEndCode();
931 checkLabel(start, false, "start label");
932 checkLabel(end, false, "end label");
933 checkLabel(handler, false, "handler label");
934 checkNonDebugLabel(start);
935 checkNonDebugLabel(end);
936 checkNonDebugLabel(handler);
937 if (labels.get(start) != null || labels.get(end) != null
938 || labels.get(handler) != null) {
939 throw new IllegalStateException(
940 "Try catch blocks must be visited before their labels");
941 }
942 if (type != null) {
943 checkInternalName(type, "type");
944 }
945 super.visitTryCatchBlock(start, end, handler, type);
946 handlers.add(start);
947 handlers.add(end);
948 }
949
950 @Override
951 public AnnotationVisitor visitTryCatchAnnotation(final int typeRef,
952 final TypePath typePath, final String desc, final boolean visible) {
953 checkStartCode();
954 checkEndCode();
955 int sort = typeRef >>> 24;
956 if (sort != TypeReference.EXCEPTION_PARAMETER) {
957 throw new IllegalArgumentException("Invalid type reference sort 0x"
958 + Integer.toHexString(sort));
959 }
960 CheckClassAdapter.checkTypeRefAndPath(typeRef, typePath);
961 CheckMethodAdapter.checkDesc(desc, false);
962 return new CheckAnnotationAdapter(super.visitTryCatchAnnotation(
963 typeRef, typePath, desc, visible));
964 }
965
966 @Override
967 public void visitLocalVariable(final String name, final String desc,
968 final String signature, final Label start, final Label end,
969 final int index) {
970 checkStartCode();
971 checkEndCode();
972 checkUnqualifiedName(version, name, "name");
973 checkDesc(desc, false);
974 checkLabel(start, true, "start label");
975 checkLabel(end, true, "end label");
976 checkUnsignedShort(index, "Invalid variable index");
977 int s = labels.get(start).intValue();
978 int e = labels.get(end).intValue();
979 if (e < s) {
980 throw new IllegalArgumentException(
981 "Invalid start and end labels (end must be greater than start)");
982 }
983 super.visitLocalVariable(name, desc, signature, start, end, index);
984 }
985
986 @Override
987 public AnnotationVisitor visitLocalVariableAnnotation(int typeRef,
988 TypePath typePath, Label[] start, Label[] end, int[] index,
989 String desc, boolean visible) {
990 checkStartCode();
991 checkEndCode();
992 int sort = typeRef >>> 24;
993 if (sort != TypeReference.LOCAL_VARIABLE
994 && sort != TypeReference.RESOURCE_VARIABLE) {
995 throw new IllegalArgumentException("Invalid type reference sort 0x"
996 + Integer.toHexString(sort));
997 }
998 CheckClassAdapter.checkTypeRefAndPath(typeRef, typePath);
999 checkDesc(desc, false);
1000 if (start == null || end == null || index == null
1001 || end.length != start.length || index.length != start.length) {
1002 throw new IllegalArgumentException(
1003 "Invalid start, end and index arrays (must be non null and of identical length");
1004 }
1005 for (int i = 0; i < start.length; ++i) {
1006 checkLabel(start[i], true, "start label");
1007 checkLabel(end[i], true, "end label");
1008 checkUnsignedShort(index[i], "Invalid variable index");
1009 int s = labels.get(start[i]).intValue();
1010 int e = labels.get(end[i]).intValue();
1011 if (e < s) {
1012 throw new IllegalArgumentException(
1013 "Invalid start and end labels (end must be greater than start)");
1014 }
1015 }
1016 return super.visitLocalVariableAnnotation(typeRef, typePath, start,
1017 end, index, desc, visible);
1018 }
1019
1020 @Override
1021 public void visitLineNumber(final int line, final Label start) {
1022 checkStartCode();
1023 checkEndCode();
1024 checkUnsignedShort(line, "Invalid line number");
1025 checkLabel(start, true, "start label");
1026 super.visitLineNumber(line, start);
1027 }
1028
1029 @Override
1030 public void visitMaxs(final int maxStack, final int maxLocals) {
1031 checkStartCode();
1032 checkEndCode();
1033 endCode = true;
1034 for (Label l : usedLabels) {
1035 if (labels.get(l) == null) {
1036 throw new IllegalStateException("Undefined label used");
1037 }
1038 }
1039 for (int i = 0; i < handlers.size();) {
1040 Integer start = labels.get(handlers.get(i++));
1041 Integer end = labels.get(handlers.get(i++));
1042 if (start == null || end == null) {
1043 throw new IllegalStateException(
1044 "Undefined try catch block labels");
1045 }
1046 if (end.intValue() <= start.intValue()) {
1047 throw new IllegalStateException(
1048 "Emty try catch block handler range");
1049 }
1050 }
1051 checkUnsignedShort(maxStack, "Invalid max stack");
1052 checkUnsignedShort(maxLocals, "Invalid max locals");
1053 super.visitMaxs(maxStack, maxLocals);
1054 }
1055
1056 @Override
1057 public void visitEnd() {
1058 checkEndMethod();
1059 endMethod = true;
1060 super.visitEnd();
1061 }
1062
1063 // -------------------------------------------------------------------------
1064
1065 /**
1066 * Checks that the visitCode method has been called.
1067 */
1068 void checkStartCode() {
1069 if (!startCode) {
1070 throw new IllegalStateException(
1071 "Cannot visit instructions before visitCode has been called.");
1072 }
1073 }
1074
1075 /**
1076 * Checks that the visitMaxs method has not been called.
1077 */
1078 void checkEndCode() {
1079 if (endCode) {
1080 throw new IllegalStateException(
1081 "Cannot visit instructions after visitMaxs has been called.");
1082 }
1083 }
1084
1085 /**
1086 * Checks that the visitEnd method has not been called.
1087 */
1088 void checkEndMethod() {
1089 if (endMethod) {
1090 throw new IllegalStateException(
1091 "Cannot visit elements after visitEnd has been called.");
1092 }
1093 }
1094
1095 /**
1096 * Checks a stack frame value.
1097 *
1098 * @param value
1099 * the value to be checked.
1100 */
1101 void checkFrameValue(final Object value) {
1102 if (value == Opcodes.TOP || value == Opcodes.INTEGER
1103 || value == Opcodes.FLOAT || value == Opcodes.LONG
1104 || value == Opcodes.DOUBLE || value == Opcodes.NULL
1105 || value == Opcodes.UNINITIALIZED_THIS) {
1106 return;
1107 }
1108 if (value instanceof String) {
1109 checkInternalName((String) value, "Invalid stack frame value");
1110 return;
1111 }
1112 if (!(value instanceof Label)) {
1113 throw new IllegalArgumentException("Invalid stack frame value: "
1114 + value);
1115 } else {
1116 usedLabels.add((Label) value);
1117 }
1118 }
1119
1120 /**
1121 * Checks that the type of the given opcode is equal to the given type.
1122 *
1123 * @param opcode
1124 * the opcode to be checked.
1125 * @param type
1126 * the expected opcode type.
1127 */
1128 static void checkOpcode(final int opcode, final int type) {
1129 if (opcode < 0 || opcode > 199 || TYPE[opcode] != type) {
1130 throw new IllegalArgumentException("Invalid opcode: " + opcode);
1131 }
1132 }
1133
1134 /**
1135 * Checks that the given value is a signed byte.
1136 *
1137 * @param value
1138 * the value to be checked.
1139 * @param msg
1140 * an message to be used in case of error.
1141 */
1142 static void checkSignedByte(final int value, final String msg) {
1143 if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE) {
1144 throw new IllegalArgumentException(msg
1145 + " (must be a signed byte): " + value);
1146 }
1147 }
1148
1149 /**
1150 * Checks that the given value is a signed short.
1151 *
1152 * @param value
1153 * the value to be checked.
1154 * @param msg
1155 * an message to be used in case of error.
1156 */
1157 static void checkSignedShort(final int value, final String msg) {
1158 if (value < Short.MIN_VALUE || value > Short.MAX_VALUE) {
1159 throw new IllegalArgumentException(msg
1160 + " (must be a signed short): " + value);
1161 }
1162 }
1163
1164 /**
1165 * Checks that the given value is an unsigned short.
1166 *
1167 * @param value
1168 * the value to be checked.
1169 * @param msg
1170 * an message to be used in case of error.
1171 */
1172 static void checkUnsignedShort(final int value, final String msg) {
1173 if (value < 0 || value > 65535) {
1174 throw new IllegalArgumentException(msg
1175 + " (must be an unsigned short): " + value);
1176 }
1177 }
1178
1179 /**
1180 * Checks that the given value is an {@link Integer}, a{@link Float}, a
1181 * {@link Long}, a {@link Double} or a {@link String}.
1182 *
1183 * @param cst
1184 * the value to be checked.
1185 */
1186 static void checkConstant(final Object cst) {
1187 if (!(cst instanceof Integer) && !(cst instanceof Float)
1188 && !(cst instanceof Long) && !(cst instanceof Double)
1189 && !(cst instanceof String)) {
1190 throw new IllegalArgumentException("Invalid constant: " + cst);
1191 }
1192 }
1193
1194 void checkLDCConstant(final Object cst) {
1195 if (cst instanceof Type) {
1196 int s = ((Type) cst).getSort();
1197 if (s != Type.OBJECT && s != Type.ARRAY && s != Type.METHOD) {
1198 throw new IllegalArgumentException("Illegal LDC constant value");
1199 }
1200 if (s != Type.METHOD && (version & 0xFFFF) < Opcodes.V1_5) {
1201 throw new IllegalArgumentException(
1202 "ldc of a constant class requires at least version 1.5");
1203 }
1204 if (s == Type.METHOD && (version & 0xFFFF) < Opcodes.V1_7) {
1205 throw new IllegalArgumentException(
1206 "ldc of a method type requires at least version 1.7");
1207 }
1208 } else if (cst instanceof Handle) {
1209 if ((version & 0xFFFF) < Opcodes.V1_7) {
1210 throw new IllegalArgumentException(
1211 "ldc of a handle requires at least version 1.7");
1212 }
1213 int tag = ((Handle) cst).getTag();
1214 if (tag < Opcodes.H_GETFIELD || tag > Opcodes.H_INVOKEINTERFACE) {
1215 throw new IllegalArgumentException("invalid handle tag " + tag);
1216 }
1217 } else {
1218 checkConstant(cst);
1219 }
1220 }
1221
1222 /**
1223 * Checks that the given string is a valid unqualified name.
1224 *
1225 * @param version
1226 * the class version.
1227 * @param name
1228 * the string to be checked.
1229 * @param msg
1230 * a message to be used in case of error.
1231 */
1232 static void checkUnqualifiedName(int version, final String name,
1233 final String msg) {
1234 if ((version & 0xFFFF) < Opcodes.V1_5) {
1235 checkIdentifier(name, msg);
1236 } else {
1237 for (int i = 0; i < name.length(); ++i) {
1238 if (".;[/".indexOf(name.charAt(i)) != -1) {
1239 throw new IllegalArgumentException("Invalid " + msg
1240 + " (must be a valid unqualified name): " + name);
1241 }
1242 }
1243 }
1244 }
1245
1246 /**
1247 * Checks that the given string is a valid Java identifier.
1248 *
1249 * @param name
1250 * the string to be checked.
1251 * @param msg
1252 * a message to be used in case of error.
1253 */
1254 static void checkIdentifier(final String name, final String msg) {
1255 checkIdentifier(name, 0, -1, msg);
1256 }
1257
1258 /**
1259 * Checks that the given substring is a valid Java identifier.
1260 *
1261 * @param name
1262 * the string to be checked.
1263 * @param start
1264 * index of the first character of the identifier (inclusive).
1265 * @param end
1266 * index of the last character of the identifier (exclusive). -1
1267 * is equivalent to <tt>name.length()</tt> if name is not
1268 * <tt>null</tt>.
1269 * @param msg
1270 * a message to be used in case of error.
1271 */
1272 static void checkIdentifier(final String name, final int start,
1273 final int end, final String msg) {
1274 if (name == null || (end == -1 ? name.length() <= start : end <= start)) {
1275 throw new IllegalArgumentException("Invalid " + msg
1276 + " (must not be null or empty)");
1277 }
1278 if (!Character.isJavaIdentifierStart(name.charAt(start))) {
1279 throw new IllegalArgumentException("Invalid " + msg
1280 + " (must be a valid Java identifier): " + name);
1281 }
1282 int max = end == -1 ? name.length() : end;
1283 for (int i = start + 1; i < max; ++i) {
1284 if (!Character.isJavaIdentifierPart(name.charAt(i))) {
1285 throw new IllegalArgumentException("Invalid " + msg
1286 + " (must be a valid Java identifier): " + name);
1287 }
1288 }
1289 }
1290
1291 /**
1292 * Checks that the given string is a valid Java identifier.
1293 *
1294 * @param version
1295 * the class version.
1296 * @param name
1297 * the string to be checked.
1298 * @param msg
1299 * a message to be used in case of error.
1300 */
1301 static void checkMethodIdentifier(int version, final String name,
1302 final String msg) {
1303 if (name == null || name.length() == 0) {
1304 throw new IllegalArgumentException("Invalid " + msg
1305 + " (must not be null or empty)");
1306 }
1307 if ((version & 0xFFFF) >= Opcodes.V1_5) {
1308 for (int i = 0; i < name.length(); ++i) {
1309 if (".;[/<>".indexOf(name.charAt(i)) != -1) {
1310 throw new IllegalArgumentException("Invalid " + msg
1311 + " (must be a valid unqualified name): " + name);
1312 }
1313 }
1314 return;
1315 }
1316 if (!Character.isJavaIdentifierStart(name.charAt(0))) {
1317 throw new IllegalArgumentException(
1318 "Invalid "
1319 + msg
1320 + " (must be a '<init>', '<clinit>' or a valid Java identifier): "
1321 + name);
1322 }
1323 for (int i = 1; i < name.length(); ++i) {
1324 if (!Character.isJavaIdentifierPart(name.charAt(i))) {
1325 throw new IllegalArgumentException(
1326 "Invalid "
1327 + msg
1328 + " (must be '<init>' or '<clinit>' or a valid Java identifier): "
1329 + name);
1330 }
1331 }
1332 }
1333
1334 /**
1335 * Checks that the given string is a valid internal class name.
1336 *
1337 * @param name
1338 * the string to be checked.
1339 * @param msg
1340 * a message to be used in case of error.
1341 */
1342 static void checkInternalName(final String name, final String msg) {
1343 if (name == null || name.length() == 0) {
1344 throw new IllegalArgumentException("Invalid " + msg
1345 + " (must not be null or empty)");
1346 }
1347 if (name.charAt(0) == '[') {
1348 checkDesc(name, false);
1349 } else {
1350 checkInternalName(name, 0, -1, msg);
1351 }
1352 }
1353
1354 /**
1355 * Checks that the given substring is a valid internal class name.
1356 *
1357 * @param name
1358 * the string to be checked.
1359 * @param start
1360 * index of the first character of the identifier (inclusive).
1361 * @param end
1362 * index of the last character of the identifier (exclusive). -1
1363 * is equivalent to <tt>name.length()</tt> if name is not
1364 * <tt>null</tt>.
1365 * @param msg
1366 * a message to be used in case of error.
1367 */
1368 static void checkInternalName(final String name, final int start,
1369 final int end, final String msg) {
1370 int max = end == -1 ? name.length() : end;
1371 try {
1372 int begin = start;
1373 int slash;
1374 do {
1375 slash = name.indexOf('/', begin + 1);
1376 if (slash == -1 || slash > max) {
1377 slash = max;
1378 }
1379 checkIdentifier(name, begin, slash, null);
1380 begin = slash + 1;
1381 } while (slash != max);
1382 } catch (IllegalArgumentException unused) {
1383 throw new IllegalArgumentException(
1384 "Invalid "
1385 + msg
1386 + " (must be a fully qualified class name in internal form): "
1387 + name);
1388 }
1389 }
1390
1391 /**
1392 * Checks that the given string is a valid type descriptor.
1393 *
1394 * @param desc
1395 * the string to be checked.
1396 * @param canBeVoid
1397 * <tt>true</tt> if <tt>V</tt> can be considered valid.
1398 */
1399 static void checkDesc(final String desc, final boolean canBeVoid) {
1400 int end = checkDesc(desc, 0, canBeVoid);
1401 if (end != desc.length()) {
1402 throw new IllegalArgumentException("Invalid descriptor: " + desc);
1403 }
1404 }
1405
1406 /**
1407 * Checks that a the given substring is a valid type descriptor.
1408 *
1409 * @param desc
1410 * the string to be checked.
1411 * @param start
1412 * index of the first character of the identifier (inclusive).
1413 * @param canBeVoid
1414 * <tt>true</tt> if <tt>V</tt> can be considered valid.
1415 * @return the index of the last character of the type decriptor, plus one.
1416 */
1417 static int checkDesc(final String desc, final int start,
1418 final boolean canBeVoid) {
1419 if (desc == null || start >= desc.length()) {
1420 throw new IllegalArgumentException(
1421 "Invalid type descriptor (must not be null or empty)");
1422 }
1423 int index;
1424 switch (desc.charAt(start)) {
1425 case 'V':
1426 if (canBeVoid) {
1427 return start + 1;
1428 } else {
1429 throw new IllegalArgumentException("Invalid descriptor: "
1430 + desc);
1431 }
1432 case 'Z':
1433 case 'C':
1434 case 'B':
1435 case 'S':
1436 case 'I':
1437 case 'F':
1438 case 'J':
1439 case 'D':
1440 return start + 1;
1441 case '[':
1442 index = start + 1;
1443 while (index < desc.length() && desc.charAt(index) == '[') {
1444 ++index;
1445 }
1446 if (index < desc.length()) {
1447 return checkDesc(desc, index, false);
1448 } else {
1449 throw new IllegalArgumentException("Invalid descriptor: "
1450 + desc);
1451 }
1452 case 'L':
1453 index = desc.indexOf(';', start);
1454 if (index == -1 || index - start < 2) {
1455 throw new IllegalArgumentException("Invalid descriptor: "
1456 + desc);
1457 }
1458 try {
1459 checkInternalName(desc, start + 1, index, null);
1460 } catch (IllegalArgumentException unused) {
1461 throw new IllegalArgumentException("Invalid descriptor: "
1462 + desc);
1463 }
1464 return index + 1;
1465 default:
1466 throw new IllegalArgumentException("Invalid descriptor: " + desc);
1467 }
1468 }
1469
1470 /**
1471 * Checks that the given string is a valid method descriptor.
1472 *
1473 * @param desc
1474 * the string to be checked.
1475 */
1476 static void checkMethodDesc(final String desc) {
1477 if (desc == null || desc.length() == 0) {
1478 throw new IllegalArgumentException(
1479 "Invalid method descriptor (must not be null or empty)");
1480 }
1481 if (desc.charAt(0) != '(' || desc.length() < 3) {
1482 throw new IllegalArgumentException("Invalid descriptor: " + desc);
1483 }
1484 int start = 1;
1485 if (desc.charAt(start) != ')') {
1486 do {
1487 if (desc.charAt(start) == 'V') {
1488 throw new IllegalArgumentException("Invalid descriptor: "
1489 + desc);
1490 }
1491 start = checkDesc(desc, start, false);
1492 } while (start < desc.length() && desc.charAt(start) != ')');
1493 }
1494 start = checkDesc(desc, start + 1, true);
1495 if (start != desc.length()) {
1496 throw new IllegalArgumentException("Invalid descriptor: " + desc);
1497 }
1498 }
1499
1500 /**
1501 * Checks that the given label is not null. This method can also check that
1502 * the label has been visited.
1503 *
1504 * @param label
1505 * the label to be checked.
1506 * @param checkVisited
1507 * <tt>true</tt> to check that the label has been visited.
1508 * @param msg
1509 * a message to be used in case of error.
1510 */
1511 void checkLabel(final Label label, final boolean checkVisited,
1512 final String msg) {
1513 if (label == null) {
1514 throw new IllegalArgumentException("Invalid " + msg
1515 + " (must not be null)");
1516 }
1517 if (checkVisited && labels.get(label) == null) {
1518 throw new IllegalArgumentException("Invalid " + msg
1519 + " (must be visited first)");
1520 }
1521 }
1522
1523 /**
1524 * Checks that the given label is not a label used only for debug purposes.
1525 *
1526 * @param label
1527 * the label to be checked.
1528 */
1529 private static void checkNonDebugLabel(final Label label) {
1530 Field f = getLabelStatusField();
1531 int status = 0;
1532 try {
1533 status = f == null ? 0 : ((Integer) f.get(label)).intValue();
1534 } catch (IllegalAccessException e) {
1535 throw new Error("Internal error");
1536 }
1537 if ((status & 0x01) != 0) {
1538 throw new IllegalArgumentException(
1539 "Labels used for debug info cannot be reused for control flow");
1540 }
1541 }
1542
1543 /**
1544 * Returns the Field object corresponding to the Label.status field.
1545 *
1546 * @return the Field object corresponding to the Label.status field.
1547 */
1548 private static Field getLabelStatusField() {
1549 if (labelStatusField == null) {
1550 labelStatusField = getLabelField("a");
1551 if (labelStatusField == null) {
1552 labelStatusField = getLabelField("status");
1553 }
1554 }
1555 return labelStatusField;
1556 }
1557
1558 /**
1559 * Returns the field of the Label class whose name is given.
1560 *
1561 * @param name
1562 * a field name.
1563 * @return the field of the Label class whose name is given, or null.
1564 */
1565 private static Field getLabelField(final String name) {
1566 try {
1567 Field f = Label.class.getDeclaredField(name);
1568 f.setAccessible(true);
1569 return f;
1570 } catch (NoSuchFieldException e) {
1571 return null;
1572 }
1573 }
1574 }