1 /*
  2  * Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
  3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4  *
  5  * This code is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 only, as
  7  * published by the Free Software Foundation.
  8  *
  9  * This code is distributed in the hope that it will be useful, but WITHOUT
 10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 12  * version 2 for more details (a copy is included in the LICENSE file that
 13  * accompanied this code).
 14  *
 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_INTERPRETER_BYTECODES_HPP
 26 #define SHARE_INTERPRETER_BYTECODES_HPP
 27 
 28 #include "memory/allStatic.hpp"
 29 #include "runtime/globals.hpp"
 30 #include "utilities/globalDefinitions.hpp"
 31 
 32 // Bytecodes specifies all bytecodes used in the VM and
 33 // provides utility functions to get bytecode attributes.
 34 
 35 class Method;
 36 
 37 // NOTE: replicated in SA in vm/agent/sun/jvm/hotspot/interpreter/Bytecodes.java
 38 class Bytecodes: AllStatic {
 39  public:
 40   enum Code {
 41     _illegal              =  -1,
 42 
 43     // Java bytecodes
 44     _nop                  =   0, // 0x00
 45     _aconst_null          =   1, // 0x01
 46     _iconst_m1            =   2, // 0x02
 47     _iconst_0             =   3, // 0x03
 48     _iconst_1             =   4, // 0x04
 49     _iconst_2             =   5, // 0x05
 50     _iconst_3             =   6, // 0x06
 51     _iconst_4             =   7, // 0x07
 52     _iconst_5             =   8, // 0x08
 53     _lconst_0             =   9, // 0x09
 54     _lconst_1             =  10, // 0x0a
 55     _fconst_0             =  11, // 0x0b
 56     _fconst_1             =  12, // 0x0c
 57     _fconst_2             =  13, // 0x0d
 58     _dconst_0             =  14, // 0x0e
 59     _dconst_1             =  15, // 0x0f
 60     _bipush               =  16, // 0x10
 61     _sipush               =  17, // 0x11
 62     _ldc                  =  18, // 0x12
 63     _ldc_w                =  19, // 0x13
 64     _ldc2_w               =  20, // 0x14
 65     _iload                =  21, // 0x15
 66     _lload                =  22, // 0x16
 67     _fload                =  23, // 0x17
 68     _dload                =  24, // 0x18
 69     _aload                =  25, // 0x19
 70     _iload_0              =  26, // 0x1a
 71     _iload_1              =  27, // 0x1b
 72     _iload_2              =  28, // 0x1c
 73     _iload_3              =  29, // 0x1d
 74     _lload_0              =  30, // 0x1e
 75     _lload_1              =  31, // 0x1f
 76     _lload_2              =  32, // 0x20
 77     _lload_3              =  33, // 0x21
 78     _fload_0              =  34, // 0x22
 79     _fload_1              =  35, // 0x23
 80     _fload_2              =  36, // 0x24
 81     _fload_3              =  37, // 0x25
 82     _dload_0              =  38, // 0x26
 83     _dload_1              =  39, // 0x27
 84     _dload_2              =  40, // 0x28
 85     _dload_3              =  41, // 0x29
 86     _aload_0              =  42, // 0x2a
 87     _aload_1              =  43, // 0x2b
 88     _aload_2              =  44, // 0x2c
 89     _aload_3              =  45, // 0x2d
 90     _iaload               =  46, // 0x2e
 91     _laload               =  47, // 0x2f
 92     _faload               =  48, // 0x30
 93     _daload               =  49, // 0x31
 94     _aaload               =  50, // 0x32
 95     _baload               =  51, // 0x33
 96     _caload               =  52, // 0x34
 97     _saload               =  53, // 0x35
 98     _istore               =  54, // 0x36
 99     _lstore               =  55, // 0x37
100     _fstore               =  56, // 0x38
101     _dstore               =  57, // 0x39
102     _astore               =  58, // 0x3a
103     _istore_0             =  59, // 0x3b
104     _istore_1             =  60, // 0x3c
105     _istore_2             =  61, // 0x3d
106     _istore_3             =  62, // 0x3e
107     _lstore_0             =  63, // 0x3f
108     _lstore_1             =  64, // 0x40
109     _lstore_2             =  65, // 0x41
110     _lstore_3             =  66, // 0x42
111     _fstore_0             =  67, // 0x43
112     _fstore_1             =  68, // 0x44
113     _fstore_2             =  69, // 0x45
114     _fstore_3             =  70, // 0x46
115     _dstore_0             =  71, // 0x47
116     _dstore_1             =  72, // 0x48
117     _dstore_2             =  73, // 0x49
118     _dstore_3             =  74, // 0x4a
119     _astore_0             =  75, // 0x4b
120     _astore_1             =  76, // 0x4c
121     _astore_2             =  77, // 0x4d
122     _astore_3             =  78, // 0x4e
123     _iastore              =  79, // 0x4f
124     _lastore              =  80, // 0x50
125     _fastore              =  81, // 0x51
126     _dastore              =  82, // 0x52
127     _aastore              =  83, // 0x53
128     _bastore              =  84, // 0x54
129     _castore              =  85, // 0x55
130     _sastore              =  86, // 0x56
131     _pop                  =  87, // 0x57
132     _pop2                 =  88, // 0x58
133     _dup                  =  89, // 0x59
134     _dup_x1               =  90, // 0x5a
135     _dup_x2               =  91, // 0x5b
136     _dup2                 =  92, // 0x5c
137     _dup2_x1              =  93, // 0x5d
138     _dup2_x2              =  94, // 0x5e
139     _swap                 =  95, // 0x5f
140     _iadd                 =  96, // 0x60
141     _ladd                 =  97, // 0x61
142     _fadd                 =  98, // 0x62
143     _dadd                 =  99, // 0x63
144     _isub                 = 100, // 0x64
145     _lsub                 = 101, // 0x65
146     _fsub                 = 102, // 0x66
147     _dsub                 = 103, // 0x67
148     _imul                 = 104, // 0x68
149     _lmul                 = 105, // 0x69
150     _fmul                 = 106, // 0x6a
151     _dmul                 = 107, // 0x6b
152     _idiv                 = 108, // 0x6c
153     _ldiv                 = 109, // 0x6d
154     _fdiv                 = 110, // 0x6e
155     _ddiv                 = 111, // 0x6f
156     _irem                 = 112, // 0x70
157     _lrem                 = 113, // 0x71
158     _frem                 = 114, // 0x72
159     _drem                 = 115, // 0x73
160     _ineg                 = 116, // 0x74
161     _lneg                 = 117, // 0x75
162     _fneg                 = 118, // 0x76
163     _dneg                 = 119, // 0x77
164     _ishl                 = 120, // 0x78
165     _lshl                 = 121, // 0x79
166     _ishr                 = 122, // 0x7a
167     _lshr                 = 123, // 0x7b
168     _iushr                = 124, // 0x7c
169     _lushr                = 125, // 0x7d
170     _iand                 = 126, // 0x7e
171     _land                 = 127, // 0x7f
172     _ior                  = 128, // 0x80
173     _lor                  = 129, // 0x81
174     _ixor                 = 130, // 0x82
175     _lxor                 = 131, // 0x83
176     _iinc                 = 132, // 0x84
177     _i2l                  = 133, // 0x85
178     _i2f                  = 134, // 0x86
179     _i2d                  = 135, // 0x87
180     _l2i                  = 136, // 0x88
181     _l2f                  = 137, // 0x89
182     _l2d                  = 138, // 0x8a
183     _f2i                  = 139, // 0x8b
184     _f2l                  = 140, // 0x8c
185     _f2d                  = 141, // 0x8d
186     _d2i                  = 142, // 0x8e
187     _d2l                  = 143, // 0x8f
188     _d2f                  = 144, // 0x90
189     _i2b                  = 145, // 0x91
190     _i2c                  = 146, // 0x92
191     _i2s                  = 147, // 0x93
192     _lcmp                 = 148, // 0x94
193     _fcmpl                = 149, // 0x95
194     _fcmpg                = 150, // 0x96
195     _dcmpl                = 151, // 0x97
196     _dcmpg                = 152, // 0x98
197     _ifeq                 = 153, // 0x99
198     _ifne                 = 154, // 0x9a
199     _iflt                 = 155, // 0x9b
200     _ifge                 = 156, // 0x9c
201     _ifgt                 = 157, // 0x9d
202     _ifle                 = 158, // 0x9e
203     _if_icmpeq            = 159, // 0x9f
204     _if_icmpne            = 160, // 0xa0
205     _if_icmplt            = 161, // 0xa1
206     _if_icmpge            = 162, // 0xa2
207     _if_icmpgt            = 163, // 0xa3
208     _if_icmple            = 164, // 0xa4
209     _if_acmpeq            = 165, // 0xa5
210     _if_acmpne            = 166, // 0xa6
211     _goto                 = 167, // 0xa7
212     _jsr                  = 168, // 0xa8
213     _ret                  = 169, // 0xa9
214     _tableswitch          = 170, // 0xaa
215     _lookupswitch         = 171, // 0xab
216     _ireturn              = 172, // 0xac
217     _lreturn              = 173, // 0xad
218     _freturn              = 174, // 0xae
219     _dreturn              = 175, // 0xaf
220     _areturn              = 176, // 0xb0
221     _return               = 177, // 0xb1
222     _getstatic            = 178, // 0xb2
223     _putstatic            = 179, // 0xb3
224     _getfield             = 180, // 0xb4
225     _putfield             = 181, // 0xb5
226     _invokevirtual        = 182, // 0xb6
227     _invokespecial        = 183, // 0xb7
228     _invokestatic         = 184, // 0xb8
229     _invokeinterface      = 185, // 0xb9
230     _invokedynamic        = 186, // 0xba
231     _new                  = 187, // 0xbb
232     _newarray             = 188, // 0xbc
233     _anewarray            = 189, // 0xbd
234     _arraylength          = 190, // 0xbe
235     _athrow               = 191, // 0xbf
236     _checkcast            = 192, // 0xc0
237     _instanceof           = 193, // 0xc1
238     _monitorenter         = 194, // 0xc2
239     _monitorexit          = 195, // 0xc3
240     _wide                 = 196, // 0xc4
241     _multianewarray       = 197, // 0xc5
242     _ifnull               = 198, // 0xc6
243     _ifnonnull            = 199, // 0xc7
244     _goto_w               = 200, // 0xc8
245     _jsr_w                = 201, // 0xc9
246     _breakpoint           = 202, // 0xca
247 
248     number_of_java_codes,
249 
250     // JVM bytecodes
251     _fast_agetfield       = number_of_java_codes,
252     _fast_vgetfield       ,
253     _fast_bgetfield       ,
254     _fast_cgetfield       ,
255     _fast_dgetfield       ,
256     _fast_fgetfield       ,
257     _fast_igetfield       ,
258     _fast_lgetfield       ,
259     _fast_sgetfield       ,
260 
261     _fast_aputfield       ,
262     _fast_vputfield       ,
263     _fast_bputfield       ,
264     _fast_zputfield       ,
265     _fast_cputfield       ,
266     _fast_dputfield       ,
267     _fast_fputfield       ,
268     _fast_iputfield       ,
269     _fast_lputfield       ,
270     _fast_sputfield       ,
271 
272     _fast_aload_0         ,
273     _fast_iaccess_0       ,
274     _fast_aaccess_0       ,
275     _fast_faccess_0       ,
276 
277     _fast_iload           ,
278     _fast_iload2          ,
279     _fast_icaload         ,
280 
281     _fast_invokevfinal    ,
282     _fast_linearswitch    ,
283     _fast_binaryswitch    ,
284 
285     // special handling of oop constants:
286     _fast_aldc            ,
287     _fast_aldc_w          ,
288 
289     _return_register_finalizer    ,
290 
291     // special handling of signature-polymorphic methods:
292     _invokehandle         ,
293 
294     // These bytecodes are rewritten at CDS dump time, so that we can prevent them from being
295     // rewritten at run time. This way, the ConstMethods can be placed in the CDS ReadOnly
296     // section, and RewriteByteCodes/RewriteFrequentPairs can rewrite non-CDS bytecodes
297     // at run time.
298     //
299     // Rewritten at CDS dump time to | Original bytecode
300     // _invoke_virtual rewritten on sparc, will be disabled if UseSharedSpaces turned on.
301     // ------------------------------+------------------
302     _nofast_getfield      ,          //  <- _getfield
303     _nofast_putfield      ,          //  <- _putfield
304     _nofast_aload_0       ,          //  <- _aload_0
305     _nofast_iload         ,          //  <- _iload
306 
307     _shouldnotreachhere   ,          // For debugging
308 
309 
310     number_of_codes
311   };
312 
313   static_assert(number_of_codes <= 256, "too many bytecodes");
314 
315   // Flag bits derived from format strings, can_trap, can_rewrite, etc.:
316   enum Flags : jchar {
317     // semantic flags:
318     _bc_can_trap      = 1<<0,     // bytecode execution can trap or block
319     _bc_can_rewrite   = 1<<1,     // bytecode execution has an alternate form
320 
321     // format bits (determined only by the format string):
322     _fmt_has_c        = 1<<2,     // constant, such as sipush "bcc"
323     _fmt_has_j        = 1<<3,     // constant pool cache index, such as getfield "bjj"
324     _fmt_has_k        = 1<<4,     // constant pool index, such as ldc "bk"
325     _fmt_has_i        = 1<<5,     // local index, such as iload
326     _fmt_has_o        = 1<<6,     // offset, such as ifeq
327     _fmt_has_nbo      = 1<<7,     // contains native-order field(s)
328     _fmt_has_u2       = 1<<8,     // contains double-byte field(s)
329     _fmt_has_u4       = 1<<9,     // contains quad-byte field
330     _fmt_not_variable = 1<<10,    // not of variable length (simple or wide)
331     _fmt_not_simple   = 1<<11,    // either wide or variable length
332     _all_fmt_bits     = (_fmt_not_simple*2 - _fmt_has_c),
333 
334     // Example derived format syndromes:
335     _fmt_b      = _fmt_not_variable,
336     _fmt_bc     = _fmt_b | _fmt_has_c,
337     _fmt_bi     = _fmt_b | _fmt_has_i,
338     _fmt_bkk    = _fmt_b | _fmt_has_k | _fmt_has_u2,
339     _fmt_bJJ    = _fmt_b | _fmt_has_j | _fmt_has_u2 | _fmt_has_nbo,
340     _fmt_bo2    = _fmt_b | _fmt_has_o | _fmt_has_u2,
341     _fmt_bo4    = _fmt_b | _fmt_has_o | _fmt_has_u4
342   };
343 
344  private:
345   static       bool        _is_initialized;
346   static const char* const _name       [number_of_codes];
347   static const BasicType   _result_type[number_of_codes];
348   static const s_char      _depth      [number_of_codes];
349   static const u_char      _lengths    [number_of_codes];
350   static const Code        _java_code  [number_of_codes];
351   static       jchar       _flags      [(1<<BitsPerByte)*2]; // all second page for wide formats
352 
353   static void def_flags(Code code, const char* format, const char* wide_format, bool can_trap, Code java_code);
354 
355   // Verify that bcp points into method
356 #ifdef ASSERT
357   static bool        check_method(const Method* method, address bcp);
358 #endif
359   static bool check_must_rewrite(Bytecodes::Code bc);
360   static jchar compute_flags  (const char* format, jchar more_flags);  // compute the flags
361 
362  public:
363   // Conversion
364   static void        check          (Code code)    { assert(is_defined(code),      "illegal code: %d", (int)code); }
365   static void        wide_check     (Code code)    { assert(wide_is_defined(code), "illegal code: %d", (int)code); }
366   static Code        cast           (int  code)    { return (Code)code; }
367 
368 
369   // Fetch a bytecode, hiding breakpoints as necessary.  The method
370   // argument is used for conversion of breakpoints into the original
371   // bytecode.  The CI uses these methods but guarantees that
372   // breakpoints are hidden so the method argument should be passed as
373   // null since in that case the bcp and Method* are unrelated
374   // memory.
375   static Code       code_at(const Method* method, address bcp) {
376     assert(method == nullptr || check_method(method, bcp), "bcp must point into method");
377     Code code = cast(*bcp);
378     assert(code != _breakpoint || method != nullptr, "need Method* to decode breakpoint");
379     return (code != _breakpoint) ? code : non_breakpoint_code_at(method, bcp);
380   }
381   static Code       java_code_at(const Method* method, address bcp) {
382     return java_code(code_at(method, bcp));
383   }
384 
385   // Fetch a bytecode or a breakpoint:
386   static Code       code_or_bp_at(address bcp)    { return (Code)cast(*bcp); }
387 
388   static Code       code_at(Method* method, int bci);
389 
390   // find a bytecode, behind a breakpoint if necessary:
391   static Code       non_breakpoint_code_at(const Method* method, address bcp);
392 
393   // Bytecode attributes
394   static bool        is_valid       (int  code)    { return 0 <= code && code < number_of_codes; }
395   static bool        is_defined     (int  code)    { return is_valid(code) && flags(code, false) != 0; }
396   static bool        wide_is_defined(int  code)    { return is_defined(code) && flags(code, true) != 0; }
397   static const char* name           (Code code)    { check(code);      return _name          [code]; }
398   static BasicType   result_type    (Code code)    { check(code);      return _result_type   [code]; }
399   static int         depth          (Code code)    { check(code);      return _depth         [code]; }
400   // Note: Length functions must return <=0 for invalid bytecodes.
401   // Calling check(code) in length functions would throw an unwanted assert.
402   static int         length_for     (Code code)    { return is_valid(code) ? _lengths[code] & 0xF : -1; }
403   static int         wide_length_for(Code code)    { return is_valid(code) ? _lengths[code]  >> 4 : -1; }
404   static bool        can_trap       (Code code)    { check(code);      return has_all_flags(code, _bc_can_trap, false); }
405   static Code        java_code      (Code code)    { check(code);      return _java_code     [code]; }
406   static bool        can_rewrite    (Code code)    { check(code);      return has_all_flags(code, _bc_can_rewrite, false); }
407   static bool        must_rewrite(Bytecodes::Code code) { return can_rewrite(code) && check_must_rewrite(code); }
408   static bool        native_byte_order(Code code)  { check(code);      return has_all_flags(code, _fmt_has_nbo, false); }
409   static bool        uses_cp_cache  (Code code)    { check(code);      return has_all_flags(code, _fmt_has_j, false); }
410   // if 'end' is provided, it indicates the end of the code buffer which
411   // should not be read past when parsing.
412   static int         special_length_at(Bytecodes::Code code, address bcp, address end = nullptr);
413   static int         raw_special_length_at(address bcp, address end = nullptr);
414   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); }
415   static int         length_at      (Method* method, address bcp)  { return length_for_code_at(code_at(method, bcp), bcp); }
416   static int         java_length_at (Method* method, address bcp)  { return length_for_code_at(java_code_at(method, bcp), bcp); }
417   static bool        is_java_code   (Code code)    { return 0 <= code && code < number_of_java_codes; }
418 
419   static bool        is_store_into_local(Code code){ return (_istore <= code && code <= _astore_3); }
420   static bool        is_const       (Code code)    { return (_aconst_null <= code && code <= _ldc2_w); }
421   static bool        is_zero_const  (Code code)    { return (code == _aconst_null || code == _iconst_0
422                                                            || code == _fconst_0 || code == _dconst_0); }
423   static bool        is_return      (Code code)    { return (_ireturn <= code && code <= _return); }
424   static bool        is_invoke      (Code code)    { return (_invokevirtual <= code && code <= _invokedynamic); }
425   static bool        is_field_code  (Code code)    {
426     return (_getstatic <= java_code(code) && java_code(code) <= _putfield);
427   }
428   static bool        has_receiver   (Code code)    { assert(is_invoke(code), "");  return code == _invokevirtual ||
429                                                                                           code == _invokespecial ||
430                                                                                           code == _invokeinterface; }
431   static bool        has_optional_appendix(Code code) { return code == _invokedynamic || code == _invokehandle; }
432 
433   static int         flags          (int code, bool is_wide) {
434     assert(code == (u_char)code, "must be a byte");
435     return _flags[code + (is_wide ? (1<<BitsPerByte) : 0)];
436   }
437   static bool        has_all_flags  (Code code, int test_flags, bool is_wide) {
438     return (flags(code, is_wide) & test_flags) == test_flags;
439   }
440 
441   // Initialization
442   static void        initialize     ();
443 };
444 
445 #endif // SHARE_INTERPRETER_BYTECODES_HPP