001// ASM: a very small and fast Java bytecode manipulation framework 002// Copyright (c) 2000-2011 INRIA, France Telecom 003// All rights reserved. 004// 005// Redistribution and use in source and binary forms, with or without 006// modification, are permitted provided that the following conditions 007// are met: 008// 1. Redistributions of source code must retain the above copyright 009// notice, this list of conditions and the following disclaimer. 010// 2. Redistributions in binary form must reproduce the above copyright 011// notice, this list of conditions and the following disclaimer in the 012// documentation and/or other materials provided with the distribution. 013// 3. Neither the name of the copyright holders nor the names of its 014// contributors may be used to endorse or promote products derived from 015// this software without specific prior written permission. 016// 017// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 018// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 019// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 020// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 021// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 022// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 023// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 024// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 025// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 026// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 027// THE POSSIBILITY OF SUCH DAMAGE. 028package org.springframework.asm; 029 030/** 031 * The JVM opcodes, access flags and array type codes. This interface does not define all the JVM 032 * opcodes because some opcodes are automatically handled. For example, the xLOAD and xSTORE opcodes 033 * are automatically replaced by xLOAD_n and xSTORE_n opcodes when possible. The xLOAD_n and 034 * xSTORE_n opcodes are therefore not defined in this interface. Likewise for LDC, automatically 035 * replaced by LDC_W or LDC2_W when necessary, WIDE, GOTO_W and JSR_W. 036 * 037 * @see <a href="https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-6.html">JVMS 6</a> 038 * @author Eric Bruneton 039 * @author Eugene Kuleshov 040 */ 041// DontCheck(InterfaceIsType): can't be fixed (for backward binary compatibility). 042public interface Opcodes { 043 044 // ASM API versions. 045 046 int ASM4 = 4 << 16 | 0 << 8; 047 int ASM5 = 5 << 16 | 0 << 8; 048 int ASM6 = 6 << 16 | 0 << 8; 049 int ASM7 = 7 << 16 | 0 << 8; 050 051 /** 052 * <i>Experimental, use at your own risk. This field will be renamed when it becomes stable, this 053 * will break existing code using it. Only code compiled with --enable-preview can use this.</i> 054 * 055 * @deprecated This API is experimental. 056 */ 057 @Deprecated int ASM8_EXPERIMENTAL = 1 << 24 | 8 << 16 | 0 << 8; 058 059 /* 060 * Internal flags used to redirect calls to deprecated methods. For instance, if a visitOldStuff 061 * method in API_OLD is deprecated and replaced with visitNewStuff in API_NEW, then the 062 * redirection should be done as follows: 063 * 064 * <pre> 065 * public class StuffVisitor { 066 * ... 067 * 068 * @Deprecated public void visitOldStuff(int arg, ...) { 069 * // SOURCE_DEPRECATED means "a call from a deprecated method using the old 'api' value". 070 * visitNewStuf(arg | (api < API_NEW ? SOURCE_DEPRECATED : 0), ...); 071 * } 072 * 073 * public void visitNewStuff(int argAndSource, ...) { 074 * if (api < API_NEW && (argAndSource & SOURCE_DEPRECATED) == 0) { 075 * visitOldStuff(argAndSource, ...); 076 * } else { 077 * int arg = argAndSource & ~SOURCE_MASK; 078 * [ do stuff ] 079 * } 080 * } 081 * } 082 * </pre> 083 * 084 * <p>If 'api' is equal to API_NEW, there are two cases: 085 * 086 * <ul> 087 * <li>call visitNewStuff: the redirection test is skipped and 'do stuff' is executed directly. 088 * <li>call visitOldSuff: the source is not set to SOURCE_DEPRECATED before calling 089 * visitNewStuff, but the redirection test is skipped anyway in visitNewStuff, which 090 * directly executes 'do stuff'. 091 * </ul> 092 * 093 * <p>If 'api' is equal to API_OLD, there are two cases: 094 * 095 * <ul> 096 * <li>call visitOldSuff: the source is set to SOURCE_DEPRECATED before calling visitNewStuff. 097 * Because of this visitNewStuff does not redirect back to visitOldStuff, and instead 098 * executes 'do stuff'. 099 * <li>call visitNewStuff: the call is redirected to visitOldStuff because the source is 0. 100 * visitOldStuff now sets the source to SOURCE_DEPRECATED and calls visitNewStuff back. This 101 * time visitNewStuff does not redirect the call, and instead executes 'do stuff'. 102 * </ul> 103 * 104 * <h1>User subclasses</h1> 105 * 106 * <p>If a user subclass overrides one of these methods, there are only two cases: either 'api' is 107 * API_OLD and visitOldStuff is overridden (and visitNewStuff is not), or 'api' is API_NEW or 108 * more, and visitNewStuff is overridden (and visitOldStuff is not). Any other case is a user 109 * programming error. 110 * 111 * <p>If 'api' is equal to API_NEW, the class hierarchy is equivalent to 112 * 113 * <pre> 114 * public class StuffVisitor { 115 * @Deprecated public void visitOldStuff(int arg, ...) { visitNewStuf(arg, ...); } 116 * public void visitNewStuff(int arg, ...) { [ do stuff ] } 117 * } 118 * class UserStuffVisitor extends StuffVisitor { 119 * @Override public void visitNewStuff(int arg, ...) { 120 * super.visitNewStuff(int arg, ...); // optional 121 * [ do user stuff ] 122 * } 123 * } 124 * </pre> 125 * 126 * <p>It is then obvious that whether visitNewStuff or visitOldStuff is called, 'do stuff' and 'do 127 * user stuff' will be executed, in this order. 128 * 129 * <p>If 'api' is equal to API_OLD, the class hierarchy is equivalent to 130 * 131 * <pre> 132 * public class StuffVisitor { 133 * @Deprecated public void visitOldStuff(int arg, ...) { 134 * visitNewStuf(arg | SOURCE_DEPRECATED, ...); 135 * } 136 * public void visitNewStuff(int argAndSource...) { 137 * if ((argAndSource & SOURCE_DEPRECATED) == 0) { 138 * visitOldStuff(argAndSource, ...); 139 * } else { 140 * int arg = argAndSource & ~SOURCE_MASK; 141 * [ do stuff ] 142 * } 143 * } 144 * } 145 * class UserStuffVisitor extends StuffVisitor { 146 * @Override public void visitOldStuff(int arg, ...) { 147 * super.visitOldStuff(int arg, ...); // optional 148 * [ do user stuff ] 149 * } 150 * } 151 * </pre> 152 * 153 * <p>and there are two cases: 154 * 155 * <ul> 156 * <li>call visitOldSuff: in the call to super.visitOldStuff, the source is set to 157 * SOURCE_DEPRECATED and visitNewStuff is called. Here 'do stuff' is run because the source 158 * was previously set to SOURCE_DEPRECATED, and execution eventually returns to 159 * UserStuffVisitor.visitOldStuff, where 'do user stuff' is run. 160 * <li>call visitNewStuff: the call is redirected to UserStuffVisitor.visitOldStuff because the 161 * source is 0. Execution continues as in the previous case, resulting in 'do stuff' and 'do 162 * user stuff' being executed, in this order. 163 * </ul> 164 * 165 * <h1>ASM subclasses</h1> 166 * 167 * <p>In ASM packages, subclasses of StuffVisitor can typically be sub classed again by the user, 168 * and can be used with API_OLD or API_NEW. Because of this, if such a subclass must override 169 * visitNewStuff, it must do so in the following way (and must not override visitOldStuff): 170 * 171 * <pre> 172 * public class AsmStuffVisitor extends StuffVisitor { 173 * @Override public void visitNewStuff(int argAndSource, ...) { 174 * if (api < API_NEW && (argAndSource & SOURCE_DEPRECATED) == 0) { 175 * super.visitNewStuff(argAndSource, ...); 176 * return; 177 * } 178 * super.visitNewStuff(argAndSource, ...); // optional 179 * int arg = argAndSource & ~SOURCE_MASK; 180 * [ do other stuff ] 181 * } 182 * } 183 * </pre> 184 * 185 * <p>If a user class extends this with 'api' equal to API_NEW, the class hierarchy is equivalent 186 * to 187 * 188 * <pre> 189 * public class StuffVisitor { 190 * @Deprecated public void visitOldStuff(int arg, ...) { visitNewStuf(arg, ...); } 191 * public void visitNewStuff(int arg, ...) { [ do stuff ] } 192 * } 193 * public class AsmStuffVisitor extends StuffVisitor { 194 * @Override public void visitNewStuff(int arg, ...) { 195 * super.visitNewStuff(arg, ...); 196 * [ do other stuff ] 197 * } 198 * } 199 * class UserStuffVisitor extends StuffVisitor { 200 * @Override public void visitNewStuff(int arg, ...) { 201 * super.visitNewStuff(int arg, ...); 202 * [ do user stuff ] 203 * } 204 * } 205 * </pre> 206 * 207 * <p>It is then obvious that whether visitNewStuff or visitOldStuff is called, 'do stuff', 'do 208 * other stuff' and 'do user stuff' will be executed, in this order. If, on the other hand, a user 209 * class extends AsmStuffVisitor with 'api' equal to API_OLD, the class hierarchy is equivalent to 210 * 211 * <pre> 212 * public class StuffVisitor { 213 * @Deprecated public void visitOldStuff(int arg, ...) { 214 * visitNewStuf(arg | SOURCE_DEPRECATED, ...); 215 * } 216 * public void visitNewStuff(int argAndSource, ...) { 217 * if ((argAndSource & SOURCE_DEPRECATED) == 0) { 218 * visitOldStuff(argAndSource, ...); 219 * } else { 220 * int arg = argAndSource & ~SOURCE_MASK; 221 * [ do stuff ] 222 * } 223 * } 224 * } 225 * public class AsmStuffVisitor extends StuffVisitor { 226 * @Override public void visitNewStuff(int argAndSource, ...) { 227 * if ((argAndSource & SOURCE_DEPRECATED) == 0) { 228 * super.visitNewStuff(argAndSource, ...); 229 * return; 230 * } 231 * super.visitNewStuff(argAndSource, ...); // optional 232 * int arg = argAndSource & ~SOURCE_MASK; 233 * [ do other stuff ] 234 * } 235 * } 236 * class UserStuffVisitor extends StuffVisitor { 237 * @Override public void visitOldStuff(int arg, ...) { 238 * super.visitOldStuff(arg, ...); 239 * [ do user stuff ] 240 * } 241 * } 242 * </pre> 243 * 244 * <p>and, here again, whether visitNewStuff or visitOldStuff is called, 'do stuff', 'do other 245 * stuff' and 'do user stuff' will be executed, in this order (exercise left to the reader). 246 * 247 * <h1>Notes</h1> 248 * 249 * <ul> 250 * <li>the SOURCE_DEPRECATED flag is set only if 'api' is API_OLD, just before calling 251 * visitNewStuff. By hypothesis, this method is not overridden by the user. Therefore, user 252 * classes can never see this flag. Only ASM subclasses must take care of extracting the 253 * actual argument value by clearing the source flags. 254 * <li>because the SOURCE_DEPRECATED flag is immediately cleared in the caller, the caller can 255 * call visitOldStuff or visitNewStuff (in 'do stuff' and 'do user stuff') on a delegate 256 * visitor without any risks (breaking the redirection logic, "leaking" the flag, etc). 257 * <li>all the scenarios discussed above are unit tested in MethodVisitorTest. 258 * </ul> 259 */ 260 261 int SOURCE_DEPRECATED = 0x100; 262 int SOURCE_MASK = SOURCE_DEPRECATED; 263 264 // Java ClassFile versions (the minor version is stored in the 16 most significant bits, and the 265 // major version in the 16 least significant bits). 266 267 int V1_1 = 3 << 16 | 45; 268 int V1_2 = 0 << 16 | 46; 269 int V1_3 = 0 << 16 | 47; 270 int V1_4 = 0 << 16 | 48; 271 int V1_5 = 0 << 16 | 49; 272 int V1_6 = 0 << 16 | 50; 273 int V1_7 = 0 << 16 | 51; 274 int V1_8 = 0 << 16 | 52; 275 int V9 = 0 << 16 | 53; 276 int V10 = 0 << 16 | 54; 277 int V11 = 0 << 16 | 55; 278 int V12 = 0 << 16 | 56; 279 int V13 = 0 << 16 | 57; 280 int V14 = 0 << 16 | 58; 281 int V15 = 0 << 16 | 59; 282 283 /** 284 * Version flag indicating that the class is using 'preview' features. 285 * 286 * <p>{@code version & V_PREVIEW == V_PREVIEW} tests if a version is flagged with {@code 287 * V_PREVIEW}. 288 */ 289 int V_PREVIEW = 0xFFFF0000; 290 291 // Access flags values, defined in 292 // - https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-4.html#jvms-4.1-200-E.1 293 // - https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-4.html#jvms-4.5-200-A.1 294 // - https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-4.html#jvms-4.6-200-A.1 295 // - https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-4.html#jvms-4.7.25 296 297 int ACC_PUBLIC = 0x0001; // class, field, method 298 int ACC_PRIVATE = 0x0002; // class, field, method 299 int ACC_PROTECTED = 0x0004; // class, field, method 300 int ACC_STATIC = 0x0008; // field, method 301 int ACC_FINAL = 0x0010; // class, field, method, parameter 302 int ACC_SUPER = 0x0020; // class 303 int ACC_SYNCHRONIZED = 0x0020; // method 304 int ACC_OPEN = 0x0020; // module 305 int ACC_TRANSITIVE = 0x0020; // module requires 306 int ACC_VOLATILE = 0x0040; // field 307 int ACC_BRIDGE = 0x0040; // method 308 int ACC_STATIC_PHASE = 0x0040; // module requires 309 int ACC_VARARGS = 0x0080; // method 310 int ACC_TRANSIENT = 0x0080; // field 311 int ACC_NATIVE = 0x0100; // method 312 int ACC_INTERFACE = 0x0200; // class 313 int ACC_ABSTRACT = 0x0400; // class, method 314 int ACC_STRICT = 0x0800; // method 315 int ACC_SYNTHETIC = 0x1000; // class, field, method, parameter, module * 316 int ACC_ANNOTATION = 0x2000; // class 317 int ACC_ENUM = 0x4000; // class(?) field inner 318 int ACC_MANDATED = 0x8000; // field, method, parameter, module, module * 319 int ACC_MODULE = 0x8000; // class 320 321 // ASM specific access flags. 322 // WARNING: the 16 least significant bits must NOT be used, to avoid conflicts with standard 323 // access flags, and also to make sure that these flags are automatically filtered out when 324 // written in class files (because access flags are stored using 16 bits only). 325 326 int ACC_DEPRECATED = 0x20000; // class, field, method 327 328 // Possible values for the type operand of the NEWARRAY instruction. 329 // See https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-6.html#jvms-6.5.newarray. 330 331 int T_BOOLEAN = 4; 332 int T_CHAR = 5; 333 int T_FLOAT = 6; 334 int T_DOUBLE = 7; 335 int T_BYTE = 8; 336 int T_SHORT = 9; 337 int T_INT = 10; 338 int T_LONG = 11; 339 340 // Possible values for the reference_kind field of CONSTANT_MethodHandle_info structures. 341 // See https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-4.html#jvms-4.4.8. 342 343 int H_GETFIELD = 1; 344 int H_GETSTATIC = 2; 345 int H_PUTFIELD = 3; 346 int H_PUTSTATIC = 4; 347 int H_INVOKEVIRTUAL = 5; 348 int H_INVOKESTATIC = 6; 349 int H_INVOKESPECIAL = 7; 350 int H_NEWINVOKESPECIAL = 8; 351 int H_INVOKEINTERFACE = 9; 352 353 // ASM specific stack map frame types, used in {@link ClassVisitor#visitFrame}. 354 355 /** An expanded frame. See {@link ClassReader#EXPAND_FRAMES}. */ 356 int F_NEW = -1; 357 358 /** A compressed frame with complete frame data. */ 359 int F_FULL = 0; 360 361 /** 362 * A compressed frame where locals are the same as the locals in the previous frame, except that 363 * additional 1-3 locals are defined, and with an empty stack. 364 */ 365 int F_APPEND = 1; 366 367 /** 368 * A compressed frame where locals are the same as the locals in the previous frame, except that 369 * the last 1-3 locals are absent and with an empty stack. 370 */ 371 int F_CHOP = 2; 372 373 /** 374 * A compressed frame with exactly the same locals as the previous frame and with an empty stack. 375 */ 376 int F_SAME = 3; 377 378 /** 379 * A compressed frame with exactly the same locals as the previous frame and with a single value 380 * on the stack. 381 */ 382 int F_SAME1 = 4; 383 384 // Standard stack map frame element types, used in {@link ClassVisitor#visitFrame}. 385 386 Integer TOP = Frame.ITEM_TOP; 387 Integer INTEGER = Frame.ITEM_INTEGER; 388 Integer FLOAT = Frame.ITEM_FLOAT; 389 Integer DOUBLE = Frame.ITEM_DOUBLE; 390 Integer LONG = Frame.ITEM_LONG; 391 Integer NULL = Frame.ITEM_NULL; 392 Integer UNINITIALIZED_THIS = Frame.ITEM_UNINITIALIZED_THIS; 393 394 // The JVM opcode values (with the MethodVisitor method name used to visit them in comment, and 395 // where '-' means 'same method name as on the previous line'). 396 // See https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-6.html. 397 398 int NOP = 0; // visitInsn 399 int ACONST_NULL = 1; // - 400 int ICONST_M1 = 2; // - 401 int ICONST_0 = 3; // - 402 int ICONST_1 = 4; // - 403 int ICONST_2 = 5; // - 404 int ICONST_3 = 6; // - 405 int ICONST_4 = 7; // - 406 int ICONST_5 = 8; // - 407 int LCONST_0 = 9; // - 408 int LCONST_1 = 10; // - 409 int FCONST_0 = 11; // - 410 int FCONST_1 = 12; // - 411 int FCONST_2 = 13; // - 412 int DCONST_0 = 14; // - 413 int DCONST_1 = 15; // - 414 int BIPUSH = 16; // visitIntInsn 415 int SIPUSH = 17; // - 416 int LDC = 18; // visitLdcInsn 417 int ILOAD = 21; // visitVarInsn 418 int LLOAD = 22; // - 419 int FLOAD = 23; // - 420 int DLOAD = 24; // - 421 int ALOAD = 25; // - 422 int IALOAD = 46; // visitInsn 423 int LALOAD = 47; // - 424 int FALOAD = 48; // - 425 int DALOAD = 49; // - 426 int AALOAD = 50; // - 427 int BALOAD = 51; // - 428 int CALOAD = 52; // - 429 int SALOAD = 53; // - 430 int ISTORE = 54; // visitVarInsn 431 int LSTORE = 55; // - 432 int FSTORE = 56; // - 433 int DSTORE = 57; // - 434 int ASTORE = 58; // - 435 int IASTORE = 79; // visitInsn 436 int LASTORE = 80; // - 437 int FASTORE = 81; // - 438 int DASTORE = 82; // - 439 int AASTORE = 83; // - 440 int BASTORE = 84; // - 441 int CASTORE = 85; // - 442 int SASTORE = 86; // - 443 int POP = 87; // - 444 int POP2 = 88; // - 445 int DUP = 89; // - 446 int DUP_X1 = 90; // - 447 int DUP_X2 = 91; // - 448 int DUP2 = 92; // - 449 int DUP2_X1 = 93; // - 450 int DUP2_X2 = 94; // - 451 int SWAP = 95; // - 452 int IADD = 96; // - 453 int LADD = 97; // - 454 int FADD = 98; // - 455 int DADD = 99; // - 456 int ISUB = 100; // - 457 int LSUB = 101; // - 458 int FSUB = 102; // - 459 int DSUB = 103; // - 460 int IMUL = 104; // - 461 int LMUL = 105; // - 462 int FMUL = 106; // - 463 int DMUL = 107; // - 464 int IDIV = 108; // - 465 int LDIV = 109; // - 466 int FDIV = 110; // - 467 int DDIV = 111; // - 468 int IREM = 112; // - 469 int LREM = 113; // - 470 int FREM = 114; // - 471 int DREM = 115; // - 472 int INEG = 116; // - 473 int LNEG = 117; // - 474 int FNEG = 118; // - 475 int DNEG = 119; // - 476 int ISHL = 120; // - 477 int LSHL = 121; // - 478 int ISHR = 122; // - 479 int LSHR = 123; // - 480 int IUSHR = 124; // - 481 int LUSHR = 125; // - 482 int IAND = 126; // - 483 int LAND = 127; // - 484 int IOR = 128; // - 485 int LOR = 129; // - 486 int IXOR = 130; // - 487 int LXOR = 131; // - 488 int IINC = 132; // visitIincInsn 489 int I2L = 133; // visitInsn 490 int I2F = 134; // - 491 int I2D = 135; // - 492 int L2I = 136; // - 493 int L2F = 137; // - 494 int L2D = 138; // - 495 int F2I = 139; // - 496 int F2L = 140; // - 497 int F2D = 141; // - 498 int D2I = 142; // - 499 int D2L = 143; // - 500 int D2F = 144; // - 501 int I2B = 145; // - 502 int I2C = 146; // - 503 int I2S = 147; // - 504 int LCMP = 148; // - 505 int FCMPL = 149; // - 506 int FCMPG = 150; // - 507 int DCMPL = 151; // - 508 int DCMPG = 152; // - 509 int IFEQ = 153; // visitJumpInsn 510 int IFNE = 154; // - 511 int IFLT = 155; // - 512 int IFGE = 156; // - 513 int IFGT = 157; // - 514 int IFLE = 158; // - 515 int IF_ICMPEQ = 159; // - 516 int IF_ICMPNE = 160; // - 517 int IF_ICMPLT = 161; // - 518 int IF_ICMPGE = 162; // - 519 int IF_ICMPGT = 163; // - 520 int IF_ICMPLE = 164; // - 521 int IF_ACMPEQ = 165; // - 522 int IF_ACMPNE = 166; // - 523 int GOTO = 167; // - 524 int JSR = 168; // - 525 int RET = 169; // visitVarInsn 526 int TABLESWITCH = 170; // visiTableSwitchInsn 527 int LOOKUPSWITCH = 171; // visitLookupSwitch 528 int IRETURN = 172; // visitInsn 529 int LRETURN = 173; // - 530 int FRETURN = 174; // - 531 int DRETURN = 175; // - 532 int ARETURN = 176; // - 533 int RETURN = 177; // - 534 int GETSTATIC = 178; // visitFieldInsn 535 int PUTSTATIC = 179; // - 536 int GETFIELD = 180; // - 537 int PUTFIELD = 181; // - 538 int INVOKEVIRTUAL = 182; // visitMethodInsn 539 int INVOKESPECIAL = 183; // - 540 int INVOKESTATIC = 184; // - 541 int INVOKEINTERFACE = 185; // - 542 int INVOKEDYNAMIC = 186; // visitInvokeDynamicInsn 543 int NEW = 187; // visitTypeInsn 544 int NEWARRAY = 188; // visitIntInsn 545 int ANEWARRAY = 189; // visitTypeInsn 546 int ARRAYLENGTH = 190; // visitInsn 547 int ATHROW = 191; // - 548 int CHECKCAST = 192; // visitTypeInsn 549 int INSTANCEOF = 193; // - 550 int MONITORENTER = 194; // visitInsn 551 int MONITOREXIT = 195; // - 552 int MULTIANEWARRAY = 197; // visitMultiANewArrayInsn 553 int IFNULL = 198; // visitJumpInsn 554 int IFNONNULL = 199; // - 555}