1 package com.atlassian.plugin.osgi.util;
2
3 /**
4 * Copied from the bndlib version 0.255, no changes, but necessary due to package-private fields
5 */
6 public class OpCodes {
7 final static short nop = 0x00; // [No change] performs
8 // no
9 // operation
10 final static short aconst_null = 0x01; // ? null pushes a null
11 // reference onto the stack
12 final static short iconst_m1 = 0x02; // ? -1 loads the int
13 // value -1
14 // onto the stack
15 final static short iconst_0 = 0x03; // ? 0 loads the int
16 // value 0
17 // onto the stack
18 final static short iconst_1 = 0x04; // ? 1 loads the int
19 // value 1
20 // onto the stack
21 final static short iconst_2 = 0x05; // ? 2 loads the int
22 // value 2
23 // onto the stack
24 final static short iconst_3 = 0x06; // ? 3 loads the int
25 // value 3
26 // onto the stack
27 final static short iconst_4 = 0x07; // ? 4 loads the int
28 // value 4
29 // onto the stack
30 final static short iconst_5 = 0x08; // ? 5 loads the int
31 // value 5
32 // onto the stack
33 final static short lconst_0 = 0x09; // ? 0L pushes the long
34 // 0 onto
35 // the stack
36 final static short bipush = 0x10; // byte ? value pushes a
37 // byte
38 // onto the stack as an integer
39 // value
40 final static short sipush = 0x11; // byte1, byte2 ? value
41 // pushes a
42 // signed integer (byte1 << 8 +
43 // byte2) onto the stack
44 final static short ldc = 0x12; // index ? value pushes
45 // a
46 // constant #index from a
47 // constant pool (String, int,
48 // float or class type) onto the
49 // stack
50 final static short ldc_w = 0x13; // indexbyte1,
51 // indexbyte2 ?
52 // value pushes a constant
53 // #index from a constant pool
54 // (String, int, float or class
55 // type) onto the stack (wide
56 // index is constructed as
57 // indexbyte1 << 8 + indexbyte2)
58 final static short ldc2_w = 0x14; // indexbyte1,
59 // indexbyte2 ?
60 // value pushes a constant
61 // #index from a constant pool
62 // (double or long) onto the
63 // stack (wide index is
64 // constructed as indexbyte1 <<
65 // 8 + indexbyte2)
66 final static short iload = 0x15; // index ? value loads
67 // an int
68 // value from a variable #index
69 final static short lload = 0x16; // index ? value load a
70 // long
71 // value from a local variable
72 // #index
73 final static short fload = 0x17; // index ? value loads a
74 // float
75 // value from a local variable
76 // #index
77 final static short dload = 0x18; // index ? value loads a
78 // double
79 // value from a local variable
80 // #index
81 final static short aload = 0x19; // index ? objectref
82 // loads a
83 // reference onto the stack from
84 // a local variable #index
85 final static short lload_2 = 0x20; // ? value load a long
86 // value
87 // from a local variable 2
88 final static short lload_3 = 0x21; // ? value load a long
89 // value
90 // from a local variable 3
91 final static short fload_0 = 0x22; // ? value loads a float
92 // value
93 // from local variable 0
94 final static short fload_1 = 0x23; // ? value loads a float
95 // value
96 // from local variable 1
97 final static short fload_2 = 0x24; // ? value loads a float
98 // value
99 // from local variable 2
100 final static short fload_3 = 0x25; // ? value loads a float
101 // value
102 // from local variable 3
103 final static short dload_0 = 0x26; // ? value loads a
104 // double from
105 // local variable 0
106 final static short dload_1 = 0x27; // ? value loads a
107 // double from
108 // local variable 1
109 final static short dload_2 = 0x28; // ? value loads a
110 // double from
111 // local variable 2
112 final static short dload_3 = 0x29; // ? value loads a
113 // double from
114 // local variable 3
115 final static short faload = 0x30; // arrayref, index ?
116 // value loads
117 // a float from an array
118 final static short daload = 0x31; // arrayref, index ?
119 // value loads
120 // a double from an array
121 final static short aaload = 0x32; // arrayref, index ?
122 // value loads
123 // onto the stack a reference
124 // from an array
125 final static short baload = 0x33; // arrayref, index ?
126 // value loads
127 // a byte or Boolean value from
128 // an array
129 final static short caload = 0x34; // arrayref, index ?
130 // value loads
131 // a char from an array
132 final static short saload = 0x35; // arrayref, index ?
133 // value load
134 // short from array
135 final static short istore = 0x36; // index value ? store
136 // int value
137 // into variable #index
138 final static short lstore = 0x37; // index value ? store a
139 // long
140 // value in a local variable
141 // #index
142 final static short fstore = 0x38; // index value ? stores
143 // a float
144 // value into a local variable
145 // #index
146 final static short dstore = 0x39; // index value ? stores
147 // a double
148 // value into a local variable
149 // #index
150 final static short lstore_1 = 0x40; // value ? store a long
151 // value in
152 // a local variable 1
153 final static short lstore_2 = 0x41; // value ? store a long
154 // value in
155 // a local variable 2
156 final static short lstore_3 = 0x42; // value ? store a long
157 // value in
158 // a local variable 3
159 final static short fstore_0 = 0x43; // value ? stores a
160 // float value
161 // into local variable 0
162 final static short fstore_1 = 0x44; // value ? stores a
163 // float value
164 // into local variable 1
165 final static short fstore_2 = 0x45; // value ? stores a
166 // float value
167 // into local variable 2
168 final static short fstore_3 = 0x46; // value ? stores a
169 // float value
170 // into local variable 3
171 final static short dstore_0 = 0x47; // value ? stores a
172 // double into
173 // local variable 0
174 final static short dstore_1 = 0x48; // value ? stores a
175 // double into
176 // local variable 1
177 final static short dstore_2 = 0x49; // value ? stores a
178 // double into
179 // local variable 2
180 final static short lastore = 0x50; // arrayref, index,
181 // value ?
182 // store a long to an array
183 final static short fastore = 0x51; // arreyref, index,
184 // value ?
185 // stores a float in an array
186 final static short dastore = 0x52; // arrayref, index,
187 // value ?
188 // stores a double into an array
189 final static short aastore = 0x53; // arrayref, index,
190 // value ?
191 // stores into a reference to an
192 // array
193 final static short bastore = 0x54; // arrayref, index,
194 // value ?
195 // stores a byte or Boolean
196 // value into an array
197 final static short castore = 0x55; // arrayref, index,
198 // value ?
199 // stores a char into an array
200 final static short sastore = 0x56; // arrayref, index,
201 // value ?
202 // store short to array
203 final static short pop = 0x57; // value ? discards the
204 // top
205 // value on the stack
206 final static short pop2 = 0x58; // {value2, value1} ?
207 // discards
208 // the top two values on the
209 // stack (or one value, if it is
210 // a double or long)
211 final static short dup = 0x59; // value ? value, value
212 // duplicates the value on top
213 // of the stack
214 final static short iadd = 0x60; // value1, value2 ?
215 // result adds
216 // two ints together
217 final static short ladd = 0x61; // value1, value2 ?
218 // result add
219 // two longs
220 final static short fadd = 0x62; // value1, value2 ?
221 // result adds
222 // two floats
223 final static short dadd = 0x63; // value1, value2 ?
224 // result adds
225 // two doubles
226 final static short isub = 0x64; // value1, value2 ?
227 // result int
228 // subtract
229 final static short lsub = 0x65; // value1, value2 ?
230 // result
231 // subtract two longs
232 final static short fsub = 0x66; // value1, value2 ?
233 // result
234 // subtracts two floats
235 final static short dsub = 0x67; // value1, value2 ?
236 // result
237 // subtracts a double from
238 // another
239 final static short imul = 0x68; // value1, value2 ?
240 // result
241 // multiply two integers
242 final static short lmul = 0x69; // value1, value2 ?
243 // result
244 // multiplies two longs
245 final static short irem = 0x70; // value1, value2 ?
246 // result
247 // logical int remainder
248 final static short lrem = 0x71; // value1, value2 ?
249 // result
250 // remainder of division of two
251 // longs
252 final static short frem = 0x72; // value1, value2 ?
253 // result gets
254 // the remainder from a division
255 // between two floats
256 final static short drem = 0x73; // value1, value2 ?
257 // result gets
258 // the remainder from a division
259 // between two doubles
260 final static short ineg = 0x74; // value ? result negate
261 // int
262 final static short lneg = 0x75; // value ? result
263 // negates a long
264 final static short fneg = 0x76; // value ? result
265 // negates a
266 // float
267 final static short dneg = 0x77; // value ? result
268 // negates a
269 // double
270 final static short ishl = 0x78; // value1, value2 ?
271 // result int
272 // shift left
273 final static short lshl = 0x79; // value1, value2 ?
274 // result
275 // bitwise shift left of a long
276 // value1 by value2 positions
277 final static short ior = 0x80; // value1, value2 ?
278 // result
279 // logical int or
280 final static short lor = 0x81; // value1, value2 ?
281 // result
282 // bitwise or of two longs
283 final static short ixor = 0x82; // value1, value2 ?
284 // result int
285 // xor
286 final static short lxor = 0x83; // value1, value2 ?
287 // result
288 // bitwise exclusive or of two
289 // longs
290 final static short iinc = 0x84; // index, const [No
291 // change]
292 // increment local variable
293 // #index by signed byte const
294 final static short i2l = 0x85; // value ? result
295 // converts an
296 // int into a long
297 final static short i2f = 0x86; // value ? result
298 // converts an
299 // int into a float
300 final static short i2d = 0x87; // value ? result
301 // converts an
302 // int into a double
303 final static short l2i = 0x88; // value ? result
304 // converts a
305 // long to an int
306 final static short l2f = 0x89; // value ? result
307 // converts a
308 // long to a float
309 final static short d2f = 0x90; // value ? result
310 // converts a
311 // double to a float
312 final static short i2b = 0x91; // value ? result
313 // converts an
314 // int into a byte
315 final static short i2c = 0x92; // value ? result
316 // converts an
317 // int into a character
318 final static short i2s = 0x93; // value ? result
319 // converts an
320 // int into a short
321 final static short lcmp = 0x94; // value1, value2 ?
322 // result
323 // compares two longs values
324 final static short fcmpl = 0x95; // value1, value2 ?
325 // result
326 // compares two floats
327 final static short fcmpg = 0x96; // value1, value2 ?
328 // result
329 // compares two floats
330 final static short dcmpl = 0x97; // value1, value2 ?
331 // result
332 // compares two doubles
333 final static short dcmpg = 0x98; // value1, value2 ?
334 // result
335 // compares two doubles
336 final static short ifeq = 0x99; // branchbyte1,
337 // branchbyte2
338 // value ? if value is 0, branch
339 // to instruction at
340 // branchoffset (signed short
341 // constructed from unsigned
342 // bytes branchbyte1 << 8 +
343 // branchbyte2)
344 final static short lconst_1 = 0x0a; // ? 1L pushes the long
345 // 1 onto
346 // the stack
347 final static short fconst_0 = 0x0b; // ? 0.0f pushes 0.0f on
348 // the
349 // stack
350 final static short fconst_1 = 0x0c; // ? 1.0f pushes 1.0f on
351 // the
352 // stack
353 final static short fconst_2 = 0x0d; // ? 2.0f pushes 2.0f on
354 // the
355 // stack
356 final static short dconst_0 = 0x0e; // ? 0.0 pushes the
357 // constant 0.0
358 // onto the stack
359 final static short dconst_1 = 0x0f; // ? 1.0 pushes the
360 // constant 1.0
361 // onto the stack
362 final static short iload_0 = 0x1a; // ? value loads an int
363 // value
364 // from variable 0
365 final static short iload_1 = 0x1b; // ? value loads an int
366 // value
367 // from variable 1
368 final static short iload_2 = 0x1c; // ? value loads an int
369 // value
370 // from variable 2
371 final static short iload_3 = 0x1d; // ? value loads an int
372 // value
373 // from variable 3
374 final static short lload_0 = 0x1e; // ? value load a long
375 // value
376 // from a local variable 0
377 final static short lload_1 = 0x1f; // ? value load a long
378 // value
379 // from a local variable 1
380 final static short aload_0 = 0x2a; // ? objectref loads a
381 // reference
382 // onto the stack from local
383 // variable 0
384 final static short aload_1 = 0x2b; // ? objectref loads a
385 // reference
386 // onto the stack from local
387 // variable 1
388 final static short aload_2 = 0x2c; // ? objectref loads a
389 // reference
390 // onto the stack from local
391 // variable 2
392 final static short aload_3 = 0x2d; // ? objectref loads a
393 // reference
394 // onto the stack from local
395 // variable 3
396 final static short iaload = 0x2e; // arrayref, index ?
397 // value loads
398 // an int from an array
399 final static short laload = 0x2f; // arrayref, index ?
400 // value load
401 // a long from an array
402 final static short astore = 0x3a; // index objectref ?
403 // stores a
404 // reference into a local
405 // variable #index
406 final static short istore_0 = 0x3b; // value ? store int
407 // value into
408 // variable 0
409 final static short istore_1 = 0x3c; // value ? store int
410 // value into
411 // variable 1
412 final static short istore_2 = 0x3d; // value ? store int
413 // value into
414 // variable 2
415 final static short istore_3 = 0x3e; // value ? store int
416 // value into
417 // variable 3
418 final static short lstore_0 = 0x3f; // value ? store a long
419 // value in
420 // a local variable 0
421 final static short dstore_3 = 0x4a; // value ? stores a
422 // double into
423 // local variable 3
424 final static short astore_0 = 0x4b; // objectref ? stores a
425 // reference into local variable
426 // 0
427 final static short astore_1 = 0x4c; // objectref ? stores a
428 // reference into local variable
429 // 1
430 final static short astore_2 = 0x4d; // objectref ? stores a
431 // reference into local variable
432 // 2
433 final static short astore_3 = 0x4e; // objectref ? stores a
434 // reference into local variable
435 // 3
436 final static short iastore = 0x4f; // arrayref, index,
437 // value ?
438 // stores an int into an array
439 final static short dup_x1 = 0x5a; // value2, value1 ?
440 // value1,
441 // value2, value1 inserts a copy
442 // of the top value into the
443 // stack two values from the top
444 final static short dup_x2 = 0x5b; // value3, value2,
445 // value1 ?
446 // value1, value3, value2,
447 // value1 inserts a copy of the
448 // top value into the stack two
449 // (if value2 is double or long
450 // it takes up the entry of
451 // value3, too) or three values
452 // (if value2 is neither double
453 // nor long) from the top
454 final static short dup2 = 0x5c; // {value2, value1} ?
455 // {value2,
456 // value1}, {value2, value1}
457 // duplicate top two stack words
458 // (two values, if value1 is not
459 // double nor long; a single
460 // value, if value1 is double or
461 // long)
462 final static short dup2_x1 = 0x5d; // value3, {value2,
463 // value1} ?
464 // {value2, value1}, value3,
465 // {value2, value1} duplicate
466 // two words and insert beneath
467 // third word (see explanation
468 // above)
469 final static short dup2_x2 = 0x5e; // {value4, value3},
470 // {value2,
471 // value1} ? {value2, value1},
472 // {value4, value3}, {value2,
473 // value1} duplicate two words
474 // and insert beneath fourth
475 // word
476 final static short swap = 0x5f; // value2, value1 ?
477 // value1,
478 // value2 swaps two top words on
479 // the stack (note that value1
480 // and value2 must not be double
481 // or long)
482 final static short fmul = 0x6a; // value1, value2 ?
483 // result
484 // multiplies two floats
485 final static short dmul = 0x6b; // value1, value2 ?
486 // result
487 // multiplies two doubles
488 final static short idiv = 0x6c; // value1, value2 ?
489 // result
490 // divides two integers
491 final static short ldiv = 0x6d; // value1, value2 ?
492 // result
493 // divide two longs
494 final static short fdiv = 0x6e; // value1, value2 ?
495 // result
496 // divides two floats
497 final static short ddiv = 0x6f; // value1, value2 ?
498 // result
499 // divides two doubles
500 final static short ishr = 0x7a; // value1, value2 ?
501 // result int
502 // shift right
503 final static short lshr = 0x7b; // value1, value2 ?
504 // result
505 // bitwise shift right of a long
506 // value1 by value2 positions
507 final static short iushr = 0x7c; // value1, value2 ?
508 // result int
509 // shift right
510 final static short lushr = 0x7d; // value1, value2 ?
511 // result
512 // bitwise shift right of a long
513 // value1 by value2 positions,
514 // unsigned
515 final static short iand = 0x7e; // value1, value2 ?
516 // result
517 // performs a logical and on two
518 // integers
519 final static short land = 0x7f; // value1, value2 ?
520 // result
521 // bitwise and of two longs
522 final static short l2d = 0x8a; // value ? result
523 // converts a
524 // long to a double
525 final static short f2i = 0x8b; // value ? result
526 // converts a
527 // float to an int
528 final static short f2l = 0x8c; // value ? result
529 // converts a
530 // float to a long
531 final static short f2d = 0x8d; // value ? result
532 // converts a
533 // float to a double
534 final static short d2i = 0x8e; // value ? result
535 // converts a
536 // double to an int
537 final static short d2l = 0x8f; // value ? result
538 // converts a
539 // double to a long
540 final static short ifne = 0x9a; // branchbyte1,
541 // branchbyte2
542 // value ? if value is not 0,
543 // branch to instruction at
544 // branchoffset (signed short
545 // constructed from unsigned
546 // bytes branchbyte1 << 8 +
547 // branchbyte2)
548 final static short iflt = 0x9b; // branchbyte1,
549 // branchbyte2
550 // value ? if value is less than
551 // 0, branch to instruction at
552 // branchoffset (signed short
553 // constructed from unsigned
554 // bytes branchbyte1 << 8 +
555 // branchbyte2)
556 final static short ifge = 0x9c; // branchbyte1,
557 // branchbyte2
558 // value ? if value is greater
559 // than or equal to 0, branch to
560 // instruction at branchoffset
561 // (signed short constructed
562 // from unsigned bytes
563 // branchbyte1 << 8 +
564 // branchbyte2)
565 final static short ifgt = 0x9d; // branchbyte1,
566 // branchbyte2
567 // value ? if value is greater
568 // than 0, branch to instruction
569 // at branchoffset (signed short
570 // constructed from unsigned
571 // bytes branchbyte1 << 8 +
572 // branchbyte2)
573 final static short ifle = 0x9e; // branchbyte1,
574 // branchbyte2
575 // value ? if value is less than
576 // or equal to 0, branch to
577 // instruction at branchoffset
578 // (signed short constructed
579 // from unsigned bytes
580 // branchbyte1 << 8 +
581 // branchbyte2)
582 final static short if_icmpeq = 0x9f; // branchbyte1,
583 // branchbyte2
584 // value1, value2 ? if ints are
585 // equal, branch to instruction
586 // at branchoffset (signed short
587 // constructed from unsigned
588 // bytes branchbyte1 << 8 +
589 // branchbyte2)
590 final static short if_icmpne = 0xa0; // branchbyte1,
591 // branchbyte2
592 // value1, value2 ? if ints are
593 // not equal, branch to
594 // instruction at branchoffset
595 // (signed short constructed
596 // from unsigned bytes
597 // branchbyte1 << 8 +
598 // branchbyte2)
599 final static short if_icmplt = 0xa1; // branchbyte1,
600 // branchbyte2
601 // value1, value2 ? if value1 is
602 // less than value2, branch to
603 // instruction at branchoffset
604 // (signed short constructed
605 // from unsigned bytes
606 // branchbyte1 << 8 +
607 // branchbyte2)
608 final static short if_icmpge = 0xa2; // branchbyte1,
609 // branchbyte2
610 // value1, value2 ? if value1 is
611 // greater than or equal to
612 // value2, branch to instruction
613 // at branchoffset (signed short
614 // constructed from unsigned
615 // bytes branchbyte1 << 8 +
616 // branchbyte2)
617 final static short if_icmpgt = 0xa3; // branchbyte1,
618 // branchbyte2
619 // value1, value2 ? if value1 is
620 // greater than value2, branch
621 // to instruction at
622 // branchoffset (signed short
623 // constructed from unsigned
624 // bytes branchbyte1 << 8 +
625 // branchbyte2)
626 final static short if_icmple = 0xa4; // branchbyte1,
627 // branchbyte2
628 // value1, value2 ? if value1 is
629 // less than or equal to value2,
630 // branch to instruction at
631 // branchoffset (signed short
632 // constructed from unsigned
633 // bytes branchbyte1 << 8 +
634 // branchbyte2)
635 final static short if_acmpeq = 0xa5; // branchbyte1,
636 // branchbyte2
637 // value1, value2 ? if
638 // references are equal, branch
639 // to instruction at
640 // branchoffset (signed short
641 // constructed from unsigned
642 // bytes branchbyte1 << 8 +
643 // branchbyte2)
644 final static short if_acmpne = 0xa6; // branchbyte1,
645 // branchbyte2
646 // value1, value2 ? if
647 // references are not equal,
648 // branch to instruction at
649 // branchoffset (signed short
650 // constructed from unsigned
651 // bytes branchbyte1 << 8 +
652 // branchbyte2)
653 final static short goto_ = 0xa7; // branchbyte1,
654 // branchbyte2 [no
655 // change] goes to another
656 // instruction at branchoffset
657 // (signed short constructed
658 // from unsigned bytes
659 // branchbyte1 << 8 +
660 // branchbyte2)
661 final static short jsr = 0xa8; // branchbyte1,
662 // branchbyte2 ?
663 // address jump to subroutine at
664 // branchoffset (signed short
665 // constructed from unsigned
666 // bytes branchbyte1 << 8 +
667 // branchbyte2) and place the
668 // return address on the stack
669 final static short ret = 0xa9; // index [No change]
670 // continue
671 // execution from address taken
672 // from a local variable #index
673 // (the asymmetry with jsr is
674 // intentional)
675 final static short tableswitch = 0xaa; // [0-3 bytes padding],
676 // defaultbyte1, defaultbyte2,
677 // defaultbyte3, defaultbyte4,
678 // lowbyte1, lowbyte2, lowbyte3,
679 // lowbyte4, highbyte1,
680 // highbyte2, highbyte3,
681 // highbyte4, jump offsets...
682 // index ? continue execution
683 // from an address in the table
684 // at offset index
685 final static short lookupswitch = 0xab; // <0-3 bytes padding>,
686 // defaultbyte1, defaultbyte2,
687 // defaultbyte3, defaultbyte4,
688 // npairs1, npairs2, npairs3,
689 // npairs4, match-offset
690 // pairs... key ? a target
691 // address is looked up from a
692 // table using a key and
693 // execution continues from the
694 // instruction at that address
695 final static short ireturn = 0xac; // value ? [empty]
696 // returns an
697 // integer from a method
698 final static short lreturn = 0xad; // value ? [empty]
699 // returns a
700 // long value
701 final static short freturn = 0xae; // value ? [empty]
702 // returns a
703 // float
704 final static short dreturn = 0xaf; // value ? [empty]
705 // returns a
706 // double from a method
707 final static short areturn = 0xb0; // objectref ? [empty]
708 // returns a
709 // reference from a method
710 final static short return_ = 0xb1; // ? [empty] return void
711 // from
712 // method
713 final static short getstatic = 0xb2; // index1, index2 ?
714 // value gets a
715 // static field value of a
716 // class, where the field is
717 // identified by field reference
718 // in the constant pool index
719 // (index1 << 8 + index2)
720 final static short putstatic = 0xb3; // indexbyte1,
721 // indexbyte2 value
722 // ? set static field to value
723 // in a class, where the field
724 // is identified by a field
725 // reference index in constant
726 // pool (indexbyte1 << 8 +
727 // indexbyte2)
728 final static short getfield = 0xb4; // index1, index2
729 // objectref ?
730 // value gets a field value of
731 // an object objectref, where
732 // the field is identified by
733 // field reference in the
734 // constant pool index (index1
735 // << 8 + index2)
736 final static short putfield = 0xb5; // indexbyte1,
737 // indexbyte2
738 // objectref, value ? set field
739 // to value in an object
740 // objectref, where the field is
741 // identified by a field
742 // reference index in constant
743 // pool (indexbyte1 << 8 +
744 // indexbyte2)
745 final static short invokevirtual = 0xb6; // indexbyte1,
746 // indexbyte2
747 // objectref, [arg1, arg2, ...]
748 // ? invoke virtual method on
749 // object objectref, where the
750 // method is identified by
751 // method reference index in
752 // constant pool (indexbyte1 <<
753 // 8 + indexbyte2)
754 final static short invokespecial = 0xb7; // indexbyte1,
755 // indexbyte2
756 // objectref, [arg1, arg2, ...]
757 // ? invoke instance method on
758 // object objectref, where the
759 // method is identified by
760 // method reference index in
761 // constant pool (indexbyte1 <<
762 // 8 + indexbyte2)
763 final static short invokestatic = 0xb8; // indexbyte1,
764 // indexbyte2 [arg1,
765 // arg2, ...] ? invoke a static
766 // method, where the method is
767 // identified by method
768 // reference index in constant
769 // pool (indexbyte1 << 8 +
770 // indexbyte2)
771 final static short invokeinterface = 0xb9; // indexbyte1,
772 // indexbyte2,
773 // count, 0 objectref, [arg1,
774 // arg2, ...] ? invokes an
775 // interface method on object
776 // objectref, where the
777 // interface method is
778 // identified by method
779 // reference index in constant
780 // pool (indexbyte1 << 8 +
781 // indexbyte2)
782 final static short xxxunusedxxx = 0xba; // this opcode is
783 // reserved "for
784 // historical reasons"
785 final static short new_ = 0xbb; // indexbyte1,
786 // indexbyte2 ?
787 // objectref creates new object
788 // of type identified by class
789 // reference in constant pool
790 // index (indexbyte1 << 8 +
791 // indexbyte2)
792 final static short newarray = 0xbc; // atype count ?
793 // arrayref
794 // creates new array with count
795 // elements of primitive type
796 // identified by atype
797 final static short anewarray = 0xbd; // indexbyte1,
798 // indexbyte2 count
799 // ? arrayref creates a new
800 // array of references of length
801 // count and component type
802 // identified by the class
803 // reference index (indexbyte1
804 // << 8 + indexbyte2) in the
805 // constant pool
806 final static short arraylength = 0xbe; // arrayref ? length
807 // gets the
808 // length of an array
809 final static short athrow = 0xbf; // objectref ? [empty],
810 // objectref throws an error or
811 // exception (notice that the
812 // rest of the stack is cleared,
813 // leaving only a reference to
814 // the Throwable)
815 final static short checkcast = 0xc0; // indexbyte1,
816 // indexbyte2
817 // objectref ? objectref checks
818 // whether an objectref is of a
819 // certain type, the class
820 // reference of which is in the
821 // constant pool at index
822 // (indexbyte1 << 8 +
823 // indexbyte2)
824 final static short instanceof_ = 0xc1; // indexbyte1,
825 // indexbyte2
826 // objectref ? result determines
827 // if an object objectref is of
828 // a given type, identified by
829 // class reference index in
830 // constant pool (indexbyte1 <<
831 // 8 + indexbyte2)
832 final static short monitorenter = 0xc2; // objectref ? enter
833 // monitor for
834 // object ("grab the lock" -
835 // start of synchronized()
836 // section)
837 final static short monitorexit = 0xc3; // objectref ? exit
838 // monitor for
839 // object ("release the lock" -
840 // end of synchronized()
841 // section)
842 final static short wide = 0xc4; // opcode, indexbyte1,
843 // indexbyte2
844 final static short multianewarray = 0xc5; // indexbyte1,
845 // indexbyte2,
846 // dimensions count1,
847 // [count2,...] ? arrayref
848 // create a new array of
849 // dimensions dimensions with
850 // elements of type identified
851 // by class reference in
852 // constant pool index
853 // (indexbyte1 << 8 +
854 // indexbyte2); the sizes of
855 // each dimension is identified
856 // by count1, [count2, etc]
857 final static short ifnull = 0xc6; // branchbyte1,
858 // branchbyte2
859 // value ? if value is null,
860 // branch to instruction at
861 // branchoffset (signed short
862 // constructed from unsigned
863 // bytes branchbyte1 << 8 +
864 // branchbyte2)
865 final static short ifnonnull = 0xc7; // branchbyte1,
866 // branchbyte2
867 // value ? if value is not null,
868 // branch to instruction at
869 // branchoffset (signed short
870 // constructed from unsigned
871 // bytes branchbyte1 << 8 +
872 // branchbyte2)
873 final static short goto_w = 0xc8; // branchbyte1,
874 // branchbyte2,
875 // branchbyte3, branchbyte4 [no
876 // change] goes to another
877 // instruction at branchoffset
878 // (signed int constructed from
879 // unsigned bytes branchbyte1 <<
880 // 24 + branchbyte2 << 16 +
881 // branchbyte3 << 8 +
882 // branchbyte4)
883 final static short jsr_w = 0xc9; // branchbyte1,
884 // branchbyte2,
885 // branchbyte3, branchbyte4 ?
886 // address jump to subroutine at
887 // branchoffset (signed int
888 // constructed from unsigned
889 // bytes branchbyte1 << 24 +
890 // branchbyte2 << 16 +
891 // branchbyte3 << 8 +
892 // branchbyte4) and place the
893 // return address on the stack
894 final static short breakpoint = 0xca; // reserved for
895 // breakpoints in
896 // Java debuggers; should not
897 // appear in any class file
898 final static short impdep1 = 0xfe; // reserved for
899 // implementation-dependent
900 // operations within debuggers;
901 // should not appear in any
902 // class file
903 final static short impdep2 = 0xff; // reserved for
904 // implementation-dependent
905 // operations within debuggers;
906 // should not appear in any
907 // class file
908
909 final static byte OFFSETS[] = new byte[256];
910
911 static {
912 OFFSETS[bipush] = 1; // byte ? value pushes a byte onto the
913 // stack as an integer value
914 OFFSETS[sipush] = 2; // byte1, byte2 ? value pushes a signed
915 // integer (byte1 << 8 + byte2) onto the
916 // stack
917 OFFSETS[ldc] = 1; // index ? value pushes a constant
918 // #index from a constant pool (String,
919 // int, float or class type) onto the
920 // stack
921 OFFSETS[ldc_w] = 2; // indexbyte1, indexbyte2 ? value pushes
922 // a constant #index from a constant
923 // pool (String, int, float or class
924 // type) onto the stack (wide index is
925 // constructed as indexbyte1 << 8 +
926 // indexbyte2)
927 OFFSETS[ldc2_w] = 2; // indexbyte1, indexbyte2 ? value pushes
928 // a constant #index from a constant
929 // pool (double or long) onto the stack
930 // (wide index is constructed as
931 // indexbyte1 << 8 + indexbyte2)
932 OFFSETS[iload] = 1; // index ? value loads an int value from
933 // a variable #index
934 OFFSETS[lload] = 1; // index ? value load a long value from
935 // a local variable #index
936 OFFSETS[fload] = 1; // index ? value loads a float value
937 // from a local variable #index
938 OFFSETS[dload] = 1; // index ? value loads a double value
939 // from a local variable #index
940 OFFSETS[aload] = 1; // index ? objectref loads a reference
941 // onto the stack from a local variable
942 // #index
943 OFFSETS[istore] = 1; // index value ? store int value into
944 // variable #index
945 OFFSETS[lstore] = 1; // index value ? store a long value in a
946 // local variable #index
947 OFFSETS[fstore] = 1; // index value ? stores a float value
948 // into a local variable #index
949 OFFSETS[dstore] = 1; // index value ? stores a double value
950 // into a local variable #index
951 OFFSETS[iinc] = 2; // index, const [No change] increment
952 // local variable #index by signed byte
953 // const
954 OFFSETS[ifeq] = 2; // branchbyte1, branchbyte2 value ? if
955 // value is 0, branch to instruction at
956 // branchoffset (signed short
957 // constructed from unsigned bytes
958 // branchbyte1 << 8 + branchbyte2)
959 OFFSETS[astore] = 1; // index objectref ? stores a reference
960 // into a local variable #index
961 OFFSETS[ifne] = 2; // branchbyte1, branchbyte2 value ? if
962 // value is not 0, branch to instruction
963 // at branchoffset (signed short
964 // constructed from unsigned bytes
965 // branchbyte1 << 8 + branchbyte2)
966 OFFSETS[iflt] = 2; // branchbyte1, branchbyte2 value ? if
967 // value is less than 0, branch to
968 // instruction at branchoffset (signed
969 // short constructed from unsigned bytes
970 // branchbyte1 << 8 + branchbyte2)
971 OFFSETS[ifge] = 2; // branchbyte1, branchbyte2 value ? if
972 // value is greater than or equal to 0,
973 // branch to instruction at branchoffset
974 // (signed short constructed from
975 // unsigned bytes branchbyte1 << 8 +
976 // branchbyte2)
977 OFFSETS[ifgt] = 2; // branchbyte1, branchbyte2 value ? if
978 // value is greater than 0, branch to
979 // instruction at branchoffset (signed
980 // short constructed from unsigned bytes
981 // branchbyte1 << 8 + branchbyte2)
982 OFFSETS[ifle] = 2; // branchbyte1, branchbyte2 value ? if
983 // value is less than or equal to 0,
984 // branch to instruction at branchoffset
985 // (signed short constructed from
986 // unsigned bytes branchbyte1 << 8 +
987 // branchbyte2)
988 OFFSETS[if_icmpeq] = 2; // branchbyte1, branchbyte2 value1,
989 // value2 ? if ints are equal,
990 // branch to instruction at
991 // branchoffset (signed short
992 // constructed from unsigned bytes
993 // branchbyte1 << 8 + branchbyte2)
994 OFFSETS[if_icmpne] = 2; // branchbyte1, branchbyte2 value1,
995 // value2 ? if ints are not equal,
996 // branch to instruction at
997 // branchoffset (signed short
998 // constructed from unsigned bytes
999 // branchbyte1 << 8 + branchbyte2)
1000 OFFSETS[if_icmplt] = 2; // branchbyte1, branchbyte2 value1,
1001 // value2 ? if value1 is less than
1002 // value2, branch to instruction at
1003 // branchoffset (signed short
1004 // constructed from unsigned bytes
1005 // branchbyte1 << 8 + branchbyte2)
1006 OFFSETS[if_icmpge] = 2; // branchbyte1, branchbyte2 value1,
1007 // value2 ? if value1 is greater
1008 // than or equal to value2, branch
1009 // to instruction at branchoffset
1010 // (signed short constructed from
1011 // unsigned bytes branchbyte1 << 8 +
1012 // branchbyte2)
1013 OFFSETS[if_icmpgt] = 2; // branchbyte1, branchbyte2 value1,
1014 // value2 ? if value1 is greater
1015 // than value2, branch to
1016 // instruction at branchoffset
1017 // (signed short constructed from
1018 // unsigned bytes branchbyte1 << 8 +
1019 // branchbyte2)
1020 OFFSETS[if_icmple] = 2; // branchbyte1, branchbyte2 value1,
1021 // value2 ? if value1 is less than
1022 // or equal to value2, branch to
1023 // instruction at branchoffset
1024 // (signed short constructed from
1025 // unsigned bytes branchbyte1 << 8 +
1026 // branchbyte2)
1027 OFFSETS[if_acmpeq] = 2; // branchbyte1, branchbyte2 value1,
1028 // value2 ? if references are equal,
1029 // branch to instruction at
1030 // branchoffset (signed short
1031 // constructed from unsigned bytes
1032 // branchbyte1 << 8 + branchbyte2)
1033 OFFSETS[if_acmpne] = 2; // branchbyte1, branchbyte2 value1,
1034 // value2 ? if references are not
1035 // equal, branch to instruction at
1036 // branchoffset (signed short
1037 // constructed from unsigned bytes
1038 // branchbyte1 << 8 + branchbyte2)
1039 OFFSETS[goto_] = 2; // branchbyte1, branchbyte2 [no change]
1040 // goes to another instruction at
1041 // branchoffset (signed short
1042 // constructed from unsigned bytes
1043 // branchbyte1 << 8 + branchbyte2)
1044 OFFSETS[jsr] = 2; // branchbyte1, branchbyte2 ? address
1045 // jump to subroutine at branchoffset
1046 // (signed short constructed from
1047 // unsigned bytes branchbyte1 << 8 +
1048 // branchbyte2) and place the return
1049 // address on the stack
1050 OFFSETS[ret] = 1; // index [No change] continue execution
1051 // from address taken from a local
1052 // variable #index (the asymmetry with
1053 // jsr is intentional)
1054 OFFSETS[tableswitch] = -1; // [0-3 bytes padding],
1055 // defaultbyte1, defaultbyte2,
1056 // defaultbyte3, defaultbyte4,
1057 // lowbyte1, lowbyte2, lowbyte3,
1058 // lowbyte4, highbyte1,
1059 // highbyte2, highbyte3,
1060 // highbyte4, jump offsets...
1061 // index ? continue execution
1062 // from an address in the table
1063 // at offset index
1064 OFFSETS[lookupswitch] = -1; // <0-3 bytes padding>,
1065 // defaultbyte1, defaultbyte2,
1066 // defaultbyte3, defaultbyte4,
1067 // npairs1, npairs2, npairs3,
1068 // npairs4, match-offset
1069 // pairs... key ? a target
1070 // address is looked up from a
1071 // table using a key and
1072 // execution continues from the
1073 // instruction at that address
1074 OFFSETS[getstatic] = 2; // index1, index2 ? value gets a
1075 // static field value of a class,
1076 // where the field is identified by
1077 // field reference in the constant
1078 // pool index (index1 << 8 + index2)
1079 OFFSETS[putstatic] = 2; // indexbyte1, indexbyte2 value ?
1080 // set static field to value in a
1081 // class, where the field is
1082 // identified by a field reference
1083 // index in constant pool
1084 // (indexbyte1 << 8 + indexbyte2)
1085 OFFSETS[getfield] = 2; // index1, index2 objectref ? value
1086 // gets a field value of an object
1087 // objectref, where the field is
1088 // identified by field reference in
1089 // the constant pool index (index1
1090 // << 8 + index2)
1091 OFFSETS[putfield] = 2; // indexbyte1, indexbyte2 objectref,
1092 // value ? set field to value in an
1093 // object objectref, where the field
1094 // is identified by a field
1095 // reference index in constant pool
1096 // (indexbyte1 << 8 + indexbyte2)
1097 OFFSETS[invokevirtual] = 2; // indexbyte1, indexbyte2
1098 // objectref, [arg1, arg2, ...]
1099 // ? invoke virtual method on
1100 // object objectref, where the
1101 // method is identified by
1102 // method reference index in
1103 // constant pool (indexbyte1 <<
1104 // 8 + indexbyte2)
1105 OFFSETS[invokespecial] = 2; // indexbyte1, indexbyte2
1106 // objectref, [arg1, arg2, ...]
1107 // ? invoke instance method on
1108 // object objectref, where the
1109 // method is identified by
1110 // method reference index in
1111 // constant pool (indexbyte1 <<
1112 // 8 + indexbyte2)
1113 OFFSETS[invokestatic] = 2; // indexbyte1, indexbyte2 [arg1,
1114 // arg2, ...] ? invoke a static
1115 // method, where the method is
1116 // identified by method
1117 // reference index in constant
1118 // pool (indexbyte1 << 8 +
1119 // indexbyte2)
1120 OFFSETS[invokeinterface] = 2; // indexbyte1, indexbyte2,
1121 // count, 0 objectref,
1122 // [arg1, arg2, ...] ?
1123 // invokes an interface
1124 // method on object
1125 // objectref, where the
1126 // interface method is
1127 // identified by method
1128 // reference index in
1129 // constant pool (indexbyte1
1130 // << 8 + indexbyte2)
1131 OFFSETS[new_] = 2; // indexbyte1, indexbyte2 ? objectref
1132 // creates new object of type identified
1133 // by class reference in constant pool
1134 // index (indexbyte1 << 8 + indexbyte2)
1135 OFFSETS[newarray] = 1; // atype count ? arrayref creates
1136 // new array with count elements of
1137 // primitive type identified by
1138 // atype
1139 OFFSETS[anewarray] = 2; // indexbyte1, indexbyte2 count ?
1140 // arrayref creates a new array of
1141 // references of length count and
1142 // component type identified by the
1143 // class reference index (indexbyte1
1144 // << 8 + indexbyte2) in the
1145 // constant pool
1146 OFFSETS[checkcast] = 2; // indexbyte1, indexbyte2 objectref
1147 // ? objectref checks whether an
1148 // objectref is of a certain type,
1149 // the class reference of which is
1150 // in the constant pool at index
1151 // (indexbyte1 << 8 + indexbyte2)
1152 OFFSETS[instanceof_] = 2; // indexbyte1, indexbyte2 objectref
1153 // ? result determines if an object
1154 // objectref is of a given type,
1155 // identified by class reference
1156 // index in constant pool
1157 // (indexbyte1 << 8 + indexbyte2)
1158 OFFSETS[wide] = 3; // opcode, indexbyte1, indexbyte2
1159 OFFSETS[multianewarray] = 3; // indexbyte1, indexbyte2,
1160 // dimensions count1,
1161 // [count2,...] ? arrayref
1162 // create a new array of
1163 // dimensions dimensions with
1164 // elements of type identified
1165 // by class reference in
1166 // constant pool index
1167 // (indexbyte1 << 8 +
1168 // indexbyte2); the sizes of
1169 // each dimension is identified
1170 // by count1, [count2, etc]
1171 OFFSETS[ifnull] = 2; // branchbyte1, branchbyte2 value ? if
1172 // value is null, branch to instruction
1173 // at branchoffset (signed short
1174 // constructed from unsigned bytes
1175 // branchbyte1 << 8 + branchbyte2)
1176 OFFSETS[ifnonnull] = 2; // branchbyte1, branchbyte2 value ?
1177 // if value is not null, branch to
1178 // instruction at branchoffset
1179 // (signed short constructed from
1180 // unsigned bytes branchbyte1 << 8 +
1181 // branchbyte2)
1182 OFFSETS[goto_w] = 4; // branchbyte1, branchbyte2,
1183 // branchbyte3, branchbyte4 [no change]
1184 // goes to another instruction at
1185 // branchoffset (signed int constructed
1186 // from unsigned bytes branchbyte1 << 24
1187 // + branchbyte2 << 16 + branchbyte3 <<
1188 // 8 + branchbyte4)
1189 OFFSETS[jsr_w] = 4; // branchbyte1, branchbyte2,
1190 // branchbyte3, branchbyte4 ? address
1191 // jump to subroutine at branchoffset
1192 // (signed int constructed from unsigned
1193 // bytes branchbyte1 << 24 + branchbyte2
1194 // << 16 + branchbyte3 << 8 +
1195 // branchbyte4) and place the return
1196 // address on the stack
1197 }
1198
1199 }