15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #ifndef SHARE_VM_INTERPRETER_BYTECODES_HPP
26 #define SHARE_VM_INTERPRETER_BYTECODES_HPP
27
28 #include "memory/allocation.hpp"
29 #include "utilities/top.hpp"
30
31 // Bytecodes specifies all bytecodes used in the VM and
32 // provides utility functions to get bytecode attributes.
33
34 // NOTE: replicated in SA in vm/agent/sun/jvm/hotspot/interpreter/Bytecodes.java
35 class Bytecodes: AllStatic {
36 public:
37 enum Code {
38 _illegal = -1,
39
40 // Java bytecodes
41 _nop = 0, // 0x00
42 _aconst_null = 1, // 0x01
43 _iconst_m1 = 2, // 0x02
44 _iconst_0 = 3, // 0x03
45 _iconst_1 = 4, // 0x04
46 _iconst_2 = 5, // 0x05
47 _iconst_3 = 6, // 0x06
48 _iconst_4 = 7, // 0x07
49 _iconst_5 = 8, // 0x08
50 _lconst_0 = 9, // 0x09
51 _lconst_1 = 10, // 0x0a
52 _fconst_0 = 11, // 0x0b
53 _fconst_1 = 12, // 0x0c
54 _fconst_2 = 13, // 0x0d
55 _dconst_0 = 14, // 0x0e
56 _dconst_1 = 15, // 0x0f
335 _fmt_has_o = 1<<6, // offset, such as ifeq
336 _fmt_has_nbo = 1<<7, // contains native-order field(s)
337 _fmt_has_u2 = 1<<8, // contains double-byte field(s)
338 _fmt_has_u4 = 1<<9, // contains quad-byte field
339 _fmt_not_variable = 1<<10, // not of variable length (simple or wide)
340 _fmt_not_simple = 1<<11, // either wide or variable length
341 _all_fmt_bits = (_fmt_not_simple*2 - _fmt_has_c),
342
343 // Example derived format syndromes:
344 _fmt_b = _fmt_not_variable,
345 _fmt_bc = _fmt_b | _fmt_has_c,
346 _fmt_bi = _fmt_b | _fmt_has_i,
347 _fmt_bkk = _fmt_b | _fmt_has_k | _fmt_has_u2,
348 _fmt_bJJ = _fmt_b | _fmt_has_j | _fmt_has_u2 | _fmt_has_nbo,
349 _fmt_bo2 = _fmt_b | _fmt_has_o | _fmt_has_u2,
350 _fmt_bo4 = _fmt_b | _fmt_has_o | _fmt_has_u4
351 };
352
353 private:
354 static bool _is_initialized;
355 static const char* _name [number_of_codes];
356 static BasicType _result_type [number_of_codes];
357 static s_char _depth [number_of_codes];
358 static u_char _lengths [number_of_codes];
359 static Code _java_code [number_of_codes];
360 static jchar _flags [(1<<BitsPerByte)*2]; // all second page for wide formats
361
362 static void def(Code code, const char* name, const char* format, const char* wide_format, BasicType result_type, int depth, bool can_trap);
363 static void def(Code code, const char* name, const char* format, const char* wide_format, BasicType result_type, int depth, bool can_trap, Code java_code);
364
365 // Verify that bcp points into method
366 #ifdef ASSERT
367 static bool check_method(const Method* method, address bcp);
368 #endif
369 static bool check_must_rewrite(Bytecodes::Code bc);
370
371 public:
372 // Conversion
373 static void check (Code code) { assert(is_defined(code), "illegal code: %d", (int)code); }
374 static void wide_check (Code code) { assert(wide_is_defined(code), "illegal code: %d", (int)code); }
375 static Code cast (int code) { return (Code)code; }
376
377
378 // Fetch a bytecode, hiding breakpoints as necessary. The method
379 // argument is used for conversion of breakpoints into the original
380 // bytecode. The CI uses these methods but guarantees that
381 // breakpoints are hidden so the method argument should be passed as
382 // NULL since in that case the bcp and Method* are unrelated
383 // memory.
384 static Code code_at(const Method* method, address bcp) {
385 assert(method == NULL || check_method(method, bcp), "bcp must point into method");
386 Code code = cast(*bcp);
387 assert(code != _breakpoint || method != NULL, "need Method* to decode breakpoint");
388 return (code != _breakpoint) ? code : non_breakpoint_code_at(method, bcp);
389 }
390 static Code java_code_at(const Method* method, address bcp) {
391 return java_code(code_at(method, bcp));
392 }
393
394 // Fetch a bytecode or a breakpoint:
395 static Code code_or_bp_at(address bcp) { return (Code)cast(*bcp); }
396
397 static Code code_at(Method* method, int bci);
398 static bool is_active_breakpoint_at(address bcp) { return (Code)*bcp == _breakpoint; }
399
400 // find a bytecode, behind a breakpoint if necessary:
401 static Code non_breakpoint_code_at(const Method* method, address bcp);
402
403 // Bytecode attributes
404 static bool is_defined (int code) { return 0 <= code && code < number_of_codes && flags(code, false) != 0; }
405 static bool wide_is_defined(int code) { return is_defined(code) && flags(code, true) != 0; }
406 static const char* name (Code code) { check(code); return _name [code]; }
407 static BasicType result_type (Code code) { check(code); return _result_type [code]; }
408 static int depth (Code code) { check(code); return _depth [code]; }
409 // Note: Length functions must return <=0 for invalid bytecodes.
410 // Calling check(code) in length functions would throw an unwanted assert.
411 static int length_for (Code code) { /*no check*/ return _lengths [code] & 0xF; }
412 static int wide_length_for(Code code) { /*no check*/ return _lengths [code] >> 4; }
413 static bool can_trap (Code code) { check(code); return has_all_flags(code, _bc_can_trap, false); }
414 static Code java_code (Code code) { check(code); return _java_code [code]; }
415 static bool can_rewrite (Code code) { check(code); return has_all_flags(code, _bc_can_rewrite, false); }
416 static bool must_rewrite(Bytecodes::Code code) { return can_rewrite(code) && check_must_rewrite(code); }
417 static bool native_byte_order(Code code) { check(code); return has_all_flags(code, _fmt_has_nbo, false); }
418 static bool uses_cp_cache (Code code) { check(code); return has_all_flags(code, _fmt_has_j, false); }
419 // if 'end' is provided, it indicates the end of the code buffer which
420 // should not be read past when parsing.
421 static int special_length_at(Bytecodes::Code code, address bcp, address end = NULL);
422 static int special_length_at(Method* method, address bcp, address end = NULL) { return special_length_at(code_at(method, bcp), bcp, end); }
423 static int raw_special_length_at(address bcp, address end = NULL);
424 static int length_for_code_at(Bytecodes::Code code, address bcp) { int l = length_for(code); return l > 0 ? l : special_length_at(code, bcp); }
425 static int length_at (Method* method, address bcp) { return length_for_code_at(code_at(method, bcp), bcp); }
426 static int java_length_at (Method* method, address bcp) { return length_for_code_at(java_code_at(method, bcp), bcp); }
427 static bool is_java_code (Code code) { return 0 <= code && code < number_of_java_codes; }
428
429 static bool is_aload (Code code) { return (code == _aload || code == _aload_0 || code == _aload_1
430 || code == _aload_2 || code == _aload_3); }
431 static bool is_astore (Code code) { return (code == _astore || code == _astore_0 || code == _astore_1
432 || code == _astore_2 || code == _astore_3); }
433
434 static bool is_store_into_local(Code code){ return (_istore <= code && code <= _astore_3); }
435 static bool is_const (Code code) { return (_aconst_null <= code && code <= _ldc2_w); }
436 static bool is_zero_const (Code code) { return (code == _aconst_null || code == _iconst_0
437 || code == _fconst_0 || code == _dconst_0); }
438 static bool is_return (Code code) { return (_ireturn <= code && code <= _return); }
439 static bool is_invoke (Code code) { return (_invokevirtual <= code && code <= _invokedynamic) || code == _invokedirect; }
440 static bool has_receiver (Code code) { assert(is_invoke(code), ""); return code == _invokevirtual ||
441 code == _invokedirect ||
442 code == _invokespecial ||
443 code == _invokeinterface; }
444 static bool has_optional_appendix(Code code) { return code == _invokedynamic || code == _invokehandle; }
445
446 static int compute_flags (const char* format, int more_flags = 0); // compute the flags
447 static int flags (int code, bool is_wide) {
448 assert(code == (u_char)code, "must be a byte");
449 return _flags[code + (is_wide ? (1<<BitsPerByte) : 0)];
450 }
451 static int format_bits (Code code, bool is_wide) { return flags(code, is_wide) & _all_fmt_bits; }
452 static bool has_all_flags (Code code, int test_flags, bool is_wide) {
453 return (flags(code, is_wide) & test_flags) == test_flags;
454 }
455
456 // Initialization
457 static void initialize ();
458 };
459
460 #endif // SHARE_VM_INTERPRETER_BYTECODES_HPP
|
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #ifndef SHARE_VM_INTERPRETER_BYTECODES_HPP
26 #define SHARE_VM_INTERPRETER_BYTECODES_HPP
27
28 #include "memory/allocation.hpp"
29 #include "utilities/top.hpp"
30
31 // Bytecodes specifies all bytecodes used in the VM and
32 // provides utility functions to get bytecode attributes.
33
34 // NOTE: replicated in SA in vm/agent/sun/jvm/hotspot/interpreter/Bytecodes.java
35 class Bytecodes {
36 public:
37
38 // a BCSet is a Bytecode Type, all arguments used by a _typed bytecode
39 // must be reducible to one of these BCSets.
40 // Each BCSet can redefine 256 bytecodes.
41 // The legacy Java bytecodes are assigned to BCSet _bcset_default
42 enum BCSet {
43 _bcset_illegal = -1,
44 _bcset_default = 0,
45 _bcset_byte,
46 _bcset_short,
47 _bcset_int,
48 _bcset_long,
49 _bcset_char,
50 _bcset_float,
51 _bcset_double,
52 _bcset_reference,
53 _bcset_array,
54
55 number_of_bcset
56 };
57
58 // The Code enum was the way to designate any bytecode known by the JVM.
59 // Even if coded with an int, only the less significant byte was used
60 // (because obviously bytecodes were encoded with bytes)
61 // To support typed bytecodes, the semantic of Code has been extended:
62 // The _typed bytecode is used as a prefix to modify the semantic of
63 // the next bytecode. The _typed bytecode arguments points to a constant
64 // pool entry which must be reducible to a BCSet (see above).
65 // With typed bytecodes, the total number of bytecodes now supported
66 // by the JVM is higher than 256, but the instruction following a
67 // _typed bytecode is still encoded with a byte, which makes it
68 // a bytecode anyway.
69 // The extended format for the Code enum uses the least significant
70 // byte (bits 0-7) to encode the bytecode, and bits (15-8) to
71 // encode the BCSet.
72 // The BCSet of legacy Java bytecodes is _btype_default which has
73 // value zero, which means the value of these bytecodes are the
74 // same with the old and the extended encoding.
75 // Legacy Java bytecodes are still defined in the Code enum.
76 // New typed bytecodes are defined in their respective BCSet
77 // definitions.
78 enum Code {
79 _illegal = -1,
80
81 // Java bytecodes
82 _nop = 0, // 0x00
83 _aconst_null = 1, // 0x01
84 _iconst_m1 = 2, // 0x02
85 _iconst_0 = 3, // 0x03
86 _iconst_1 = 4, // 0x04
87 _iconst_2 = 5, // 0x05
88 _iconst_3 = 6, // 0x06
89 _iconst_4 = 7, // 0x07
90 _iconst_5 = 8, // 0x08
91 _lconst_0 = 9, // 0x09
92 _lconst_1 = 10, // 0x0a
93 _fconst_0 = 11, // 0x0b
94 _fconst_1 = 12, // 0x0c
95 _fconst_2 = 13, // 0x0d
96 _dconst_0 = 14, // 0x0e
97 _dconst_1 = 15, // 0x0f
376 _fmt_has_o = 1<<6, // offset, such as ifeq
377 _fmt_has_nbo = 1<<7, // contains native-order field(s)
378 _fmt_has_u2 = 1<<8, // contains double-byte field(s)
379 _fmt_has_u4 = 1<<9, // contains quad-byte field
380 _fmt_not_variable = 1<<10, // not of variable length (simple or wide)
381 _fmt_not_simple = 1<<11, // either wide or variable length
382 _all_fmt_bits = (_fmt_not_simple*2 - _fmt_has_c),
383
384 // Example derived format syndromes:
385 _fmt_b = _fmt_not_variable,
386 _fmt_bc = _fmt_b | _fmt_has_c,
387 _fmt_bi = _fmt_b | _fmt_has_i,
388 _fmt_bkk = _fmt_b | _fmt_has_k | _fmt_has_u2,
389 _fmt_bJJ = _fmt_b | _fmt_has_j | _fmt_has_u2 | _fmt_has_nbo,
390 _fmt_bo2 = _fmt_b | _fmt_has_o | _fmt_has_u2,
391 _fmt_bo4 = _fmt_b | _fmt_has_o | _fmt_has_u4
392 };
393
394 private:
395 static bool _is_initialized;
396
397 static Bytecodes _codes [number_of_bcset][1<<BitsPerByte];
398 static const char* _bcset2name_tab[Bytecodes::number_of_bcset];
399
400 const char* _name;
401 BasicType _result_type;
402 Code _java_code;
403 s_char _depth;
404 u_char _lengths;
405 jchar _flags[2];
406
407 static void def(Code code, const char* name, const char* format, const char* wide_format, BasicType result_type, int depth, bool can_trap);
408 static void def(Code code, const char* name, const char* format, const char* wide_format, BasicType result_type, int depth, bool can_trap, Code java_code);
409
410 // Verify that bcp points into method
411 #ifdef ASSERT
412 static bool check_method(const Method* method, address bcp);
413 #endif
414 static bool check_must_rewrite(Bytecodes::Code bc);
415
416 public:
417
418 Bytecodes() {
419 _name = NULL;
420 _result_type = T_ILLEGAL;
421 _java_code = _illegal;
422 _depth = 0;
423 _lengths = 0;
424 _flags[0] = 0;
425 _flags[1] = 0;
426 }
427
428 // Conversion
429 static void check (Code code) { assert(is_defined(code), "illegal code: %d", (int)code); }
430 static void wide_check (Code code) { assert(wide_is_defined(code), "illegal code: %d", (int)code); }
431 static Code cast (int code) { return (Code)code; }
432 static BCSet bcset (Code code) { return (BCSet)((code >> BitsPerByte) & ((1 << BitsPerByte) - 1)); }
433 static Code bytecode (Code code) { return (Code)(code & ((1 << BitsPerByte) - 1)); }
434 static Code extended_Code (BCSet bt, Code bc) {
435 assert(bt >= 0 && bt < number_of_bcset, "Invalid BCSet");
436 assert(bc >=0 && bc < 256, "Out of range");
437 assert(bt > 0 || bc < number_of_codes, "Invalid bytecode");
438 return (Code)((bt << BitsPerByte) | bc);
439 }
440 static const char* bcset2name(BCSet bcs) {
441 assert(bcs >= 0 && bcs < number_of_bcset, "Invalid BCSet");
442 return _bcset2name_tab[bcs];
443 }
444
445 #define BCSET_BYTECODE_INDEXES(code) [bcset((Code)code)][bytecode((Code)code)]
446
447 // Fetch a bytecode, hiding breakpoints as necessary. The method
448 // argument is used for conversion of breakpoints into the original
449 // bytecode. The CI uses these methods but guarantees that
450 // breakpoints are hidden so the method argument should be passed as
451 // NULL since in that case the bcp and Method* are unrelated
452 // memory.
453 static Code code_at(const Method* method, address bcp) {
454 assert(method == NULL || check_method(method, bcp), "bcp must point into method");
455 Code code = cast(*bcp);
456 assert(code != _breakpoint || method != NULL, "need Method* to decode breakpoint");
457 return (code != _breakpoint) ? code : non_breakpoint_code_at(method, bcp);
458 }
459 static Code java_code_at(const Method* method, address bcp) {
460 return java_code(code_at(method, bcp));
461 }
462
463 // Fetch a bytecode or a breakpoint:
464 static Code code_or_bp_at(address bcp) { return (Code)cast(*bcp); }
465
466 static Code code_at(Method* method, int bci);
467 static bool is_active_breakpoint_at(address bcp) { return (Code)*bcp == _breakpoint; }
468
469 // find a bytecode, behind a breakpoint if necessary:
470 static Code non_breakpoint_code_at(const Method* method, address bcp);
471
472 // Bytecode attributes
473 static bool is_defined (int code) { return _codes[bcset((Code)code)][bytecode((Code)code)]._java_code != _illegal; }
474 static bool wide_is_defined(int code) { return is_defined(code) && flags(code, true) != 0; }
475 static const char* name (Code code) { check(code); return _codes BCSET_BYTECODE_INDEXES(code)._name; }
476 static BasicType result_type (Code code) { check(code); return _codes BCSET_BYTECODE_INDEXES(code)._result_type; }
477 static int depth (Code code) { check(code); return _codes BCSET_BYTECODE_INDEXES(code)._depth; }
478 // Note: Length functions must return <=0 for invalid bytecodes.
479 // Calling check(code) in length functions would throw an unwanted assert.
480 static int length_for (Code code) { /*no check*/ return _codes BCSET_BYTECODE_INDEXES(code)._lengths & 0xF; }
481 static int wide_length_for(Code code) { /*no check*/ return _codes BCSET_BYTECODE_INDEXES(code)._lengths >> 4; }
482 static bool can_trap (Code code) { check(code); return has_all_flags(code, _bc_can_trap, false); }
483 static Code java_code (Code code) { check(code); return _codes BCSET_BYTECODE_INDEXES(code)._java_code; }
484 static bool can_rewrite (Code code) { check(code); return has_all_flags(code, _bc_can_rewrite, false); }
485 static bool must_rewrite(Bytecodes::Code code) { return can_rewrite(code) && check_must_rewrite(code); }
486 static bool native_byte_order(Code code) { check(code); return has_all_flags(code, _fmt_has_nbo, false); }
487 static bool uses_cp_cache (Code code) { check(code); return has_all_flags(code, _fmt_has_j, false); }
488 // if 'end' is provided, it indicates the end of the code buffer which
489 // should not be read past when parsing.
490 static int special_length_at(Bytecodes::Code code, address bcp, address end = NULL);
491 static int special_length_at(Method* method, address bcp, address end = NULL) { return special_length_at(code_at(method, bcp), bcp, end); }
492 static int raw_special_length_at(address bcp, address end = NULL);
493 static int length_for_code_at(Bytecodes::Code code, address bcp) { int l = length_for(code); return l > 0 ? l : special_length_at(code, bcp); }
494 static int length_at (Method* method, address bcp) { return length_for_code_at(code_at(method, bcp), bcp); }
495 static int java_length_at (Method* method, address bcp) { return length_for_code_at(java_code_at(method, bcp), bcp); }
496 static bool is_java_code (Code code) { return bcset(code) == _bcset_default &&
497 0 <= code && code < number_of_java_codes; }
498
499 static bool is_aload (Code code) { return (code == _aload || code == _aload_0 || code == _aload_1
500 || code == _aload_2 || code == _aload_3); }
501 static bool is_astore (Code code) { return (code == _astore || code == _astore_0 || code == _astore_1
502 || code == _astore_2 || code == _astore_3); }
503
504 static bool is_store_into_local(Code code){ return (_istore <= code && code <= _astore_3); }
505 static bool is_const (Code code) { return (_aconst_null <= code && code <= _ldc2_w); }
506 static bool is_zero_const (Code code) { return (code == _aconst_null || code == _iconst_0
507 || code == _fconst_0 || code == _dconst_0); }
508 static bool is_return (Code code) { return (_ireturn <= code && code <= _return); }
509 static bool is_invoke (Code code) { return (_invokevirtual <= code && code <= _invokedynamic) || code == _invokedirect; }
510 static bool has_receiver (Code code) { assert(is_invoke(code), ""); return code == _invokevirtual ||
511 code == _invokedirect ||
512 code == _invokespecial ||
513 code == _invokeinterface; }
514 static bool has_optional_appendix(Code code) { return code == _invokedynamic || code == _invokehandle; }
515
516 static int compute_flags (const char* format, int more_flags = 0); // compute the flags
517 static int flags (int code, bool is_wide) {
518 // assert(code == (u_char)code, "must be a byte");
519 return _codes BCSET_BYTECODE_INDEXES(code)._flags [is_wide ? 1 : 0];
520 }
521 static int format_bits (Code code, bool is_wide) { return flags(code, is_wide) & _all_fmt_bits; }
522 static bool has_all_flags (Code code, int test_flags, bool is_wide) {
523 return (flags(code, is_wide) & test_flags) == test_flags;
524 }
525
526 // Initialization
527 static void initialize ();
528 static void define_typed_bytecodes_sets();
529 static void define_typed_I_bytecodes();
530 static void define_typed_F_bytecodes();
531
532 // Typed bytecodes
533
534 #define EXTENDED_CODE(bt,c) ((bt << BitsPerByte) | c)
535
536 enum Typed_I_bytecodes {
537 _typed_I_aload = EXTENDED_CODE(_bcset_int, _aload),
538 _typed_I_aload_0 = EXTENDED_CODE(_bcset_int, _aload_0),
539 _typed_I_aload_1 = EXTENDED_CODE(_bcset_int, _aload_1),
540 _typed_I_aload_2 = EXTENDED_CODE(_bcset_int, _aload_2),
541 _typed_I_aload_3 = EXTENDED_CODE(_bcset_int, _aload_3),
542 _typed_I_astore = EXTENDED_CODE(_bcset_int, _astore),
543 _typed_I_astore_0 = EXTENDED_CODE(_bcset_int, _astore_0),
544 _typed_I_astore_1 = EXTENDED_CODE(_bcset_int, _astore_1),
545 _typed_I_astore_2 = EXTENDED_CODE(_bcset_int, _astore_2),
546 _typed_I_astore_3 = EXTENDED_CODE(_bcset_int, _astore_3),
547 _typed_I_aaload = EXTENDED_CODE(_bcset_int, _aaload),
548 _typed_I_aastore = EXTENDED_CODE(_bcset_int, _aastore),
549 _typed_I_areturn = EXTENDED_CODE(_bcset_int, _areturn),
550 _typed_I_anewarray = EXTENDED_CODE(_bcset_int, _anewarray),
551 _typed_I_aconst_null = EXTENDED_CODE(_bcset_int, _aconst_null)
552 };
553
554 enum Typed_F_bytecodes {
555 _typed_F_aload = EXTENDED_CODE(_bcset_float, _aload),
556 _typed_F_aload_0 = EXTENDED_CODE(_bcset_float, _aload_0),
557 _typed_F_aload_1 = EXTENDED_CODE(_bcset_float, _aload_1),
558 _typed_F_aload_2 = EXTENDED_CODE(_bcset_float, _aload_2),
559 _typed_F_aload_3 = EXTENDED_CODE(_bcset_float, _aload_3),
560 _typed_F_astore = EXTENDED_CODE(_bcset_float, _astore),
561 _typed_F_astore_0 = EXTENDED_CODE(_bcset_float, _astore_0),
562 _typed_F_astore_1 = EXTENDED_CODE(_bcset_float, _astore_1),
563 _typed_F_astore_2 = EXTENDED_CODE(_bcset_float, _astore_2),
564 _typed_F_astore_3 = EXTENDED_CODE(_bcset_float, _astore_3),
565 _typed_F_aaload = EXTENDED_CODE(_bcset_float, _aaload),
566 _typed_F_aastore = EXTENDED_CODE(_bcset_float, _aastore),
567 _typed_F_areturn = EXTENDED_CODE(_bcset_float, _areturn),
568 _typed_F_anewarray = EXTENDED_CODE(_bcset_float, _anewarray),
569 _typed_F_aconst_null = EXTENDED_CODE(_bcset_float, _aconst_null)
570 };
571 };
572
573 #undef EXTENDED_CODE
574
575 #endif // SHARE_VM_INTERPRETER_BYTECODES_HPP
|