hotspot/src/share/vm/code/nmethod.hpp
author rehn
Thu, 31 Aug 2017 08:18:47 +0200
changeset 47099 49f5fa3fc2ae
parent 46702 13ae789b982e
permissions -rw-r--r--
8186837: Memory ordering nmethod, _state and _stack_traversal_mark Reviewed-by: dholmes, rkennke
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
47099
49f5fa3fc2ae 8186837: Memory ordering nmethod, _state and _stack_traversal_mark
rehn
parents: 46702
diff changeset
     2
 * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5533
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5533
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5533
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    25
#ifndef SHARE_VM_CODE_NMETHOD_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    26
#define SHARE_VM_CODE_NMETHOD_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    27
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
    28
#include "code/compiledMethod.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
    30
class DepChange;
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
    31
class DirectiveSet;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
// nmethods (native methods) are the compiled code versions of Java methods.
5924
dc9d04930c82 6965184: possible races in make_not_entrant_or_zombie
never
parents: 5896
diff changeset
    34
//
dc9d04930c82 6965184: possible races in make_not_entrant_or_zombie
never
parents: 5896
diff changeset
    35
// An nmethod contains:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
//  - header                 (the nmethod structure)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
//  [Relocation]
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
//  - relocation information
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
//  - constant part          (doubles, longs and floats used in nmethod)
5686
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
    40
//  - oop table
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
//  [Code]
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
//  - code body
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
//  - exception handler
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
//  - stub code
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
//  [Debugging information]
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
//  - oop array
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
//  - data array
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
//  - pcs
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
//  [Exception handler table]
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
//  - handler entry point array
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
//  [Implicit Null Pointer exception table]
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
//  - implicit null table array
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
    54
class nmethod : public CompiledMethod {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
  friend class VMStructs;
35123
b0b89d83bcf5 8134994: use separate VMStructs databases for SA and JVMCI
twisti
parents: 35108
diff changeset
    56
  friend class JVMCIVMStructs;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
  friend class NMethodSweeper;
9935
51267b5e1a3d 7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents: 8872
diff changeset
    58
  friend class CodeCache;  // scavengable oops
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
 private:
25492
d27050bdfb04 8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents: 25491
diff changeset
    60
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  // Shared fields for all nmethod's
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
  int       _entry_bci;        // != InvocationEntryBci if this nmethod is an on-stack replacement method
5896
c60924a89622 6656830: assert((*p)->is_oop(),"expected an oop while scanning weak refs")
never
parents: 5702
diff changeset
    63
  jmethodID _jmethod_id;       // Cache of method()->jmethod_id()
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32466
diff changeset
    65
#if INCLUDE_JVMCI
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32466
diff changeset
    66
  // Needed to keep nmethods alive that are not the default nmethod for the associated Method.
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32466
diff changeset
    67
  oop       _jvmci_installed_code;
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32466
diff changeset
    68
  oop       _speculation_log;
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32466
diff changeset
    69
#endif
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32466
diff changeset
    70
3908
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2131
diff changeset
    71
  // To support simple linked-list chaining of nmethods:
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
    72
  nmethod*  _osr_link;         // from InstanceKlass::osr_nmethods_head
25492
d27050bdfb04 8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents: 25491
diff changeset
    73
3908
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2131
diff changeset
    74
  static nmethod* volatile _oops_do_mark_nmethods;
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2131
diff changeset
    75
  nmethod*        volatile _oops_do_mark_link;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
5924
dc9d04930c82 6965184: possible races in make_not_entrant_or_zombie
never
parents: 5896
diff changeset
    77
  // offsets for entry points
dc9d04930c82 6965184: possible races in make_not_entrant_or_zombie
never
parents: 5896
diff changeset
    78
  address _entry_point;                      // entry point with class check
dc9d04930c82 6965184: possible races in make_not_entrant_or_zombie
never
parents: 5896
diff changeset
    79
  address _verified_entry_point;             // entry point without class check
dc9d04930c82 6965184: possible races in make_not_entrant_or_zombie
never
parents: 5896
diff changeset
    80
  address _osr_entry_point;                  // entry point for on stack replacement
dc9d04930c82 6965184: possible races in make_not_entrant_or_zombie
never
parents: 5896
diff changeset
    81
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  // Offsets for different nmethod parts
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
    83
  int  _exception_offset;
5334
b2d040a8d375 6939930: exception unwind changes in 6919934 hurts compilation speed
never
parents: 4752
diff changeset
    84
  // Offset of the unwind handler if it exists
b2d040a8d375 6939930: exception unwind changes in 6919934 hurts compilation speed
never
parents: 4752
diff changeset
    85
  int _unwind_handler_offset;
b2d040a8d375 6939930: exception unwind changes in 6919934 hurts compilation speed
never
parents: 4752
diff changeset
    86
6432
d36e09b60939 6961697: move nmethod constants section before instruction section
twisti
parents: 6418
diff changeset
    87
  int _consts_offset;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  int _stub_offset;
5686
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
    89
  int _oops_offset;                       // offset to where embedded oop table begins (inside data)
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
    90
  int _metadata_offset;                   // embedded meta data table
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  int _scopes_data_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  int _scopes_pcs_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  int _dependencies_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  int _handler_table_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  int _nul_chk_table_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  int _nmethod_end_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
    98
  int code_offset() const { return (address) code_begin() - header_begin(); }
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
    99
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  // location in frame (offset for sp) that deopt can store the original
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  // pc during a deopt.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  int _orig_pc_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
5924
dc9d04930c82 6965184: possible races in make_not_entrant_or_zombie
never
parents: 5896
diff changeset
   104
  int _compile_id;                           // which compilation made this nmethod
dc9d04930c82 6965184: possible races in make_not_entrant_or_zombie
never
parents: 5896
diff changeset
   105
  int _comp_level;                           // compilation level
dc9d04930c82 6965184: possible races in make_not_entrant_or_zombie
never
parents: 5896
diff changeset
   106
dc9d04930c82 6965184: possible races in make_not_entrant_or_zombie
never
parents: 5896
diff changeset
   107
  // protected by CodeCache_lock
dc9d04930c82 6965184: possible races in make_not_entrant_or_zombie
never
parents: 5896
diff changeset
   108
  bool _has_flushed_dependencies;            // Used for maintenance of dependencies (CodeCache_lock)
dc9d04930c82 6965184: possible races in make_not_entrant_or_zombie
never
parents: 5896
diff changeset
   109
dc9d04930c82 6965184: possible races in make_not_entrant_or_zombie
never
parents: 5896
diff changeset
   110
  // used by jvmti to track if an unload event has been posted for this nmethod.
dc9d04930c82 6965184: possible races in make_not_entrant_or_zombie
never
parents: 5896
diff changeset
   111
  bool _unload_reported;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
5924
dc9d04930c82 6965184: possible races in make_not_entrant_or_zombie
never
parents: 5896
diff changeset
   113
  // Protected by Patching_lock
36802
18b1db5a7e70 8023191: OSR nmethods should be flushed to free space in CodeCache
thartmann
parents: 36300
diff changeset
   114
  volatile unsigned char _state;             // {in_use, not_entrant, zombie, unloaded}
5924
dc9d04930c82 6965184: possible races in make_not_entrant_or_zombie
never
parents: 5896
diff changeset
   115
6268
9e96dde307e9 6974176: ShouldNotReachHere, instanceKlass.cpp:1426
never
parents: 6187
diff changeset
   116
#ifdef ASSERT
9e96dde307e9 6974176: ShouldNotReachHere, instanceKlass.cpp:1426
never
parents: 6187
diff changeset
   117
  bool _oops_are_stale;  // indicates that it's no longer safe to access oops section
9e96dde307e9 6974176: ShouldNotReachHere, instanceKlass.cpp:1426
never
parents: 6187
diff changeset
   118
#endif
9e96dde307e9 6974176: ShouldNotReachHere, instanceKlass.cpp:1426
never
parents: 6187
diff changeset
   119
3908
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2131
diff changeset
   120
  jbyte _scavenge_root_state;
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2131
diff changeset
   121
23491
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22506
diff changeset
   122
#if INCLUDE_RTM_OPT
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22506
diff changeset
   123
  // RTM state at compile time. Used during deoptimization to decide
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22506
diff changeset
   124
  // whether to restart collecting RTM locking abort statistic again.
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22506
diff changeset
   125
  RTMState _rtm_state;
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22506
diff changeset
   126
#endif
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22506
diff changeset
   127
8661
3dc8a18ac563 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue
dcubed
parents: 8495
diff changeset
   128
  // Nmethod Flushing lock. If non-zero, then the nmethod is not removed
3dc8a18ac563 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue
dcubed
parents: 8495
diff changeset
   129
  // and is not made into a zombie. However, once the nmethod is made into
3dc8a18ac563 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue
dcubed
parents: 8495
diff changeset
   130
  // a zombie, it will be locked one final time if CompiledMethodUnload
3dc8a18ac563 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue
dcubed
parents: 8495
diff changeset
   131
  // event processing needs to be done.
24309
fc2950805050 8041468: Field nmethod::_lock_count should be declared volatile
anoll
parents: 23491
diff changeset
   132
  volatile jint _lock_count;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  // not_entrant method removal. Each mark_sweep pass will update
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  // this mark to current sweep invocation count if it is seen on the
20290
2127dc70bce9 8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents: 19696
diff changeset
   136
  // stack.  An not_entrant method can be removed when there are no
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  // more activations, i.e., when the _stack_traversal_mark is less than
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  // current sweep traversal index.
47099
49f5fa3fc2ae 8186837: Memory ordering nmethod, _state and _stack_traversal_mark
rehn
parents: 46702
diff changeset
   139
  volatile long _stack_traversal_mark;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
20290
2127dc70bce9 8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents: 19696
diff changeset
   141
  // The _hotness_counter indicates the hotness of a method. The higher
2127dc70bce9 8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents: 19696
diff changeset
   142
  // the value the hotter the method. The hotness counter of a nmethod is
2127dc70bce9 8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents: 19696
diff changeset
   143
  // set to [(ReservedCodeCacheSize / (1024 * 1024)) * 2] each time the method
2127dc70bce9 8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents: 19696
diff changeset
   144
  // is active while stack scanning (mark_active_nmethods()). The hotness
2127dc70bce9 8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents: 19696
diff changeset
   145
  // counter is decreased (by 1) while sweeping.
2127dc70bce9 8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents: 19696
diff changeset
   146
  int _hotness_counter;
2127dc70bce9 8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents: 19696
diff changeset
   147
7444
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7397
diff changeset
   148
  // These are used for compiled synchronized native methods to
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  // locate the owner and stack slot for the BasicLock so that we can
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  // properly revoke the bias of the owner if necessary. They are
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  // needed because there is no debug information for compiled native
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  // wrappers and the oop maps are insufficient to allow
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  // frame::retrieve_receiver() to work. Currently they are expected
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  // to be byte offsets from the Java stack pointer for maximum code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  // sharing between platforms. Note that currently biased locking
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  // will never cause Class instances to be biased but this code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  // handles the static synchronized case as well.
7444
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7397
diff changeset
   158
  // JVMTI's GetLocalInstance() also uses these offsets to find the receiver
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7397
diff changeset
   159
  // for non-static native wrapper frames.
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7397
diff changeset
   160
  ByteSize _native_receiver_sp_offset;
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7397
diff changeset
   161
  ByteSize _native_basic_lock_sp_offset;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  friend class nmethodLocker;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  // For native wrappers
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   166
  nmethod(Method* method,
42040
70ec5a09a0d5 8166377: is_compiled_by_jvmci hot in some profiles - improve nmethod compiler type detection
neliasso
parents: 38133
diff changeset
   167
          CompilerType type,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
          int nmethod_size,
8872
36680c58660e 7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents: 8724
diff changeset
   169
          int compile_id,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
          CodeOffsets* offsets,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
          CodeBuffer *code_buffer,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
          int frame_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
          ByteSize basic_lock_owner_sp_offset, /* synchronized natives only */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
          ByteSize basic_lock_sp_offset,       /* synchronized natives only */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
          OopMapSet* oop_maps);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  // Creation support
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   178
  nmethod(Method* method,
42040
70ec5a09a0d5 8166377: is_compiled_by_jvmci hot in some profiles - improve nmethod compiler type detection
neliasso
parents: 38133
diff changeset
   179
          CompilerType type,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
          int nmethod_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
          int compile_id,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
          int entry_bci,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
          CodeOffsets* offsets,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
          int orig_pc_offset,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
          DebugInformationRecorder *recorder,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
          Dependencies* dependencies,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
          CodeBuffer *code_buffer,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
          int frame_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
          OopMapSet* oop_maps,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
          ExceptionHandlerTable* handler_table,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
          ImplicitExceptionTable* nul_chk_table,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
          AbstractCompiler* compiler,
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32466
diff changeset
   193
          int comp_level
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32466
diff changeset
   194
#if INCLUDE_JVMCI
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32466
diff changeset
   195
          , Handle installed_code,
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32466
diff changeset
   196
          Handle speculation_log
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32466
diff changeset
   197
#endif
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32466
diff changeset
   198
          );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
  // helper methods
26796
666464578742 8015774: Add support for multiple code heaps
thartmann
parents: 26705
diff changeset
   201
  void* operator new(size_t size, int nmethod_size, int comp_level) throw();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  const char* reloc_string_for(u_char* begin, u_char* end);
4479
5686407cde7a 5057818: codecache full and compiler disabled in bigapps fastdebug run
never
parents: 3919
diff changeset
   204
  // Returns true if this thread changed the state of the nmethod or
5686407cde7a 5057818: codecache full and compiler disabled in bigapps fastdebug run
never
parents: 3919
diff changeset
   205
  // false if another thread performed the transition.
4570
43d30f43697e 6914002: unsigned compare problem after 5057818
never
parents: 4564
diff changeset
   206
  bool make_not_entrant_or_zombie(unsigned int state);
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   207
  bool make_entrant() { Unimplemented(); return false; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
  void inc_decompile_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
  // Inform external interfaces that a compiled method has been unloaded
5924
dc9d04930c82 6965184: possible races in make_not_entrant_or_zombie
never
parents: 5896
diff changeset
   211
  void post_compiled_method_unload();
dc9d04930c82 6965184: possible races in make_not_entrant_or_zombie
never
parents: 5896
diff changeset
   212
dc9d04930c82 6965184: possible races in make_not_entrant_or_zombie
never
parents: 5896
diff changeset
   213
  // Initailize fields to their default values
dc9d04930c82 6965184: possible races in make_not_entrant_or_zombie
never
parents: 5896
diff changeset
   214
  void init_defaults();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   216
  // Offsets
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   217
  int content_offset() const                  { return content_begin() - header_begin(); }
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   218
  int data_offset() const                     { return _data_offset; }
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   219
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   220
  address header_end() const                  { return (address)    header_begin() + header_size(); }
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   221
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  // create nmethod with entry_bci
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 33160
diff changeset
   224
  static nmethod* new_nmethod(const methodHandle& method,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
                              int compile_id,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
                              int entry_bci,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
                              CodeOffsets* offsets,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
                              int orig_pc_offset,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
                              DebugInformationRecorder* recorder,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
                              Dependencies* dependencies,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
                              CodeBuffer *code_buffer,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
                              int frame_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
                              OopMapSet* oop_maps,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
                              ExceptionHandlerTable* handler_table,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
                              ImplicitExceptionTable* nul_chk_table,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
                              AbstractCompiler* compiler,
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32466
diff changeset
   237
                              int comp_level
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32466
diff changeset
   238
#if INCLUDE_JVMCI
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32466
diff changeset
   239
                              , Handle installed_code = Handle(),
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32466
diff changeset
   240
                              Handle speculation_log = Handle()
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32466
diff changeset
   241
#endif
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   242
  );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 33160
diff changeset
   244
  static nmethod* new_native_nmethod(const methodHandle& method,
8872
36680c58660e 7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents: 8724
diff changeset
   245
                                     int compile_id,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
                                     CodeBuffer *code_buffer,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
                                     int vep_offset,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
                                     int frame_complete,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
                                     int frame_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
                                     ByteSize receiver_sp_offset,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
                                     ByteSize basic_lock_sp_offset,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
                                     OopMapSet* oop_maps);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  // type info
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  bool is_nmethod() const                         { return true; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  bool is_osr_method() const                      { return _entry_bci != InvocationEntryBci; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
  // boundaries for different parts
6432
d36e09b60939 6961697: move nmethod constants section before instruction section
twisti
parents: 6418
diff changeset
   259
  address consts_begin          () const          { return           header_begin() + _consts_offset        ; }
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   260
  address consts_end            () const          { return           code_begin()                           ; }
6432
d36e09b60939 6961697: move nmethod constants section before instruction section
twisti
parents: 6418
diff changeset
   261
  address stub_begin            () const          { return           header_begin() + _stub_offset          ; }
d36e09b60939 6961697: move nmethod constants section before instruction section
twisti
parents: 6418
diff changeset
   262
  address stub_end              () const          { return           header_begin() + _oops_offset          ; }
4752
67a506670cd0 6921352: JSR 292 needs its own deopt handler
twisti
parents: 4750
diff changeset
   263
  address exception_begin       () const          { return           header_begin() + _exception_offset     ; }
5334
b2d040a8d375 6939930: exception unwind changes in 6919934 hurts compilation speed
never
parents: 4752
diff changeset
   264
  address unwind_handler_begin  () const          { return _unwind_handler_offset != -1 ? (header_begin() + _unwind_handler_offset) : NULL; }
5686
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
   265
  oop*    oops_begin            () const          { return (oop*)   (header_begin() + _oops_offset)         ; }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   266
  oop*    oops_end              () const          { return (oop*)   (header_begin() + _metadata_offset)     ; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   267
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   268
  Metadata** metadata_begin   () const            { return (Metadata**)  (header_begin() + _metadata_offset)     ; }
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   269
  Metadata** metadata_end     () const            { return (Metadata**)  _scopes_data_begin; }
5686
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
   270
4752
67a506670cd0 6921352: JSR 292 needs its own deopt handler
twisti
parents: 4750
diff changeset
   271
  address scopes_data_end       () const          { return           header_begin() + _scopes_pcs_offset    ; }
67a506670cd0 6921352: JSR 292 needs its own deopt handler
twisti
parents: 4750
diff changeset
   272
  PcDesc* scopes_pcs_begin      () const          { return (PcDesc*)(header_begin() + _scopes_pcs_offset   ); }
67a506670cd0 6921352: JSR 292 needs its own deopt handler
twisti
parents: 4750
diff changeset
   273
  PcDesc* scopes_pcs_end        () const          { return (PcDesc*)(header_begin() + _dependencies_offset) ; }
67a506670cd0 6921352: JSR 292 needs its own deopt handler
twisti
parents: 4750
diff changeset
   274
  address dependencies_begin    () const          { return           header_begin() + _dependencies_offset  ; }
67a506670cd0 6921352: JSR 292 needs its own deopt handler
twisti
parents: 4750
diff changeset
   275
  address dependencies_end      () const          { return           header_begin() + _handler_table_offset ; }
67a506670cd0 6921352: JSR 292 needs its own deopt handler
twisti
parents: 4750
diff changeset
   276
  address handler_table_begin   () const          { return           header_begin() + _handler_table_offset ; }
67a506670cd0 6921352: JSR 292 needs its own deopt handler
twisti
parents: 4750
diff changeset
   277
  address handler_table_end     () const          { return           header_begin() + _nul_chk_table_offset ; }
67a506670cd0 6921352: JSR 292 needs its own deopt handler
twisti
parents: 4750
diff changeset
   278
  address nul_chk_table_begin   () const          { return           header_begin() + _nul_chk_table_offset ; }
67a506670cd0 6921352: JSR 292 needs its own deopt handler
twisti
parents: 4750
diff changeset
   279
  address nul_chk_table_end     () const          { return           header_begin() + _nmethod_end_offset   ; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
5686
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
   281
  // Sizes
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
   282
  int oops_size         () const                  { return (address)  oops_end         () - (address)  oops_begin         (); }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   283
  int metadata_size     () const                  { return (address)  metadata_end     () - (address)  metadata_begin     (); }
5686
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
   284
  int dependencies_size () const                  { return            dependencies_end () -            dependencies_begin (); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
35086
bbf32241d851 8072008: Emit direct call instead of linkTo* for recursive indy/MH.invoke* calls
vlivanov
parents: 34185
diff changeset
   286
  int     oops_count() const { assert(oops_size() % oopSize == 0, "");  return (oops_size() / oopSize) + 1; }
bbf32241d851 8072008: Emit direct call instead of linkTo* for recursive indy/MH.invoke* calls
vlivanov
parents: 34185
diff changeset
   287
  int metadata_count() const { assert(metadata_size() % wordSize == 0, ""); return (metadata_size() / wordSize) + 1; }
bbf32241d851 8072008: Emit direct call instead of linkTo* for recursive indy/MH.invoke* calls
vlivanov
parents: 34185
diff changeset
   288
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
  int total_size        () const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
20290
2127dc70bce9 8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents: 19696
diff changeset
   291
  void dec_hotness_counter()        { _hotness_counter--; }
2127dc70bce9 8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents: 19696
diff changeset
   292
  void set_hotness_counter(int val) { _hotness_counter = val; }
2127dc70bce9 8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents: 19696
diff changeset
   293
  int  hotness_counter() const      { return _hotness_counter; }
2127dc70bce9 8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents: 19696
diff changeset
   294
5686
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
   295
  // Containment
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
   296
  bool oops_contains         (oop*    addr) const { return oops_begin         () <= addr && addr < oops_end         (); }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   297
  bool metadata_contains     (Metadata** addr) const   { return metadata_begin     () <= addr && addr < metadata_end     (); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
  bool scopes_data_contains  (address addr) const { return scopes_data_begin  () <= addr && addr < scopes_data_end  (); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  bool scopes_pcs_contains   (PcDesc* addr) const { return scopes_pcs_begin   () <= addr && addr < scopes_pcs_end   (); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  // entry points
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
  address entry_point() const                     { return _entry_point;             } // normal entry point
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  address verified_entry_point() const            { return _verified_entry_point;    } // if klass is correct
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
  // flag accessing and manipulation
22223
82e95c562133 8028107: Kitchensink crashed with EAV
kvn
parents: 20290
diff changeset
   306
  bool  is_in_use() const                         { return _state == in_use; }
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   307
  bool  is_alive() const                          { unsigned char s = _state; return s < zombie; }
5924
dc9d04930c82 6965184: possible races in make_not_entrant_or_zombie
never
parents: 5896
diff changeset
   308
  bool  is_not_entrant() const                    { return _state == not_entrant; }
dc9d04930c82 6965184: possible races in make_not_entrant_or_zombie
never
parents: 5896
diff changeset
   309
  bool  is_zombie() const                         { return _state == zombie; }
36802
18b1db5a7e70 8023191: OSR nmethods should be flushed to free space in CodeCache
thartmann
parents: 36300
diff changeset
   310
  bool  is_unloaded() const                       { return _state == unloaded; }
18b1db5a7e70 8023191: OSR nmethods should be flushed to free space in CodeCache
thartmann
parents: 36300
diff changeset
   311
23491
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22506
diff changeset
   312
#if INCLUDE_RTM_OPT
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22506
diff changeset
   313
  // rtm state accessing and manipulating
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22506
diff changeset
   314
  RTMState  rtm_state() const                     { return _rtm_state; }
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22506
diff changeset
   315
  void set_rtm_state(RTMState state)              { _rtm_state = state; }
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22506
diff changeset
   316
#endif
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22506
diff changeset
   317
4479
5686407cde7a 5057818: codecache full and compiler disabled in bigapps fastdebug run
never
parents: 3919
diff changeset
   318
  // Make the nmethod non entrant. The nmethod will continue to be
5686407cde7a 5057818: codecache full and compiler disabled in bigapps fastdebug run
never
parents: 3919
diff changeset
   319
  // alive.  It is used when an uncommon trap happens.  Returns true
5686407cde7a 5057818: codecache full and compiler disabled in bigapps fastdebug run
never
parents: 3919
diff changeset
   320
  // if this thread changed the state of the nmethod or false if
5686407cde7a 5057818: codecache full and compiler disabled in bigapps fastdebug run
never
parents: 3919
diff changeset
   321
  // another thread performed the transition.
26580
8cca7fbe77b8 8056154: JVM crash with EXCEPTION_ACCESS_VIOLATION when there are many threads running
iveresov
parents: 25740
diff changeset
   322
  bool  make_not_entrant() {
8cca7fbe77b8 8056154: JVM crash with EXCEPTION_ACCESS_VIOLATION when there are many threads running
iveresov
parents: 25740
diff changeset
   323
    assert(!method()->is_method_handle_intrinsic(), "Cannot make MH intrinsic not entrant");
8cca7fbe77b8 8056154: JVM crash with EXCEPTION_ACCESS_VIOLATION when there are many threads running
iveresov
parents: 25740
diff changeset
   324
    return make_not_entrant_or_zombie(not_entrant);
8cca7fbe77b8 8056154: JVM crash with EXCEPTION_ACCESS_VIOLATION when there are many threads running
iveresov
parents: 25740
diff changeset
   325
  }
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   326
  bool  make_not_used()    { return make_not_entrant(); }
20290
2127dc70bce9 8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents: 19696
diff changeset
   327
  bool  make_zombie()      { return make_not_entrant_or_zombie(zombie); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
  // used by jvmti to track if the unload event has been reported
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  bool  unload_reported()                         { return _unload_reported; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
  void  set_unload_reported()                     { _unload_reported = true; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   333
  int get_state() const {
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   334
    return _state;
36300
5b47f168b948 7177745: JSR292: Many Callsite relinkages cause target method to always run in interpreter mode
vlivanov
parents: 36078
diff changeset
   335
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  void  make_unloaded(BoolObjectClosure* is_alive, oop cause);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  bool has_dependencies()                         { return dependencies_size() != 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  void flush_dependencies(BoolObjectClosure* is_alive);
5924
dc9d04930c82 6965184: possible races in make_not_entrant_or_zombie
never
parents: 5896
diff changeset
   341
  bool has_flushed_dependencies()                 { return _has_flushed_dependencies; }
dc9d04930c82 6965184: possible races in make_not_entrant_or_zombie
never
parents: 5896
diff changeset
   342
  void set_has_flushed_dependencies()             {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
    assert(!has_flushed_dependencies(), "should only happen once");
5924
dc9d04930c82 6965184: possible races in make_not_entrant_or_zombie
never
parents: 5896
diff changeset
   344
    _has_flushed_dependencies = 1;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
  int   comp_level() const                        { return _comp_level; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
5686
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
   349
  // Support for oops in scopes and relocs:
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
   350
  // Note: index 0 is reserved for null.
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
   351
  oop   oop_at(int index) const                   { return index == 0 ? (oop) NULL: *oop_addr_at(index); }
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
   352
  oop*  oop_addr_at(int index) const {  // for GC
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
   353
    // relocation indexes are biased by 1 (because 0 is reserved)
35086
bbf32241d851 8072008: Emit direct call instead of linkTo* for recursive indy/MH.invoke* calls
vlivanov
parents: 34185
diff changeset
   354
    assert(index > 0 && index <= oops_count(), "must be a valid non-zero index");
6268
9e96dde307e9 6974176: ShouldNotReachHere, instanceKlass.cpp:1426
never
parents: 6187
diff changeset
   355
    assert(!_oops_are_stale, "oops are stale");
5686
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
   356
    return &oops_begin()[index - 1];
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
   357
  }
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
   358
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   359
  // Support for meta data in scopes and relocs:
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   360
  // Note: index 0 is reserved for null.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   361
  Metadata*     metadata_at(int index) const      { return index == 0 ? NULL: *metadata_addr_at(index); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   362
  Metadata**  metadata_addr_at(int index) const {  // for GC
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   363
    // relocation indexes are biased by 1 (because 0 is reserved)
35086
bbf32241d851 8072008: Emit direct call instead of linkTo* for recursive indy/MH.invoke* calls
vlivanov
parents: 34185
diff changeset
   364
    assert(index > 0 && index <= metadata_count(), "must be a valid non-zero index");
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   365
    return &metadata_begin()[index - 1];
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   366
  }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   367
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   368
  void copy_values(GrowableArray<jobject>* oops);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   369
  void copy_values(GrowableArray<Metadata*>* metadata);
5686
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
   370
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
   371
  // Relocation support
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
   372
private:
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
   373
  void fix_oop_relocations(address begin, address end, bool initialize_immediates);
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
   374
  inline void initialize_immediate_oop(oop* dest, jobject handle);
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
   375
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
   376
public:
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
   377
  void fix_oop_relocations(address begin, address end) { fix_oop_relocations(begin, end, false); }
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
   378
  void fix_oop_relocations()                           { fix_oop_relocations(NULL, NULL, false); }
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
   379
9935
51267b5e1a3d 7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents: 8872
diff changeset
   380
  // Scavengable oop support
3908
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2131
diff changeset
   381
  bool  on_scavenge_root_list() const                  { return (_scavenge_root_state & 1) != 0; }
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2131
diff changeset
   382
 protected:
9935
51267b5e1a3d 7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents: 8872
diff changeset
   383
  enum { sl_on_list = 0x01, sl_marked = 0x10 };
51267b5e1a3d 7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents: 8872
diff changeset
   384
  void  set_on_scavenge_root_list()                    { _scavenge_root_state = sl_on_list; }
3908
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2131
diff changeset
   385
  void  clear_on_scavenge_root_list()                  { _scavenge_root_state = 0; }
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2131
diff changeset
   386
  // assertion-checking and pruning logic uses the bits of _scavenge_root_state
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2131
diff changeset
   387
#ifndef PRODUCT
9935
51267b5e1a3d 7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents: 8872
diff changeset
   388
  void  set_scavenge_root_marked()                     { _scavenge_root_state |= sl_marked; }
51267b5e1a3d 7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents: 8872
diff changeset
   389
  void  clear_scavenge_root_marked()                   { _scavenge_root_state &= ~sl_marked; }
51267b5e1a3d 7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents: 8872
diff changeset
   390
  bool  scavenge_root_not_marked()                     { return (_scavenge_root_state &~ sl_on_list) == 0; }
3908
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2131
diff changeset
   391
  // N.B. there is no positive marked query, and we only use the not_marked query for asserts.
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2131
diff changeset
   392
#endif //PRODUCT
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2131
diff changeset
   393
  nmethod* scavenge_root_link() const                  { return _scavenge_root_link; }
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2131
diff changeset
   394
  void     set_scavenge_root_link(nmethod *n)          { _scavenge_root_link = n; }
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2131
diff changeset
   395
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2131
diff changeset
   396
 public:
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2131
diff changeset
   397
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  // Sweeper support
47099
49f5fa3fc2ae 8186837: Memory ordering nmethod, _state and _stack_traversal_mark
rehn
parents: 46702
diff changeset
   399
  long  stack_traversal_mark()                    { return _stack_traversal_mark; }
49f5fa3fc2ae 8186837: Memory ordering nmethod, _state and _stack_traversal_mark
rehn
parents: 46702
diff changeset
   400
  void  set_stack_traversal_mark(long l)          { _stack_traversal_mark = l; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
  // implicit exceptions support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
  address continuation_for_implicit_exception(address pc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
  // On-stack replacement support
8872
36680c58660e 7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents: 8724
diff changeset
   406
  int   osr_entry_bci() const                     { assert(is_osr_method(), "wrong kind of nmethod"); return _entry_bci; }
36680c58660e 7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents: 8724
diff changeset
   407
  address  osr_entry() const                      { assert(is_osr_method(), "wrong kind of nmethod"); return _osr_entry_point; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
  void  invalidate_osr_method();
3908
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2131
diff changeset
   409
  nmethod* osr_link() const                       { return _osr_link; }
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2131
diff changeset
   410
  void     set_osr_link(nmethod *n)               { _osr_link = n; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
25492
d27050bdfb04 8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents: 25491
diff changeset
   412
  // Verify calls to dead methods have been cleaned.
d27050bdfb04 8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents: 25491
diff changeset
   413
  void verify_clean_inline_caches();
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   414
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
  // unlink and deallocate this nmethod
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
  // Only NMethodSweeper class is expected to use this. NMethodSweeper is not
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  // expected to use any other private methods/data in this class.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
  void flush();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
 public:
8661
3dc8a18ac563 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue
dcubed
parents: 8495
diff changeset
   423
  // When true is returned, it is unsafe to remove this nmethod even if
3dc8a18ac563 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue
dcubed
parents: 8495
diff changeset
   424
  // it is a zombie, since the VM or the ServiceThread might still be
3dc8a18ac563 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue
dcubed
parents: 8495
diff changeset
   425
  // using it.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  bool is_locked_by_vm() const                    { return _lock_count >0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
  // See comment at definition of _last_seen_on_stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
  void mark_as_seen_on_stack();
32466
915d0c3d25aa 8134493: Cleaning inline caches of unloaded nmethods should be done in sweeper
thartmann
parents: 29576
diff changeset
   430
  bool can_convert_to_zombie();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   432
  // Evolution support. We make old (discarded) compiled methods point to new Method*s.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   433
  void set_method(Method* method) { _method = method; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32466
diff changeset
   435
#if INCLUDE_JVMCI
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32466
diff changeset
   436
  oop jvmci_installed_code() { return _jvmci_installed_code ; }
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32466
diff changeset
   437
  char* jvmci_installed_code_name(char* buf, size_t buflen);
35092
82170e5767c3 8143571: [JVMCI] Double unregistering of nmethod during unloading
never
parents: 35086
diff changeset
   438
82170e5767c3 8143571: [JVMCI] Double unregistering of nmethod during unloading
never
parents: 35086
diff changeset
   439
  // Update the state of any InstalledCode instance associated with
82170e5767c3 8143571: [JVMCI] Double unregistering of nmethod during unloading
never
parents: 35086
diff changeset
   440
  // this nmethod based on the current value of _state.
33632
038347770a9e 8139170: JVMCI refresh
twisti
parents: 33160
diff changeset
   441
  void maybe_invalidate_installed_code();
35092
82170e5767c3 8143571: [JVMCI] Double unregistering of nmethod during unloading
never
parents: 35086
diff changeset
   442
82170e5767c3 8143571: [JVMCI] Double unregistering of nmethod during unloading
never
parents: 35086
diff changeset
   443
  // Helper function to invalidate InstalledCode instances
82170e5767c3 8143571: [JVMCI] Double unregistering of nmethod during unloading
never
parents: 35086
diff changeset
   444
  static void invalidate_installed_code(Handle installed_code, TRAPS);
82170e5767c3 8143571: [JVMCI] Double unregistering of nmethod during unloading
never
parents: 35086
diff changeset
   445
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32466
diff changeset
   446
  oop speculation_log() { return _speculation_log ; }
35092
82170e5767c3 8143571: [JVMCI] Double unregistering of nmethod during unloading
never
parents: 35086
diff changeset
   447
82170e5767c3 8143571: [JVMCI] Double unregistering of nmethod during unloading
never
parents: 35086
diff changeset
   448
 private:
82170e5767c3 8143571: [JVMCI] Double unregistering of nmethod during unloading
never
parents: 35086
diff changeset
   449
  void clear_jvmci_installed_code();
82170e5767c3 8143571: [JVMCI] Double unregistering of nmethod during unloading
never
parents: 35086
diff changeset
   450
82170e5767c3 8143571: [JVMCI] Double unregistering of nmethod during unloading
never
parents: 35086
diff changeset
   451
 public:
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32466
diff changeset
   452
#endif
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32466
diff changeset
   453
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   454
 protected:
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   455
  virtual bool do_unloading_oops(address low_boundary, BoolObjectClosure* is_alive, bool unloading_occurred);
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   456
#if INCLUDE_JVMCI
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   457
  virtual bool do_unloading_jvmci(BoolObjectClosure* is_alive, bool unloading_occurred);
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   458
#endif
27247
99db666dbe8e 8056240: Investigate increased GC remark time after class unloading changes in CRM Fuse
stefank
parents: 26912
diff changeset
   459
99db666dbe8e 8056240: Investigate increased GC remark time after class unloading changes in CRM Fuse
stefank
parents: 26912
diff changeset
   460
 private:
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   461
  bool do_unloading_scopes(BoolObjectClosure* is_alive, bool unloading_occurred);
25492
d27050bdfb04 8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents: 25491
diff changeset
   462
  //  Unload a nmethod if the *root object is dead.
13878
6e6a462a6cff 7200470: KeepAliveClosure not needed in CodeCache::do_unloading
brutisso
parents: 13728
diff changeset
   463
  bool can_unload(BoolObjectClosure* is_alive, oop* root, bool unloading_occurred);
27247
99db666dbe8e 8056240: Investigate increased GC remark time after class unloading changes in CRM Fuse
stefank
parents: 26912
diff changeset
   464
  bool unload_if_dead_at(RelocIterator *iter_at_oop, BoolObjectClosure* is_alive, bool unloading_occurred);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
27247
99db666dbe8e 8056240: Investigate increased GC remark time after class unloading changes in CRM Fuse
stefank
parents: 26912
diff changeset
   466
 public:
5686
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5533
diff changeset
   467
  void oops_do(OopClosure* f) { oops_do(f, false); }
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 13897
diff changeset
   468
  void oops_do(OopClosure* f, bool allow_zombie);
3908
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2131
diff changeset
   469
  bool detect_scavenge_root_oops();
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2131
diff changeset
   470
  void verify_scavenge_root_oops() PRODUCT_RETURN;
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2131
diff changeset
   471
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2131
diff changeset
   472
  bool test_set_oops_do_mark();
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2131
diff changeset
   473
  static void oops_do_marking_prologue();
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2131
diff changeset
   474
  static void oops_do_marking_epilogue();
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2131
diff changeset
   475
  static bool oops_do_marking_is_active() { return _oops_do_mark_nmethods != NULL; }
12270
9625585c6047 7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents: 11637
diff changeset
   476
  bool test_oops_do_mark() { return _oops_do_mark_link != NULL; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
  ScopeDesc* scope_desc_in(address begin, address end);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
4752
67a506670cd0 6921352: JSR 292 needs its own deopt handler
twisti
parents: 4750
diff changeset
   481
  address* orig_pc_addr(const frame* fr) { return (address*) ((address)fr->unextended_sp() + _orig_pc_offset); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
  // copying of debugging information
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  void copy_scopes_pcs(PcDesc* pcs, int count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
  void copy_scopes_data(address buffer, int size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
  // Accessor/mutator for the original pc of a frame before a frame was deopted.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
  address get_original_pc(const frame* fr) { return *orig_pc_addr(fr); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
  void    set_original_pc(const frame* fr, address pc) { *orig_pc_addr(fr) = pc; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
  // jvmti support:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
  void post_compiled_method_load_event();
5896
c60924a89622 6656830: assert((*p)->is_oop(),"expected an oop while scanning weak refs")
never
parents: 5702
diff changeset
   494
  jmethodID get_and_cache_jmethod_id();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
  // verify operations
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  void verify();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
  void verify_scopes();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
  void verify_interrupt_point(address interrupt_point);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
  // printing support
347
df859fcca515 6667042: PrintAssembly option does not work without special plugin
jrose
parents: 1
diff changeset
   502
  void print()                          const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
  void print_relocations()                        PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
  void print_pcs()                                PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
  void print_scopes()                             PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
  void print_dependencies()                       PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
  void print_value_on(outputStream* st) const     PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
  void print_calls(outputStream* st)              PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
  void print_handler_table()                      PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
  void print_nul_chk_table()                      PRODUCT_RETURN;
35086
bbf32241d851 8072008: Emit direct call instead of linkTo* for recursive indy/MH.invoke* calls
vlivanov
parents: 34185
diff changeset
   511
  void print_recorded_oops()                      PRODUCT_RETURN;
bbf32241d851 8072008: Emit direct call instead of linkTo* for recursive indy/MH.invoke* calls
vlivanov
parents: 34185
diff changeset
   512
  void print_recorded_metadata()                  PRODUCT_RETURN;
36078
954c49c0ba57 8149969: [JVMCI] PrintNMethods is ignored for CompilerToVM.installCode when not called from the broker
never
parents: 35542
diff changeset
   513
954c49c0ba57 8149969: [JVMCI] PrintNMethods is ignored for CompilerToVM.installCode when not called from the broker
never
parents: 35542
diff changeset
   514
  void maybe_print_nmethod(DirectiveSet* directive);
347
df859fcca515 6667042: PrintAssembly option does not work without special plugin
jrose
parents: 1
diff changeset
   515
  void print_nmethod(bool print_code);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
6176
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   517
  // need to re-define this from CodeBlob else the overload hides it
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   518
  virtual void print_on(outputStream* st) const { CodeBlob::print_on(st); }
8872
36680c58660e 7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents: 8724
diff changeset
   519
  void print_on(outputStream* st, const char* msg) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
  // Logging
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
  void log_identity(xmlStream* log) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
  void log_new_nmethod() const;
4479
5686407cde7a 5057818: codecache full and compiler disabled in bigapps fastdebug run
never
parents: 3919
diff changeset
   524
  void log_state_change() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
4584
e2a449e8cc6f 6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents: 4570
diff changeset
   526
  // Prints block-level comments, including nmethod specific block labels:
13887
89b873bcc55b 7200163: add CodeComments functionality to assember stubs
kvn
parents: 13883
diff changeset
   527
  virtual void print_block_comment(outputStream* stream, address block_begin) const {
4584
e2a449e8cc6f 6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents: 4570
diff changeset
   528
    print_nmethod_labels(stream, block_begin);
e2a449e8cc6f 6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents: 4570
diff changeset
   529
    CodeBlob::print_block_comment(stream, block_begin);
e2a449e8cc6f 6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents: 4570
diff changeset
   530
  }
13887
89b873bcc55b 7200163: add CodeComments functionality to assember stubs
kvn
parents: 13883
diff changeset
   531
  void print_nmethod_labels(outputStream* stream, address block_begin) const;
4584
e2a449e8cc6f 6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents: 4570
diff changeset
   532
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
  // Prints a comment for one native instruction (reloc info, pc desc)
347
df859fcca515 6667042: PrintAssembly option does not work without special plugin
jrose
parents: 1
diff changeset
   534
  void print_code_comment_on(outputStream* st, int column, address begin, address end);
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32466
diff changeset
   535
  static void print_statistics() PRODUCT_RETURN;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
  // Compiler task identification.  Note that all OSR methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
  // are numbered in an independent sequence if CICountOSR is true,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
  // and native method wrappers are also numbered independently if
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
  // CICountNative is true.
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   541
  virtual int compile_id() const { return _compile_id; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
  const char* compile_kind() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
  // tells if any of this method's dependencies have been invalidated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
  // (this is expensive!)
22506
0759c126204d 7194669: CodeCache::mark_for_deoptimization should avoid verifying dependencies multiple times
anoll
parents: 22223
diff changeset
   546
  static void check_all_dependencies(DepChange& changes);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
  // tells if this compiled method is dependent on the given changes,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
  // and the changes have invalidated it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
  bool check_dependency_on(DepChange& changes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
  // Evolution support. Tells if this compiled method is dependent on any of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
  // methods m() of class dependee, such that if m() in dependee is replaced,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
  // this compiled method will have to be deoptimized.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   555
  bool is_evol_dependent_on(Klass* dependee);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
  // Fast breakpoint support. Tells if this compiled method is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
  // dependent on the given method. Returns true if this nmethod
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
  // corresponds to the given method as well.
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   560
  virtual bool is_dependent_on_method(Method* dependee);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
  // is it ok to patch at address?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
  bool is_patchable_at(address instr_address);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
  // UseBiasedLocking support
7444
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7397
diff changeset
   566
  ByteSize native_receiver_sp_offset() {
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7397
diff changeset
   567
    return _native_receiver_sp_offset;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
  }
7444
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7397
diff changeset
   569
  ByteSize native_basic_lock_sp_offset() {
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7397
diff changeset
   570
    return _native_basic_lock_sp_offset;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
  // support for code generation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
  static int verified_entry_point_offset()        { return offset_of(nmethod, _verified_entry_point); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
  static int osr_entry_point_offset()             { return offset_of(nmethod, _osr_entry_point); }
26705
fca1785e7084 8048721: -XX:+PrintCompilation prints negative bci for non entrant OSR methods
thartmann
parents: 26580
diff changeset
   576
  static int state_offset()                       { return offset_of(nmethod, _state); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   578
  virtual void metadata_do(void f(Metadata*));
42650
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   579
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   580
  NativeCallWrapper* call_wrapper_at(address call) const;
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   581
  NativeCallWrapper* call_wrapper_before(address return_pc) const;
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   582
  address call_instruction_address(address pc) const;
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   583
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   584
  virtual CompiledStaticCall* compiledStaticCall_at(Relocation* call_site) const;
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   585
  virtual CompiledStaticCall* compiledStaticCall_at(address addr) const;
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   586
  virtual CompiledStaticCall* compiledStaticCall_before(address addr) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
8661
3dc8a18ac563 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue
dcubed
parents: 8495
diff changeset
   589
// Locks an nmethod so its code will not get removed and it will not
3dc8a18ac563 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue
dcubed
parents: 8495
diff changeset
   590
// be made into a zombie, even if it is a not_entrant method. After the
3dc8a18ac563 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue
dcubed
parents: 8495
diff changeset
   591
// nmethod becomes a zombie, if CompiledMethodUnload event processing
3dc8a18ac563 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue
dcubed
parents: 8495
diff changeset
   592
// needs to be done, then lock_nmethod() is used directly to keep the
3dc8a18ac563 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue
dcubed
parents: 8495
diff changeset
   593
// generated code from being reused too early.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
class nmethodLocker : public StackObj {
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   595
  CompiledMethod* _nm;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
8110
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7444
diff changeset
   597
 public:
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7444
diff changeset
   598
8661
3dc8a18ac563 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue
dcubed
parents: 8495
diff changeset
   599
  // note: nm can be NULL
3dc8a18ac563 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue
dcubed
parents: 8495
diff changeset
   600
  // Only JvmtiDeferredEvent::compiled_method_unload_event()
3dc8a18ac563 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue
dcubed
parents: 8495
diff changeset
   601
  // should pass zombie_ok == true.
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   602
  static void lock_nmethod(CompiledMethod* nm, bool zombie_ok = false);
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   603
  static void unlock_nmethod(CompiledMethod* nm); // (ditto)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
  nmethodLocker(address pc); // derive nm from pc
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
  nmethodLocker(nmethod *nm) { _nm = nm; lock_nmethod(_nm); }
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   607
  nmethodLocker(CompiledMethod *nm) {
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   608
    _nm = nm;
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   609
    lock(_nm);
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   610
  }
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   611
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   612
  static void lock(CompiledMethod* method) {
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   613
    if (method == NULL) return;
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   614
    lock_nmethod(method);
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   615
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   617
  static void unlock(CompiledMethod* method) {
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   618
    if (method == NULL) return;
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   619
    unlock_nmethod(method);
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   620
  }
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   621
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   622
  nmethodLocker() { _nm = NULL; }
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   623
  ~nmethodLocker() {
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   624
    unlock(_nm);
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   625
  }
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   626
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   627
  CompiledMethod* code() { return _nm; }
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   628
  void set_code(CompiledMethod* new_nm) {
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   629
    unlock(_nm);   // note:  This works even if _nm==new_nm.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
    _nm = new_nm;
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38043
diff changeset
   631
    lock(_nm);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
};
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
   634
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
   635
#endif // SHARE_VM_CODE_NMETHOD_HPP