src/hotspot/share/oops/method.hpp
author coleenp
Thu, 10 Jan 2019 15:13:51 -0500
changeset 53244 9807daeb47c4
parent 53149 259c36ef27df
child 53432 1ec56532ae0c
permissions -rw-r--r--
8216167: Update include guards to reflect correct directories Summary: Use script and some manual fixup to fix directores names in include guards. Reviewed-by: lfoltan, eosterlund, kbarrett
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
53149
259c36ef27df 8215731: Move forward class definitions out of globalDefinitions.hpp
coleenp
parents: 51263
diff changeset
     2
 * Copyright (c) 1997, 2019, 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: 5420
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5420
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: 5420
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
53244
9807daeb47c4 8216167: Update include guards to reflect correct directories
coleenp
parents: 53149
diff changeset
    25
#ifndef SHARE_OOPS_METHOD_HPP
9807daeb47c4 8216167: Update include guards to reflect correct directories
coleenp
parents: 53149
diff changeset
    26
#define SHARE_OOPS_METHOD_HPP
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6974
diff changeset
    27
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6974
diff changeset
    28
#include "classfile/vmSymbols.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6974
diff changeset
    29
#include "code/compressedStream.hpp"
42040
70ec5a09a0d5 8166377: is_compiled_by_jvmci hot in some profiles - improve nmethod compiler type detection
neliasso
parents: 41715
diff changeset
    30
#include "compiler/compilerDefinitions.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6974
diff changeset
    31
#include "compiler/oopMap.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6974
diff changeset
    32
#include "interpreter/invocationCounter.hpp"
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
    33
#include "oops/annotations.hpp"
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
    34
#include "oops/constantPool.hpp"
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
    35
#include "oops/methodCounters.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6974
diff changeset
    36
#include "oops/instanceKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6974
diff changeset
    37
#include "oops/oop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6974
diff changeset
    38
#include "oops/typeArrayOop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6974
diff changeset
    39
#include "utilities/accessFlags.hpp"
46625
edefffab74e2 8183552: Move align functions to align.hpp
stefank
parents: 46619
diff changeset
    40
#include "utilities/align.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6974
diff changeset
    41
#include "utilities/growableArray.hpp"
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents: 49348
diff changeset
    42
#include "utilities/macros.hpp"
caf115bb98ad 8199712: Flight Recorder
egahlin
parents: 49348
diff changeset
    43
#if INCLUDE_JFR
caf115bb98ad 8199712: Flight Recorder
egahlin
parents: 49348
diff changeset
    44
#include "jfr/support/jfrTraceIdExtension.hpp"
caf115bb98ad 8199712: Flight Recorder
egahlin
parents: 49348
diff changeset
    45
#endif
caf115bb98ad 8199712: Flight Recorder
egahlin
parents: 49348
diff changeset
    46
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6974
diff changeset
    47
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 20710
diff changeset
    48
// A Method represents a Java method.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
//
23515
f4872ef5df09 8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents: 23219
diff changeset
    50
// Note that most applications load thousands of methods, so keeping the size of this
f4872ef5df09 8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents: 23219
diff changeset
    51
// class small has a big impact on footprint.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
//
23515
f4872ef5df09 8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents: 23219
diff changeset
    53
// Note that native_function and signature_handler have to be at fixed offsets
f4872ef5df09 8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents: 23219
diff changeset
    54
// (required by the interpreter)
f4872ef5df09 8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents: 23219
diff changeset
    55
//
f4872ef5df09 8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents: 23219
diff changeset
    56
//  Method embedded field layout (after declared fields):
f4872ef5df09 8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents: 23219
diff changeset
    57
//   [EMBEDDED native_function       (present only if native) ]
f4872ef5df09 8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents: 23219
diff changeset
    58
//   [EMBEDDED signature_handler     (present only if native) ]
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
class CheckedExceptionElement;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
class LocalVariableTableElement;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
class AdapterHandlerEntry;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
    63
class MethodData;
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
    64
class MethodCounters;
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
    65
class ConstMethod;
15601
df8faef6efaf 8007320: NPG: move method annotations
coleenp
parents: 15595
diff changeset
    66
class InlineTableSizes;
15437
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 15110
diff changeset
    67
class KlassSizeStats;
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 37449
diff changeset
    68
class CompiledMethod;
53149
259c36ef27df 8215731: Move forward class definitions out of globalDefinitions.hpp
coleenp
parents: 51263
diff changeset
    69
class InterpreterOopMap;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
    71
class Method : public Metadata {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
 friend class VMStructs;
35123
b0b89d83bcf5 8134994: use separate VMStructs databases for SA and JVMCI
twisti
parents: 34185
diff changeset
    73
 friend class JVMCIVMStructs;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
 private:
46746
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46727
diff changeset
    75
  // If you add a new field that points to any metaspace object, you
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46727
diff changeset
    76
  // must add this field to Method::metaspace_pointers_do().
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
    77
  ConstMethod*      _constMethod;                // Method read-only data.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
    78
  MethodData*       _method_data;
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
    79
  MethodCounters*   _method_counters;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  AccessFlags       _access_flags;               // Access flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  int               _vtable_index;               // vtable index of this method (see VtableIndexFlag)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
                                                 // note: can have vtables with >2**16 elements (because of inheritance)
32820
ec181adbf3b1 8135085: Change Method::_intrinsic_id from u1 to u2
minqi
parents: 31790
diff changeset
    83
  u2                _intrinsic_id;               // vmSymbols::intrinsic_id (0 == _none)
23219
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
    84
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
    85
  // Flags
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
    86
  enum Flags {
43453
a2097d148d0e 8171960: Event-based tracing needs separate flag representation for Method
mgronlun
parents: 42650
diff changeset
    87
    _caller_sensitive      = 1 << 0,
a2097d148d0e 8171960: Event-based tracing needs separate flag representation for Method
mgronlun
parents: 42650
diff changeset
    88
    _force_inline          = 1 << 1,
a2097d148d0e 8171960: Event-based tracing needs separate flag representation for Method
mgronlun
parents: 42650
diff changeset
    89
    _dont_inline           = 1 << 2,
a2097d148d0e 8171960: Event-based tracing needs separate flag representation for Method
mgronlun
parents: 42650
diff changeset
    90
    _hidden                = 1 << 3,
a2097d148d0e 8171960: Event-based tracing needs separate flag representation for Method
mgronlun
parents: 42650
diff changeset
    91
    _has_injected_profile  = 1 << 4,
a2097d148d0e 8171960: Event-based tracing needs separate flag representation for Method
mgronlun
parents: 42650
diff changeset
    92
    _running_emcp          = 1 << 5,
a2097d148d0e 8171960: Event-based tracing needs separate flag representation for Method
mgronlun
parents: 42650
diff changeset
    93
    _intrinsic_candidate   = 1 << 6,
a2097d148d0e 8171960: Event-based tracing needs separate flag representation for Method
mgronlun
parents: 42650
diff changeset
    94
    _reserved_stack_access = 1 << 7
23219
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
    95
  };
35071
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 34666
diff changeset
    96
  mutable u2 _flags;
8667
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
    97
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents: 49348
diff changeset
    98
  JFR_ONLY(DEFINE_TRACE_FLAG;)
43453
a2097d148d0e 8171960: Event-based tracing needs separate flag representation for Method
mgronlun
parents: 42650
diff changeset
    99
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  int               _compiled_invocation_count;  // Number of nmethod invocations so far (for perf. debugging)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  // Entry point for calling both from and to the interpreter.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  address _i2i_entry;           // All-args-on-stack calling convention
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  // Entry point for calling from compiled code, to compiled code if it exists
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  // or else the interpreter.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  volatile address _from_compiled_entry;        // Cache of: _code ? _code->entry_point() : _adapter->c2i_entry()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  // The entry point for calling both from and to compiled code is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  // "_code->entry_point()".  Because of tiered compilation and de-opt, this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  // field can come and go.  It can transition from NULL to not-null at any
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
  // time (whenever a compile completes).  It can transition from not-null to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
  // NULL only at safepoints (because of a de-opt).
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 37449
diff changeset
   113
  CompiledMethod* volatile _code;                       // Points to the corresponding piece of native code
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
  volatile address           _from_interpreted_entry; // Cache of _code ? _adapter->i2c_entry() : _i2i_entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
42650
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   116
#if INCLUDE_AOT && defined(TIERED)
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   117
  CompiledMethod* _aot_code;
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   118
#endif
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   119
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   120
  // Constructor
33209
43d7a2139756 8135284: Remove Method::_method_size field
minqi
parents: 32820
diff changeset
   121
  Method(ConstMethod* xconst, AccessFlags access_flags);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
 public:
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   123
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   124
  static Method* allocate(ClassLoaderData* loader_data,
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   125
                          int byte_code_size,
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   126
                          AccessFlags access_flags,
15601
df8faef6efaf 8007320: NPG: move method annotations
coleenp
parents: 15595
diff changeset
   127
                          InlineTableSizes* sizes,
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   128
                          ConstMethod::MethodType method_type,
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   129
                          TRAPS);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   130
14579
7f6ce6e3dd80 8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents: 14391
diff changeset
   131
  // CDS and vtbl checking can create an empty Method to get vtbl pointer.
7f6ce6e3dd80 8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents: 14391
diff changeset
   132
  Method(){}
13736
5b15a8f57979 7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type
coleenp
parents: 13728
diff changeset
   133
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   134
  bool is_method() const volatile { return true; }
1894
5c343868d071 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents: 670
diff changeset
   135
23872
536c66fc43d3 8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents: 23534
diff changeset
   136
  void restore_unshareable_info(TRAPS);
536c66fc43d3 8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents: 23534
diff changeset
   137
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  // accessors for instance variables
13736
5b15a8f57979 7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type
coleenp
parents: 13728
diff changeset
   139
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   140
  ConstMethod* constMethod() const             { return _constMethod; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   141
  void set_constMethod(ConstMethod* xconst)    { _constMethod = xconst; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
46727
6e4a84748e2c 8183039: Re-examine methodHandle methods uninlined by 8144256
coleenp
parents: 46625
diff changeset
   144
  static address make_adapters(const methodHandle& mh, TRAPS);
49340
4e82736053ae 8191102: Incorrect include file use in classLoader.hpp
hseigel
parents: 48557
diff changeset
   145
  address from_compiled_entry() const;
47634
6a0c42c40cd1 8188220: Remove Atomic::*_ptr() uses and overloads from hotspot
coleenp
parents: 47216
diff changeset
   146
  address from_compiled_entry_no_trampoline() const;
49340
4e82736053ae 8191102: Incorrect include file use in classLoader.hpp
hseigel
parents: 48557
diff changeset
   147
  address from_interpreted_entry() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  // access flag
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  AccessFlags access_flags() const               { return _access_flags;  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  void set_access_flags(AccessFlags flags)       { _access_flags = flags; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  // name
12937
0032fb2caff6 7172967: Eliminate constMethod's _method backpointer to methodOop.
jiangli
parents: 11637
diff changeset
   154
  Symbol* name() const                           { return constants()->symbol_at(name_index()); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  int name_index() const                         { return constMethod()->name_index();         }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  void set_name_index(int index)                 { constMethod()->set_name_index(index);       }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  // signature
12937
0032fb2caff6 7172967: Eliminate constMethod's _method backpointer to methodOop.
jiangli
parents: 11637
diff changeset
   159
  Symbol* signature() const                      { return constants()->symbol_at(signature_index()); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  int signature_index() const                    { return constMethod()->signature_index();         }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  void set_signature_index(int index)            { constMethod()->set_signature_index(index);       }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  // generics support
12937
0032fb2caff6 7172967: Eliminate constMethod's _method backpointer to methodOop.
jiangli
parents: 11637
diff changeset
   164
  Symbol* generic_signature() const              { int idx = generic_signature_index(); return ((idx != 0) ? constants()->symbol_at(idx) : (Symbol*)NULL); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  int generic_signature_index() const            { return constMethod()->generic_signature_index(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  void set_generic_signature_index(int index)    { constMethod()->set_generic_signature_index(index); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  // annotations support
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   169
  AnnotationArray* annotations() const           {
15601
df8faef6efaf 8007320: NPG: move method annotations
coleenp
parents: 15595
diff changeset
   170
    return constMethod()->method_annotations();
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   171
  }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   172
  AnnotationArray* parameter_annotations() const {
15601
df8faef6efaf 8007320: NPG: move method annotations
coleenp
parents: 15595
diff changeset
   173
    return constMethod()->parameter_annotations();
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   174
  }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   175
  AnnotationArray* annotation_default() const    {
15601
df8faef6efaf 8007320: NPG: move method annotations
coleenp
parents: 15595
diff changeset
   176
    return constMethod()->default_annotations();
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   177
  }
15601
df8faef6efaf 8007320: NPG: move method annotations
coleenp
parents: 15595
diff changeset
   178
  AnnotationArray* type_annotations() const      {
df8faef6efaf 8007320: NPG: move method annotations
coleenp
parents: 15595
diff changeset
   179
    return constMethod()->type_annotations();
df8faef6efaf 8007320: NPG: move method annotations
coleenp
parents: 15595
diff changeset
   180
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  // Helper routine: get klass name + "." + method name + signature as
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  // C string, for the purpose of providing more useful NoSuchMethodErrors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  // and fatal error handling. The string is allocated in resource
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  // area if a buffer is not provided by the caller.
12959
4d33f9be7e87 7174928: JSR 292: unresolved invokedynamic call sites deopt and osr infinitely
twisti
parents: 11637
diff changeset
   186
  char* name_and_sig_as_C_string() const;
4d33f9be7e87 7174928: JSR 292: unresolved invokedynamic call sites deopt and osr infinitely
twisti
parents: 11637
diff changeset
   187
  char* name_and_sig_as_C_string(char* buf, int size) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   189
  // Static routine in the situations we don't have a Method*
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7913
diff changeset
   190
  static char* name_and_sig_as_C_string(Klass* klass, Symbol* method_name, Symbol* signature);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7913
diff changeset
   191
  static char* name_and_sig_as_C_string(Klass* klass, Symbol* method_name, Symbol* signature, char* buf, int size);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   193
  Bytecodes::Code java_code_at(int bci) const {
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   194
    return Bytecodes::java_code_at(this, bcp_from(bci));
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   195
  }
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   196
  Bytecodes::Code code_at(int bci) const {
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   197
    return Bytecodes::code_at(this, bcp_from(bci));
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   198
  }
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   199
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
  // JVMTI breakpoints
38059
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
   201
#if !INCLUDE_JVMTI
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
   202
  Bytecodes::Code orig_bytecode_at(int bci) const {
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
   203
    ShouldNotReachHere();
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
   204
    return Bytecodes::_shouldnotreachhere;
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
   205
  }
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
   206
  void set_orig_bytecode_at(int bci, Bytecodes::Code code) {
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
   207
    ShouldNotReachHere();
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
   208
  };
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
   209
  u2   number_of_breakpoints() const {return 0;}
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
   210
#else // !INCLUDE_JVMTI
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   211
  Bytecodes::Code orig_bytecode_at(int bci) const;
38059
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
   212
  void set_orig_bytecode_at(int bci, Bytecodes::Code code);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
  void set_breakpoint(int bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
  void clear_breakpoint(int bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
  void clear_all_breakpoints();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  // Tracking number of breakpoints, for fullspeed debugging.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
  // Only mutated by VM thread.
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   218
  u2   number_of_breakpoints()             const {
24443
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   219
    MethodCounters* mcs = method_counters();
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   220
    if (mcs == NULL) {
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   221
      return 0;
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   222
    } else {
24443
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   223
      return mcs->number_of_breakpoints();
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   224
    }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   225
  }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   226
  void incr_number_of_breakpoints(TRAPS)         {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   227
    MethodCounters* mcs = get_method_counters(CHECK);
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   228
    if (mcs != NULL) {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   229
      mcs->incr_number_of_breakpoints();
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   230
    }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   231
  }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   232
  void decr_number_of_breakpoints(TRAPS)         {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   233
    MethodCounters* mcs = get_method_counters(CHECK);
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   234
    if (mcs != NULL) {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   235
      mcs->decr_number_of_breakpoints();
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   236
    }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   237
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
  // Initialization only
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   239
  void clear_number_of_breakpoints()             {
24443
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   240
    MethodCounters* mcs = method_counters();
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   241
    if (mcs != NULL) {
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   242
      mcs->clear_number_of_breakpoints();
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   243
    }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   244
  }
38059
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
   245
#endif // !INCLUDE_JVMTI
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   247
  // index into InstanceKlass methods() array
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 10008
diff changeset
   248
  // note: also used by jfr
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
  u2 method_idnum() const           { return constMethod()->method_idnum(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
  void set_method_idnum(u2 idnum)   { constMethod()->set_method_idnum(idnum); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
29316
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 27643
diff changeset
   252
  u2 orig_method_idnum() const           { return constMethod()->orig_method_idnum(); }
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 27643
diff changeset
   253
  void set_orig_method_idnum(u2 idnum)   { constMethod()->set_orig_method_idnum(idnum); }
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 27643
diff changeset
   254
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  // code size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  int code_size() const                  { return constMethod()->code_size(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
33209
43d7a2139756 8135284: Remove Method::_method_size field
minqi
parents: 32820
diff changeset
   258
  // method size in words
39216
40c3d66352ae 8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents: 38144
diff changeset
   259
  int method_size() const                { return sizeof(Method)/wordSize + ( is_native() ? 2 : 0 ); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   261
  // constant pool for Klass* holding this method
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   262
  ConstantPool* constants() const              { return constMethod()->constants(); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   263
  void set_constants(ConstantPool* c)          { constMethod()->set_constants(c); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
  // max stack
13396
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 13391
diff changeset
   266
  // return original max stack size for method verification
14586
1262473e8fc1 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents: 14391
diff changeset
   267
  int  verifier_max_stack() const                { return constMethod()->max_stack(); }
1262473e8fc1 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents: 14391
diff changeset
   268
  int           max_stack() const                { return constMethod()->max_stack() + extra_stack_entries(); }
1262473e8fc1 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents: 14391
diff changeset
   269
  void      set_max_stack(int size)              {        constMethod()->set_max_stack(size); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
  // max locals
14745
03904dd8649b 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing.
jiangli
parents: 14587
diff changeset
   272
  int  max_locals() const                        { return constMethod()->max_locals(); }
03904dd8649b 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing.
jiangli
parents: 14587
diff changeset
   273
  void set_max_locals(int size)                  { constMethod()->set_max_locals(size); }
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   274
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   275
  int highest_comp_level() const;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   276
  void set_highest_comp_level(int level);
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   277
  int highest_osr_comp_level() const;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   278
  void set_highest_osr_comp_level(int level);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
47799
1772ebf07d1f 8152470: Add COMPILER2_OR_JVMCI definition
jcm
parents: 47634
diff changeset
   280
#if COMPILER2_OR_JVMCI
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
  // Count of times method was exited via exception while interpreting
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   282
  void interpreter_throwout_increment(TRAPS) {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   283
    MethodCounters* mcs = get_method_counters(CHECK);
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   284
    if (mcs != NULL) {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   285
      mcs->interpreter_throwout_increment();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
  }
37272
c427db4ea8c4 8148639: Some MethodCounter fields can be excluded when not including C2
cjplummer
parents: 36350
diff changeset
   288
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   290
  int  interpreter_throwout_count() const        {
24443
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   291
    MethodCounters* mcs = method_counters();
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   292
    if (mcs == NULL) {
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   293
      return 0;
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   294
    } else {
24443
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   295
      return mcs->interpreter_throwout_count();
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   296
    }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   297
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  // size of parameters
14745
03904dd8649b 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing.
jiangli
parents: 14587
diff changeset
   300
  int  size_of_parameters() const                { return constMethod()->size_of_parameters(); }
03904dd8649b 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing.
jiangli
parents: 14587
diff changeset
   301
  void set_size_of_parameters(int size)          { constMethod()->set_size_of_parameters(size); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  bool has_stackmap_table() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
    return constMethod()->has_stackmap_table();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   307
  Array<u1>* stackmap_data() const {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
    return constMethod()->stackmap_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   311
  void set_stackmap_data(Array<u1>* sd) {
6974
a013f1c533a5 6991315: RedefineClasses fails with java.lang.VerifyError
kamg
parents: 6463
diff changeset
   312
    constMethod()->set_stackmap_data(sd);
a013f1c533a5 6991315: RedefineClasses fails with java.lang.VerifyError
kamg
parents: 6463
diff changeset
   313
  }
a013f1c533a5 6991315: RedefineClasses fails with java.lang.VerifyError
kamg
parents: 6463
diff changeset
   314
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  // exception handler table
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  bool has_exception_handler() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
                             { return constMethod()->has_exception_handler(); }
13282
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   318
  int exception_table_length() const
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   319
                             { return constMethod()->exception_table_length(); }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   320
  ExceptionTableElement* exception_table_start() const
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   321
                             { return constMethod()->exception_table_start(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  // Finds the first entry point bci of an exception handler for an
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
  // exception of klass ex_klass thrown at throw_bci. A value of NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
  // for ex_klass indicates that the exception klass is not known; in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
  // this case it matches any constraint class. Returns -1 if the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  // exception cannot be handled in this method. The handler
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
  // constraint classes are loaded if necessary. Note that this may
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
  // throw an exception if loading of the constraint classes causes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  // an IllegalAccessError (bugid 4307310) or an OutOfMemoryError.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
  // If an exception is thrown, returns the bci of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
  // exception handler which caused the exception to be thrown, which
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
  // is needed for proper retries. See, for example,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
  // InterpreterRuntime::exception_handler_for_exception.
46727
6e4a84748e2c 8183039: Re-examine methodHandle methods uninlined by 8144256
coleenp
parents: 46625
diff changeset
   335
  static int fast_exception_handler_bci_for(const methodHandle& mh, Klass* ex_klass, int throw_bci, TRAPS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  // method data access
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   338
  MethodData* method_data() const              {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
    return _method_data;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  }
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   341
49340
4e82736053ae 8191102: Incorrect include file use in classLoader.hpp
hseigel
parents: 48557
diff changeset
   342
  void set_method_data(MethodData* data);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   344
  MethodCounters* method_counters() const {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   345
    return _method_counters;
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   346
  }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   347
26799
0c349e16bbe8 8058564: Tiered compilation performance drop in PIT
iveresov
parents: 26558
diff changeset
   348
  void clear_method_counters() {
0c349e16bbe8 8058564: Tiered compilation performance drop in PIT
iveresov
parents: 26558
diff changeset
   349
    _method_counters = NULL;
0c349e16bbe8 8058564: Tiered compilation performance drop in PIT
iveresov
parents: 26558
diff changeset
   350
  }
0c349e16bbe8 8058564: Tiered compilation performance drop in PIT
iveresov
parents: 26558
diff changeset
   351
47634
6a0c42c40cd1 8188220: Remove Atomic::*_ptr() uses and overloads from hotspot
coleenp
parents: 47216
diff changeset
   352
  bool init_method_counters(MethodCounters* counters);
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   353
8667
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
   354
#ifdef TIERED
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
   355
  // We are reusing interpreter_invocation_count as a holder for the previous event count!
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
   356
  // We can do that since interpreter_invocation_count is not used in tiered.
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   357
  int prev_event_count() const                   {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   358
    if (method_counters() == NULL) {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   359
      return 0;
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   360
    } else {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   361
      return method_counters()->interpreter_invocation_count();
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   362
    }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   363
  }
24443
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   364
  void set_prev_event_count(int count) {
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   365
    MethodCounters* mcs = method_counters();
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   366
    if (mcs != NULL) {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   367
      mcs->set_interpreter_invocation_count(count);
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   368
    }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   369
  }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   370
  jlong prev_time() const                        {
24443
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   371
    MethodCounters* mcs = method_counters();
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   372
    return mcs == NULL ? 0 : mcs->prev_time();
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   373
  }
24443
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   374
  void set_prev_time(jlong time) {
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   375
    MethodCounters* mcs = method_counters();
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   376
    if (mcs != NULL) {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   377
      mcs->set_prev_time(time);
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   378
    }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   379
  }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   380
  float rate() const                             {
24443
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   381
    MethodCounters* mcs = method_counters();
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   382
    return mcs == NULL ? 0 : mcs->rate();
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   383
  }
24443
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   384
  void set_rate(float rate) {
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   385
    MethodCounters* mcs = method_counters();
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   386
    if (mcs != NULL) {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   387
      mcs->set_rate(rate);
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   388
    }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   389
  }
42650
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   390
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   391
#if INCLUDE_AOT
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   392
  void set_aot_code(CompiledMethod* aot_code) {
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   393
    _aot_code = aot_code;
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   394
  }
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   395
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   396
  CompiledMethod* aot_code() const {
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   397
    return _aot_code;
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   398
  }
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   399
#else
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   400
  CompiledMethod* aot_code() const { return NULL; }
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   401
#endif // INCLUDE_AOT
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   402
#endif // TIERED
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   403
24442
4d4ae31dea26 8032463: VirtualDispatch test timeout with DeoptimizeALot
iveresov
parents: 24322
diff changeset
   404
  int nmethod_age() const {
4d4ae31dea26 8032463: VirtualDispatch test timeout with DeoptimizeALot
iveresov
parents: 24322
diff changeset
   405
    if (method_counters() == NULL) {
4d4ae31dea26 8032463: VirtualDispatch test timeout with DeoptimizeALot
iveresov
parents: 24322
diff changeset
   406
      return INT_MAX;
4d4ae31dea26 8032463: VirtualDispatch test timeout with DeoptimizeALot
iveresov
parents: 24322
diff changeset
   407
    } else {
4d4ae31dea26 8032463: VirtualDispatch test timeout with DeoptimizeALot
iveresov
parents: 24322
diff changeset
   408
      return method_counters()->nmethod_age();
4d4ae31dea26 8032463: VirtualDispatch test timeout with DeoptimizeALot
iveresov
parents: 24322
diff changeset
   409
    }
4d4ae31dea26 8032463: VirtualDispatch test timeout with DeoptimizeALot
iveresov
parents: 24322
diff changeset
   410
  }
8667
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
   411
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   412
  int invocation_count();
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   413
  int backedge_count();
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   414
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   415
  bool was_executed_more_than(int n);
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   416
  bool was_never_executed()                      { return !was_executed_more_than(0); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 33230
diff changeset
   418
  static void build_interpreter_method_data(const methodHandle& method, TRAPS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   420
  static MethodCounters* build_method_counters(Method* m, TRAPS);
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   421
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   422
  int interpreter_invocation_count() {
24443
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   423
    if (TieredCompilation) {
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   424
      return invocation_count();
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   425
    } else {
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   426
      MethodCounters* mcs = method_counters();
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   427
      return (mcs == NULL) ? 0 : mcs->interpreter_invocation_count();
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   428
    }
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   429
  }
47799
1772ebf07d1f 8152470: Add COMPILER2_OR_JVMCI definition
jcm
parents: 47634
diff changeset
   430
#if COMPILER2_OR_JVMCI
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   431
  int increment_interpreter_invocation_count(TRAPS) {
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   432
    if (TieredCompilation) ShouldNotReachHere();
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   433
    MethodCounters* mcs = get_method_counters(CHECK_0);
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   434
    return (mcs == NULL) ? 0 : mcs->increment_interpreter_invocation_count();
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   435
  }
37272
c427db4ea8c4 8148639: Some MethodCounter fields can be excluded when not including C2
cjplummer
parents: 36350
diff changeset
   436
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
#ifndef PRODUCT
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   439
  int  compiled_invocation_count() const         { return _compiled_invocation_count;  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
  void set_compiled_invocation_count(int count)  { _compiled_invocation_count = count; }
23526
6851d341ad52 8037970: make PrintMethodData a diagnostic options
roland
parents: 23219
diff changeset
   441
#else
6851d341ad52 8037970: make PrintMethodData a diagnostic options
roland
parents: 23219
diff changeset
   442
  // for PrintMethodData in a product build
6851d341ad52 8037970: make PrintMethodData a diagnostic options
roland
parents: 23219
diff changeset
   443
  int  compiled_invocation_count() const         { return 0;  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
#endif // not PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
2131
98f9cef66a34 6810672: Comment typos
twisti
parents: 1894
diff changeset
   446
  // Clear (non-shared space) pointers which could not be relevant
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  // if this (shared) method were mapped into another JVM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
  void remove_unshareable_info();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
  // nmethod/verified compiler entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
  address verified_code_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
  bool check_code() const;      // Not inline to avoid circular ref
49340
4e82736053ae 8191102: Incorrect include file use in classLoader.hpp
hseigel
parents: 48557
diff changeset
   453
  CompiledMethod* volatile code() const;
41715
296ff044b943 8153134: Infinite loop in handle_wrong_method in jmod
thartmann
parents: 41669
diff changeset
   454
  void clear_code(bool acquire_lock = true);    // Clear out any compiled code
46727
6e4a84748e2c 8183039: Re-examine methodHandle methods uninlined by 8144256
coleenp
parents: 46625
diff changeset
   455
  static void set_code(const methodHandle& mh, CompiledMethod* code);
37439
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   456
  void set_adapter_entry(AdapterHandlerEntry* adapter) {
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   457
    constMethod()->set_adapter_entry(adapter);
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   458
  }
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   459
  void update_adapter_trampoline(AdapterHandlerEntry* adapter) {
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   460
    constMethod()->update_adapter_trampoline(adapter);
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   461
  }
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   462
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
  address get_i2c_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
  address get_c2i_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
  address get_c2i_unverified_entry();
37439
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   466
  AdapterHandlerEntry* adapter() const {
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   467
    return constMethod()->adapter();
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   468
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
  // setup entry points
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 33230
diff changeset
   470
  void link_method(const methodHandle& method, TRAPS);
37439
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   471
  // clear entry points. Used by sharing code during dump time
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   472
  void unlink_method() NOT_CDS_RETURN;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
46746
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46727
diff changeset
   474
  virtual void metaspace_pointers_do(MetaspaceClosure* iter);
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46727
diff changeset
   475
  virtual MetaspaceObj::Type type() const { return MethodType; }
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46727
diff changeset
   476
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
  // vtable index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
  enum VtableIndexFlag {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
    // Valid vtable indexes are non-negative (>= 0).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
    // These few negative values are used as sentinels.
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19720
diff changeset
   481
    itable_index_max        = -10, // first itable index, growing downward
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19720
diff changeset
   482
    pending_itable_index    = -9,  // itable index will be assigned
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
    invalid_vtable_index    = -4,  // distinct from any valid vtable index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
    garbage_vtable_index    = -3,  // not yet linked; no vtable layout yet
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
    nonvirtual_vtable_index = -2   // there is no need for vtable dispatch
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
    // 6330203 Note:  Do not use -1, which was overloaded with many meanings.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
  DEBUG_ONLY(bool valid_vtable_index() const     { return _vtable_index >= nonvirtual_vtable_index; })
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19720
diff changeset
   489
  bool has_vtable_index() const                  { return _vtable_index >= 0; }
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19720
diff changeset
   490
  int  vtable_index() const                      { return _vtable_index; }
39714
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 39450
diff changeset
   491
  void set_vtable_index(int index);
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19720
diff changeset
   492
  DEBUG_ONLY(bool valid_itable_index() const     { return _vtable_index <= pending_itable_index; })
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19720
diff changeset
   493
  bool has_itable_index() const                  { return _vtable_index <= itable_index_max; }
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19720
diff changeset
   494
  int  itable_index() const                      { assert(valid_itable_index(), "");
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19720
diff changeset
   495
                                                   return itable_index_max - _vtable_index; }
39714
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 39450
diff changeset
   496
  void set_itable_index(int index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
  // interpreter entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
  address interpreter_entry() const              { return _i2i_entry; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
  // Only used when first initialize so we can set _i2i_entry and _from_interpreted_entry
37439
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   501
  void set_interpreter_entry(address entry) {
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   502
    assert(!is_shared(), "shared method's interpreter entry should not be changed at run time");
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   503
    if (_i2i_entry != entry) {
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   504
      _i2i_entry = entry;
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   505
    }
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   506
    if (_from_interpreted_entry != entry) {
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   507
      _from_interpreted_entry = entry;
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   508
    }
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   509
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  // native function (used for native methods only)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
  enum {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
    native_bind_event_is_interesting = true
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
  address native_function() const                { return *(native_function_addr()); }
11637
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11480
diff changeset
   516
  address critical_native_function();
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11480
diff changeset
   517
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
  // Must specify a real function (not NULL).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
  // Use clear_native_function() to unregister.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
  void set_native_function(address function, bool post_event_flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
  bool has_native_function() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
  void clear_native_function();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
  // signature handler (used for native methods only)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
  address signature_handler() const              { return *(signature_handler_addr()); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
  void set_signature_handler(address handler);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
  // Interpreter oopmap support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
  void mask_for(int bci, InterpreterOopMap* mask);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
  // operations on invocation counter
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   532
  void print_invocation_count();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
  // byte codes
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 3824
diff changeset
   535
  void    set_code(address code)      { return constMethod()->set_code(code); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
  address code_base() const           { return constMethod()->code_base(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
  bool    contains(address bcp) const { return constMethod()->contains(bcp); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
  // prints byte codes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
  void print_codes() const            { print_codes_on(tty); }
23526
6851d341ad52 8037970: make PrintMethodData a diagnostic options
roland
parents: 23219
diff changeset
   541
  void print_codes_on(outputStream* st) const;
6851d341ad52 8037970: make PrintMethodData a diagnostic options
roland
parents: 23219
diff changeset
   542
  void print_codes_on(int from, int to, outputStream* st) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
15102
0a86564e5f61 8004728: Add hotspot support for parameter reflection
coleenp
parents: 15098
diff changeset
   544
  // method parameters
15744
fd58c7e770b3 8007153: Ensure that MethodParameters API works properly with RedefineClasses
emc
parents: 15601
diff changeset
   545
  bool has_method_parameters() const
fd58c7e770b3 8007153: Ensure that MethodParameters API works properly with RedefineClasses
emc
parents: 15601
diff changeset
   546
                         { return constMethod()->has_method_parameters(); }
15102
0a86564e5f61 8004728: Add hotspot support for parameter reflection
coleenp
parents: 15098
diff changeset
   547
  int method_parameters_length() const
0a86564e5f61 8004728: Add hotspot support for parameter reflection
coleenp
parents: 15098
diff changeset
   548
                         { return constMethod()->method_parameters_length(); }
0a86564e5f61 8004728: Add hotspot support for parameter reflection
coleenp
parents: 15098
diff changeset
   549
  MethodParametersElement* method_parameters_start() const
0a86564e5f61 8004728: Add hotspot support for parameter reflection
coleenp
parents: 15098
diff changeset
   550
                          { return constMethod()->method_parameters_start(); }
0a86564e5f61 8004728: Add hotspot support for parameter reflection
coleenp
parents: 15098
diff changeset
   551
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
  // checked exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
  int checked_exceptions_length() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
                         { return constMethod()->checked_exceptions_length(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
  CheckedExceptionElement* checked_exceptions_start() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
                          { return constMethod()->checked_exceptions_start(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
  // localvariable table
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
  bool has_localvariable_table() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
                          { return constMethod()->has_localvariable_table(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
  int localvariable_table_length() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
                        { return constMethod()->localvariable_table_length(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
  LocalVariableTableElement* localvariable_table_start() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
                         { return constMethod()->localvariable_table_start(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
  bool has_linenumber_table() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
                              { return constMethod()->has_linenumber_table(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
  u_char* compressed_linenumber_table() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
                       { return constMethod()->compressed_linenumber_table(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   571
  // method holder (the Klass* holding this method)
14391
df0a1573d5bd 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents: 14385
diff changeset
   572
  InstanceKlass* method_holder() const         { return constants()->pool_holder(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
  void compute_size_of_parameters(Thread *thread); // word size of parameters (receiver if any + arguments)
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7913
diff changeset
   575
  Symbol* klass_name() const;                    // returns the name of the method holder
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
  BasicType result_type() const;                 // type of the method result
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
  bool is_returning_oop() const                  { BasicType r = result_type(); return (r == T_OBJECT || r == T_ARRAY); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
  bool is_returning_fp() const                   { BasicType r = result_type(); return (r == T_FLOAT || r == T_DOUBLE); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
  // Checked exceptions thrown by this method (resolved to mirrors)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
  objArrayHandle resolved_checked_exceptions(TRAPS) { return resolved_checked_exceptions_impl(this, THREAD); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
  // Access flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
  bool is_public() const                         { return access_flags().is_public();      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
  bool is_private() const                        { return access_flags().is_private();     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
  bool is_protected() const                      { return access_flags().is_protected();   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
  bool is_package_private() const                { return !is_public() && !is_private() && !is_protected(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
  bool is_static() const                         { return access_flags().is_static();      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
  bool is_final() const                          { return access_flags().is_final();       }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
  bool is_synchronized() const                   { return access_flags().is_synchronized();}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
  bool is_native() const                         { return access_flags().is_native();      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
  bool is_abstract() const                       { return access_flags().is_abstract();    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
  bool is_strict() const                         { return access_flags().is_strict();      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
  bool is_synthetic() const                      { return access_flags().is_synthetic();   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
  // returns true if contains only return operation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
  bool is_empty_method() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
  // returns true if this is a vanilla constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
  bool is_vanilla_constructor() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
  // checks method and its method holder
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
  bool is_final_method() const;
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19720
diff changeset
   604
  bool is_final_method(AccessFlags class_access_flags) const;
41669
2091069b6851 8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents: 39714
diff changeset
   605
  // interface method declared with 'default' - excludes private interface methods
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20017
diff changeset
   606
  bool is_default_method() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
  // true if method needs no dynamic dispatch (final and/or no vtable entry)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
  bool can_be_statically_bound() const;
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19720
diff changeset
   610
  bool can_be_statically_bound(AccessFlags class_access_flags) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
  // returns true if the method has any backward branches.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
  bool has_loops() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
    return access_flags().loops_flag_init() ? access_flags().has_loops() : compute_has_loops_flag();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
  bool compute_has_loops_flag();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
  bool has_jsrs() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
    return access_flags().has_jsrs();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
  void set_has_jsrs() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
    _access_flags.set_has_jsrs();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
  // returns true if the method has any monitors.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
  bool has_monitors() const                      { return is_synchronized() || access_flags().has_monitor_bytecodes(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
  bool has_monitor_bytecodes() const             { return access_flags().has_monitor_bytecodes(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
  void set_has_monitor_bytecodes()               { _access_flags.set_has_monitor_bytecodes(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
  // monitor matching. This returns a conservative estimate of whether the monitorenter/monitorexit bytecodes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
  // propererly nest in the method. It might return false, even though they actually nest properly, since the info.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
  // has not been computed yet.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
  bool guaranteed_monitor_matching() const       { return access_flags().is_monitor_matching(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
  void set_guaranteed_monitor_matching()         { _access_flags.set_monitor_matching(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
  // returns true if the method is an accessor function (setter/getter).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
  bool is_accessor() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
34169
b0b7187852b7 8140650: Method::is_accessor should cover getters and setters for all types
shade
parents: 33230
diff changeset
   641
  // returns true if the method is a getter
b0b7187852b7 8140650: Method::is_accessor should cover getters and setters for all types
shade
parents: 33230
diff changeset
   642
  bool is_getter() const;
b0b7187852b7 8140650: Method::is_accessor should cover getters and setters for all types
shade
parents: 33230
diff changeset
   643
b0b7187852b7 8140650: Method::is_accessor should cover getters and setters for all types
shade
parents: 33230
diff changeset
   644
  // returns true if the method is a setter
b0b7187852b7 8140650: Method::is_accessor should cover getters and setters for all types
shade
parents: 33230
diff changeset
   645
  bool is_setter() const;
b0b7187852b7 8140650: Method::is_accessor should cover getters and setters for all types
shade
parents: 33230
diff changeset
   646
27643
fe8f95a2d9bc 8056071: compiler/whitebox/IsMethodCompilableTest.java fails with 'method() is not compilable after 3 iterations'
thartmann
parents: 27478
diff changeset
   647
  // returns true if the method does nothing but return a constant of primitive type
fe8f95a2d9bc 8056071: compiler/whitebox/IsMethodCompilableTest.java fails with 'method() is not compilable after 3 iterations'
thartmann
parents: 27478
diff changeset
   648
  bool is_constant_getter() const;
fe8f95a2d9bc 8056071: compiler/whitebox/IsMethodCompilableTest.java fails with 'method() is not compilable after 3 iterations'
thartmann
parents: 27478
diff changeset
   649
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
  // returns true if the method is an initializer (<init> or <clinit>).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
  bool is_initializer() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
8653
8797d788a4f1 6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents: 8313
diff changeset
   653
  // returns true if the method is static OR if the classfile version < 51
8797d788a4f1 6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents: 8313
diff changeset
   654
  bool has_valid_initializer_flags() const;
8797d788a4f1 6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents: 8313
diff changeset
   655
8797d788a4f1 6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents: 8313
diff changeset
   656
  // returns true if the method name is <clinit> and the method has
8797d788a4f1 6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents: 8313
diff changeset
   657
  // valid static initializer flags.
8797d788a4f1 6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents: 8313
diff changeset
   658
  bool is_static_initializer() const;
8797d788a4f1 6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents: 8313
diff changeset
   659
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38144
diff changeset
   660
  // returns true if the method name is <init>
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38144
diff changeset
   661
  bool is_object_initializer() const;
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38144
diff changeset
   662
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
  // compiled code support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
  // NOTE: code() is inherently racy as deopt can be clearing code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
  // simultaneously. Use with caution.
49340
4e82736053ae 8191102: Incorrect include file use in classLoader.hpp
hseigel
parents: 48557
diff changeset
   666
  bool has_compiled_code() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
42650
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   668
#ifdef TIERED
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   669
  bool has_aot_code() const                      { return aot_code() != NULL; }
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   670
#endif
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   671
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
  // sizing
44524
b0d3e8ba6f27 8170812: Metaspace corruption caused by incorrect memory size for MethodCounters
aph
parents: 43453
diff changeset
   673
  static int header_size()                       {
46619
a3919f5e8d2b 8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents: 46618
diff changeset
   674
    return align_up((int)sizeof(Method), wordSize) / wordSize;
44524
b0d3e8ba6f27 8170812: Metaspace corruption caused by incorrect memory size for MethodCounters
aph
parents: 43453
diff changeset
   675
  }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   676
  static int size(bool is_native);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   677
  int size() const                               { return method_size(); }
15437
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 15110
diff changeset
   678
#if INCLUDE_SERVICES
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 15110
diff changeset
   679
  void collect_statistics(KlassSizeStats *sz) const;
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 15110
diff changeset
   680
#endif
31790
4a08476437e8 8025692: Log what methods are touched at run-time
minqi
parents: 31587
diff changeset
   681
  void log_touched(TRAPS);
4a08476437e8 8025692: Log what methods are touched at run-time
minqi
parents: 31587
diff changeset
   682
  static void print_touched_methods(outputStream* out);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
  // interpreter support
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   685
  static ByteSize const_offset()                 { return byte_offset_of(Method, _constMethod       ); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   686
  static ByteSize access_flags_offset()          { return byte_offset_of(Method, _access_flags      ); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   687
  static ByteSize from_compiled_offset()         { return byte_offset_of(Method, _from_compiled_entry); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   688
  static ByteSize code_offset()                  { return byte_offset_of(Method, _code); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
  static ByteSize method_data_offset()           {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   690
    return byte_offset_of(Method, _method_data);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
  }
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   692
  static ByteSize method_counters_offset()       {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   693
    return byte_offset_of(Method, _method_counters);
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   694
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
#ifndef PRODUCT
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   696
  static ByteSize compiled_invocation_counter_offset() { return byte_offset_of(Method, _compiled_invocation_count); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
#endif // not PRODUCT
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   698
  static ByteSize native_function_offset()       { return in_ByteSize(sizeof(Method));                 }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   699
  static ByteSize from_interpreted_offset()      { return byte_offset_of(Method, _from_interpreted_entry ); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   700
  static ByteSize interpreter_entry_offset()     { return byte_offset_of(Method, _i2i_entry ); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   701
  static ByteSize signature_handler_offset()     { return in_ByteSize(sizeof(Method) + wordSize);      }
48557
2e867226b914 8174962: Better interface invocations
vlivanov
parents: 47799
diff changeset
   702
  static ByteSize itable_index_offset()          { return byte_offset_of(Method, _vtable_index ); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
  // for code generation
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   705
  static int method_data_offset_in_bytes()       { return offset_of(Method, _method_data); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   706
  static int intrinsic_id_offset_in_bytes()      { return offset_of(Method, _intrinsic_id); }
32820
ec181adbf3b1 8135085: Change Method::_intrinsic_id from u1 to u2
minqi
parents: 31790
diff changeset
   707
  static int intrinsic_id_size_in_bytes()        { return sizeof(u2); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
  // Static methods that are used to implement member methods where an exposed this pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
  // is needed due to possible GCs
23515
f4872ef5df09 8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents: 23219
diff changeset
   711
  static objArrayHandle resolved_checked_exceptions_impl(Method* method, TRAPS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
  // Returns the byte code index from the byte code pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
  int     bci_from(address bcp) const;
25895
03808d9a48b2 8051398: jvmti tests fieldacc002, fieldmod002 fail in nightly with errors: (watch#0) wrong location
coleenp
parents: 25714
diff changeset
   715
  address bcp_from(int bci) const;
03808d9a48b2 8051398: jvmti tests fieldacc002, fieldmod002 fail in nightly with errors: (watch#0) wrong location
coleenp
parents: 25714
diff changeset
   716
  address bcp_from(address bcp) const;
25714
87fa6860b5ae 8004128: NPG: remove stackwalking in Threads::gc_prologue and gc_epilogue code
coleenp
parents: 24461
diff changeset
   717
  int validate_bci_from_bcp(address bcp) const;
87fa6860b5ae 8004128: NPG: remove stackwalking in Threads::gc_prologue and gc_epilogue code
coleenp
parents: 24461
diff changeset
   718
  int validate_bci(int bci) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
  // Returns the line number for a bci if debugging information for the method is prowided,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
  // -1 is returned otherwise.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
  int line_number_from_bci(int bci) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
  // Reflection support
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   725
  bool is_overridden_in(Klass* k) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15744
diff changeset
   727
  // Stack walking support
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15744
diff changeset
   728
  bool is_ignored_by_security_stack_walk() const;
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15744
diff changeset
   729
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2154
diff changeset
   730
  // JSR 292 support
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   731
  bool is_method_handle_intrinsic() const;          // MethodHandles::is_signature_polymorphic_intrinsic(intrinsic_id)
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   732
  bool is_compiled_lambda_form() const;             // intrinsic_id() == vmIntrinsics::_compiledLambdaForm
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   733
  bool has_member_arg() const;                      // intrinsic_id() == vmIntrinsics::_linkToSpecial, etc.
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   734
  static methodHandle make_method_handle_intrinsic(vmIntrinsics::ID iid, // _invokeBasic, _linkToVirtual
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   735
                                                   Symbol* signature, //anything at all
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   736
                                                   TRAPS);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   737
  static Klass* check_non_bcp_klass(Klass* klass);
17875
9d4aa49a1d76 8010460: Interpreter on some platforms loads ConstMethod::_max_stack and misses extra stack slots for JSR 292
roland
parents: 17372
diff changeset
   738
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32820
diff changeset
   739
  enum {
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32820
diff changeset
   740
    // How many extra stack entries for invokedynamic
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32820
diff changeset
   741
    extra_stack_entries_for_jsr292 = 1
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32820
diff changeset
   742
  };
17875
9d4aa49a1d76 8010460: Interpreter on some platforms loads ConstMethod::_max_stack and misses extra stack slots for JSR 292
roland
parents: 17372
diff changeset
   743
9d4aa49a1d76 8010460: Interpreter on some platforms loads ConstMethod::_max_stack and misses extra stack slots for JSR 292
roland
parents: 17372
diff changeset
   744
  // this operates only on invoke methods:
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2154
diff changeset
   745
  // presize interpreter frames for extra interpreter stack entries, if needed
17875
9d4aa49a1d76 8010460: Interpreter on some platforms loads ConstMethod::_max_stack and misses extra stack slots for JSR 292
roland
parents: 17372
diff changeset
   746
  // Account for the extra appendix argument for invokehandle/invokedynamic
24322
c2978d1578e3 8036956: remove EnableInvokeDynamic flag
anoll
parents: 23872
diff changeset
   747
  static int extra_stack_entries() { return extra_stack_entries_for_jsr292; }
17875
9d4aa49a1d76 8010460: Interpreter on some platforms loads ConstMethod::_max_stack and misses extra stack slots for JSR 292
roland
parents: 17372
diff changeset
   748
  static int extra_stack_words();  // = extra_stack_entries() * Interpreter::stackElementSize
4581
e89fbd1bcb3d 6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents: 4567
diff changeset
   749
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
  // RedefineClasses() support:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
  bool is_old() const                               { return access_flags().is_old(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
  void set_is_old()                                 { _access_flags.set_is_old(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
  bool is_obsolete() const                          { return access_flags().is_obsolete(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
  void set_is_obsolete()                            { _access_flags.set_is_obsolete(); }
24459
ebd373039673 8042796: jvmtiRedefineClasses.cpp: guarantee(false) failed: OLD and/or OBSOLETE method(s) found
sspitsyn
parents: 24457
diff changeset
   755
  bool is_deleted() const                           { return access_flags().is_deleted(); }
ebd373039673 8042796: jvmtiRedefineClasses.cpp: guarantee(false) failed: OLD and/or OBSOLETE method(s) found
sspitsyn
parents: 24457
diff changeset
   756
  void set_is_deleted()                             { _access_flags.set_is_deleted(); }
26558
b7df27df6384 8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents: 25895
diff changeset
   757
b7df27df6384 8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents: 25895
diff changeset
   758
  bool is_running_emcp() const {
b7df27df6384 8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents: 25895
diff changeset
   759
    // EMCP methods are old but not obsolete or deleted. Equivalent
b7df27df6384 8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents: 25895
diff changeset
   760
    // Modulo Constant Pool means the method is equivalent except
b7df27df6384 8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents: 25895
diff changeset
   761
    // the constant pool and instructions that access the constant
b7df27df6384 8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents: 25895
diff changeset
   762
    // pool might be different.
b7df27df6384 8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents: 25895
diff changeset
   763
    // If a breakpoint is set in a redefined method, its EMCP methods that are
b7df27df6384 8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents: 25895
diff changeset
   764
    // still running must have a breakpoint also.
b7df27df6384 8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents: 25895
diff changeset
   765
    return (_flags & _running_emcp) != 0;
b7df27df6384 8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents: 25895
diff changeset
   766
  }
b7df27df6384 8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents: 25895
diff changeset
   767
b7df27df6384 8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents: 25895
diff changeset
   768
  void set_running_emcp(bool x) {
b7df27df6384 8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents: 25895
diff changeset
   769
    _flags = x ? (_flags | _running_emcp) : (_flags & ~_running_emcp);
b7df27df6384 8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents: 25895
diff changeset
   770
  }
b7df27df6384 8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents: 25895
diff changeset
   771
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   772
  bool on_stack() const                             { return access_flags().on_stack(); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   773
  void set_on_stack(const bool value);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   774
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   775
  // see the definition in Method*.cpp for the gory details
221
ec745a0fe922 6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents: 1
diff changeset
   776
  bool should_not_be_cached() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
  // JVMTI Native method prefixing support:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
  bool is_prefixed_native() const                   { return access_flags().is_prefixed_native(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
  void set_is_prefixed_native()                     { _access_flags.set_is_prefixed_native(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
  // Rewriting support
46727
6e4a84748e2c 8183039: Re-examine methodHandle methods uninlined by 8144256
coleenp
parents: 46625
diff changeset
   783
  static methodHandle clone_with_new_data(const methodHandle& m, u_char* new_code, int new_code_length,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
                                          u_char* new_compressed_linenumber_table, int new_compressed_linenumber_size, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   786
  // jmethodID handling
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   787
  // Because the useful life-span of a jmethodID cannot be determined,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   788
  // once created they are never reclaimed.  The methods to which they refer,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   789
  // however, can be GC'ed away if the class is unloaded or if the method is
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   790
  // made obsolete or deleted -- in these cases, the jmethodID
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   791
  // refers to NULL (as is the case for any weak reference).
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   792
  static jmethodID make_jmethod_id(ClassLoaderData* loader_data, Method* mh);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   793
  static void destroy_jmethod_id(ClassLoaderData* loader_data, jmethodID mid);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   794
27478
0eedae0228ac 8062116: JVMTI GetClassMethods is Slow
jmanson
parents: 27434
diff changeset
   795
  // Ensure there is enough capacity in the internal tracking data
0eedae0228ac 8062116: JVMTI GetClassMethods is Slow
jmanson
parents: 27434
diff changeset
   796
  // structures to hold the number of jmethodIDs you plan to generate.
0eedae0228ac 8062116: JVMTI GetClassMethods is Slow
jmanson
parents: 27434
diff changeset
   797
  // This saves substantial time doing allocations.
0eedae0228ac 8062116: JVMTI GetClassMethods is Slow
jmanson
parents: 27434
diff changeset
   798
  static void ensure_jmethod_ids(ClassLoaderData* loader_data, int capacity);
0eedae0228ac 8062116: JVMTI GetClassMethods is Slow
jmanson
parents: 27434
diff changeset
   799
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   800
  // Use resolve_jmethod_id() in situations where the caller is expected
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   801
  // to provide a valid jmethodID; the only sanity checks are in asserts;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   802
  // result guaranteed not to be NULL.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   803
  inline static Method* resolve_jmethod_id(jmethodID mid) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   804
    assert(mid != NULL, "JNI method id should not be null");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   805
    return *((Method**)mid);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   806
  }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   807
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   808
  // Use checked_resolve_jmethod_id() in situations where the caller
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   809
  // should provide a valid jmethodID, but might not. NULL is returned
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   810
  // when the jmethodID does not refer to a valid method.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   811
  static Method* checked_resolve_jmethod_id(jmethodID mid);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   812
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   813
  static void change_method_associated_with_jmethod_id(jmethodID old_jmid_ptr, Method* new_method);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   814
  static bool is_method_id(jmethodID mid);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   815
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   816
  // Clear methods
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   817
  static void clear_jmethod_ids(ClassLoaderData* loader_data);
49348
fde3feaaa4ed 8198926: Move ClassLoaderData::_dependencies to ClassLoaderData::_handles
coleenp
parents: 49340
diff changeset
   818
  static void print_jmethod_ids(const ClassLoaderData* loader_data, outputStream* out) PRODUCT_RETURN;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   819
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
  // Get this method's jmethodID -- allocate if it doesn't exist
46341
4c676683bdb9 8176705: Remove static functions in InstanceKlass
hseigel
parents: 46329
diff changeset
   821
  jmethodID jmethod_id()                            { return method_holder()->get_jmethod_id(this); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
  // Lookup the jmethodID for this method.  Return NULL if not found.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
  // NOTE that this function can be called from a signal handler
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
  // (see AsyncGetCallTrace support for Forte Analyzer) and this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
  // needs to be async-safe. No allocation should be done and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
  // so handles are not used to avoid deadlock.
14391
df0a1573d5bd 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents: 14385
diff changeset
   828
  jmethodID find_jmethod_id_or_null()               { return method_holder()->jmethod_id_or_null(this); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
  // Support for inlining of intrinsic methods
3273
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2570
diff changeset
   831
  vmIntrinsics::ID intrinsic_id() const          { return (vmIntrinsics::ID) _intrinsic_id;           }
32820
ec181adbf3b1 8135085: Change Method::_intrinsic_id from u1 to u2
minqi
parents: 31790
diff changeset
   832
  void     set_intrinsic_id(vmIntrinsics::ID id) {                           _intrinsic_id = (u2) id; }
3273
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2570
diff changeset
   833
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2570
diff changeset
   834
  // Helper routines for intrinsic_id() and vmIntrinsics::method().
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2570
diff changeset
   835
  void init_intrinsic_id();     // updates from _none if a match
34666
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 34185
diff changeset
   836
  static vmSymbols::SID klass_id_for_intrinsics(const Klass* holder);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
23219
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   838
  bool caller_sensitive() {
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   839
    return (_flags & _caller_sensitive) != 0;
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   840
  }
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   841
  void set_caller_sensitive(bool x) {
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   842
    _flags = x ? (_flags | _caller_sensitive) : (_flags & ~_caller_sensitive);
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   843
  }
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   844
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   845
  bool force_inline() {
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   846
    return (_flags & _force_inline) != 0;
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   847
  }
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   848
  void set_force_inline(bool x) {
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   849
    _flags = x ? (_flags | _force_inline) : (_flags & ~_force_inline);
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   850
  }
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   851
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   852
  bool dont_inline() {
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   853
    return (_flags & _dont_inline) != 0;
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   854
  }
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   855
  void set_dont_inline(bool x) {
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   856
    _flags = x ? (_flags | _dont_inline) : (_flags & ~_dont_inline);
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   857
  }
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   858
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   859
  bool is_hidden() {
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   860
    return (_flags & _hidden) != 0;
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   861
  }
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   862
  void set_hidden(bool x) {
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   863
    _flags = x ? (_flags | _hidden) : (_flags & ~_hidden);
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   864
  }
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   865
31587
e48945b7849c 8076112: Add @HotSpotIntrinsicCandidate annotation to indicate methods for which Java Runtime has intrinsics
zmajo
parents: 31228
diff changeset
   866
  bool intrinsic_candidate() {
e48945b7849c 8076112: Add @HotSpotIntrinsicCandidate annotation to indicate methods for which Java Runtime has intrinsics
zmajo
parents: 31228
diff changeset
   867
    return (_flags & _intrinsic_candidate) != 0;
e48945b7849c 8076112: Add @HotSpotIntrinsicCandidate annotation to indicate methods for which Java Runtime has intrinsics
zmajo
parents: 31228
diff changeset
   868
  }
e48945b7849c 8076112: Add @HotSpotIntrinsicCandidate annotation to indicate methods for which Java Runtime has intrinsics
zmajo
parents: 31228
diff changeset
   869
  void set_intrinsic_candidate(bool x) {
e48945b7849c 8076112: Add @HotSpotIntrinsicCandidate annotation to indicate methods for which Java Runtime has intrinsics
zmajo
parents: 31228
diff changeset
   870
    _flags = x ? (_flags | _intrinsic_candidate) : (_flags & ~_intrinsic_candidate);
e48945b7849c 8076112: Add @HotSpotIntrinsicCandidate annotation to indicate methods for which Java Runtime has intrinsics
zmajo
parents: 31228
diff changeset
   871
  }
e48945b7849c 8076112: Add @HotSpotIntrinsicCandidate annotation to indicate methods for which Java Runtime has intrinsics
zmajo
parents: 31228
diff changeset
   872
31228
8e427370cdd1 8074551: GWT can be marked non-compilable due to deopt count pollution
vlivanov
parents: 29316
diff changeset
   873
  bool has_injected_profile() {
8e427370cdd1 8074551: GWT can be marked non-compilable due to deopt count pollution
vlivanov
parents: 29316
diff changeset
   874
    return (_flags & _has_injected_profile) != 0;
8e427370cdd1 8074551: GWT can be marked non-compilable due to deopt count pollution
vlivanov
parents: 29316
diff changeset
   875
  }
8e427370cdd1 8074551: GWT can be marked non-compilable due to deopt count pollution
vlivanov
parents: 29316
diff changeset
   876
  void set_has_injected_profile(bool x) {
8e427370cdd1 8074551: GWT can be marked non-compilable due to deopt count pollution
vlivanov
parents: 29316
diff changeset
   877
    _flags = x ? (_flags | _has_injected_profile) : (_flags & ~_has_injected_profile);
8e427370cdd1 8074551: GWT can be marked non-compilable due to deopt count pollution
vlivanov
parents: 29316
diff changeset
   878
  }
8e427370cdd1 8074551: GWT can be marked non-compilable due to deopt count pollution
vlivanov
parents: 29316
diff changeset
   879
35071
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 34666
diff changeset
   880
  bool has_reserved_stack_access() {
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 34666
diff changeset
   881
    return (_flags & _reserved_stack_access) != 0;
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 34666
diff changeset
   882
  }
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 34666
diff changeset
   883
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 34666
diff changeset
   884
  void set_has_reserved_stack_access(bool x) {
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 34666
diff changeset
   885
    _flags = x ? (_flags | _reserved_stack_access) : (_flags & ~_reserved_stack_access);
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 34666
diff changeset
   886
  }
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 34666
diff changeset
   887
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents: 49348
diff changeset
   888
  JFR_ONLY(DEFINE_TRACE_FLAG_ACCESSOR;)
43453
a2097d148d0e 8171960: Event-based tracing needs separate flag representation for Method
mgronlun
parents: 42650
diff changeset
   889
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   890
  ConstMethod::MethodType method_type() const {
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   891
      return _constMethod->method_type();
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   892
  }
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   893
  bool is_overpass() const { return method_type() == ConstMethod::OVERPASS; }
13291
9de3b1387cb8 6711908: JVM needs direct access to some annotations
jrose
parents: 12960
diff changeset
   894
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
  // On-stack replacement support
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   896
  bool has_osr_nmethod(int level, bool match_level) {
14391
df0a1573d5bd 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents: 14385
diff changeset
   897
   return method_holder()->lookup_osr_nmethod(this, InvocationEntryBci, level, match_level) != NULL;
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   898
  }
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   899
27434
b4b185d05bb5 8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents: 26799
diff changeset
   900
  int mark_osr_nmethods() {
b4b185d05bb5 8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents: 26799
diff changeset
   901
    return method_holder()->mark_osr_nmethods(this);
b4b185d05bb5 8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents: 26799
diff changeset
   902
  }
b4b185d05bb5 8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents: 26799
diff changeset
   903
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   904
  nmethod* lookup_osr_nmethod_for(int bci, int level, bool match_level) {
14391
df0a1573d5bd 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents: 14385
diff changeset
   905
    return method_holder()->lookup_osr_nmethod(this, bci, level, match_level);
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   906
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
  // Find if klass for method is loaded
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
  bool is_klass_loaded_by_klass_index(int klass_index) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
  bool is_klass_loaded(int refinfo_index, bool must_be_resolved = false) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
  // Indicates whether compilation failed earlier for this method, or
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
  // whether it is not compilable for another reason like having a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
  // breakpoint set in it.
13891
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   915
  bool  is_not_compilable(int comp_level = CompLevel_any) const;
15479
e3c00ec80145 8006613: adding reason to made_not_compilable
vlivanov
parents: 15110
diff changeset
   916
  void set_not_compilable(int comp_level = CompLevel_all, bool report = true, const char* reason = NULL);
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   917
  void set_not_compilable_quietly(int comp_level = CompLevel_all) {
4756
da88c27a9241 6923043: failed nightly tests which use -XX:+PrintCompilation -Xcomp -XX:CompileOnly
kvn
parents: 4750
diff changeset
   918
    set_not_compilable(comp_level, false);
da88c27a9241 6923043: failed nightly tests which use -XX:+PrintCompilation -Xcomp -XX:CompileOnly
kvn
parents: 4750
diff changeset
   919
  }
13891
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   920
  bool  is_not_osr_compilable(int comp_level = CompLevel_any) const;
15479
e3c00ec80145 8006613: adding reason to made_not_compilable
vlivanov
parents: 15110
diff changeset
   921
  void set_not_osr_compilable(int comp_level = CompLevel_all, bool report = true, const char* reason = NULL);
13891
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   922
  void set_not_osr_compilable_quietly(int comp_level = CompLevel_all) {
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   923
    set_not_osr_compilable(comp_level, false);
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   924
  }
19720
1f9f216fa43e 8023976: assert(!CompilationPolicy::can_be_compiled(this, comp_level)) failed: sanity check
vlivanov
parents: 17875
diff changeset
   925
  bool is_always_compilable() const;
13891
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   926
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   927
 private:
15479
e3c00ec80145 8006613: adding reason to made_not_compilable
vlivanov
parents: 15110
diff changeset
   928
  void print_made_not_compilable(int comp_level, bool is_osr, bool report, const char* reason);
13891
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   929
20695
4f5a5e95090b 8025566: EXCEPTION_ACCESS_VIOLATION in compiled by C1 String.valueOf method
twisti
parents: 20017
diff changeset
   930
 public:
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   931
  MethodCounters* get_method_counters(TRAPS) {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   932
    if (_method_counters == NULL) {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   933
      build_method_counters(this, CHECK_AND_CLEAR_NULL);
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   934
    }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   935
    return _method_counters;
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   936
  }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   937
16689
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16617
diff changeset
   938
  bool   is_not_c1_compilable() const         { return access_flags().is_not_c1_compilable();  }
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16617
diff changeset
   939
  void  set_not_c1_compilable()               {       _access_flags.set_not_c1_compilable();   }
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16617
diff changeset
   940
  void clear_not_c1_compilable()              {       _access_flags.clear_not_c1_compilable(); }
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16617
diff changeset
   941
  bool   is_not_c2_compilable() const         { return access_flags().is_not_c2_compilable();  }
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16617
diff changeset
   942
  void  set_not_c2_compilable()               {       _access_flags.set_not_c2_compilable();   }
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16617
diff changeset
   943
  void clear_not_c2_compilable()              {       _access_flags.clear_not_c2_compilable(); }
13891
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   944
16689
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16617
diff changeset
   945
  bool    is_not_c1_osr_compilable() const    { return is_not_c1_compilable(); }  // don't waste an accessFlags bit
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16617
diff changeset
   946
  void   set_not_c1_osr_compilable()          {       set_not_c1_compilable(); }  // don't waste an accessFlags bit
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16617
diff changeset
   947
  void clear_not_c1_osr_compilable()          {     clear_not_c1_compilable(); }  // don't waste an accessFlags bit
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16617
diff changeset
   948
  bool   is_not_c2_osr_compilable() const     { return access_flags().is_not_c2_osr_compilable();  }
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16617
diff changeset
   949
  void  set_not_c2_osr_compilable()           {       _access_flags.set_not_c2_osr_compilable();   }
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16617
diff changeset
   950
  void clear_not_c2_osr_compilable()          {       _access_flags.clear_not_c2_osr_compilable(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
489c9b5090e2 Initial load
duke
parents:
diff changeset
   952
  // Background compilation support
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   953
  bool queued_for_compilation() const  { return access_flags().queued_for_compilation(); }
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   954
  void set_queued_for_compilation()    { _access_flags.set_queued_for_compilation();     }
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   955
  void clear_queued_for_compilation()  { _access_flags.clear_queued_for_compilation();   }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
  // Resolve all classes in signature, return 'true' if successful
46727
6e4a84748e2c 8183039: Re-examine methodHandle methods uninlined by 8144256
coleenp
parents: 46625
diff changeset
   958
  static bool load_signature_classes(const methodHandle& m, TRAPS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
  // Return if true if not all classes references in signature, including return type, has been loaded
46727
6e4a84748e2c 8183039: Re-examine methodHandle methods uninlined by 8144256
coleenp
parents: 46625
diff changeset
   961
  static bool has_unloaded_classes_in_signature(const methodHandle& m, TRAPS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
  // Printing
15591
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 15450
diff changeset
   964
  void print_short_name(outputStream* st = tty); // prints as klassname::methodname; Exposed so field engineers can debug VM
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 15450
diff changeset
   965
#if INCLUDE_JVMTI
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 15450
diff changeset
   966
  void print_name(outputStream* st = tty); // prints as "virtual void foo(int)"; exposed for TraceRedefineClasses
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 15450
diff changeset
   967
#else
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   968
  void print_name(outputStream* st = tty)        PRODUCT_RETURN; // prints as "virtual void foo(int)"
15591
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 15450
diff changeset
   969
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
  // Helper routine used for method sorting
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20017
diff changeset
   972
  static void sort_methods(Array<Method*>* methods, bool idempotent = false, bool set_idnums = true);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   974
  // Deallocation function for redefine classes or if an error occurs
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   975
  void deallocate_contents(ClassLoaderData* loader_data);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   976
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   977
  // Printing
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   978
#ifndef PRODUCT
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   979
  void print_on(outputStream* st) const;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   980
#endif
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   981
  void print_value_on(outputStream* st) const;
35463
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 35071
diff changeset
   982
  void print_linkage_flags(outputStream* st) PRODUCT_RETURN;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   983
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   984
  const char* internal_name() const { return "{method}"; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   985
14579
7f6ce6e3dd80 8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents: 14391
diff changeset
   986
  // Check for valid method pointer
24457
0e20b36df5c4 8038212: Method::is_valid_method() check has performance regression impact for stackwalking
coleenp
parents: 24322
diff changeset
   987
  static bool has_method_vptr(const void* ptr);
51263
b5aac518b097 8207779: Method::is_valid_method() compares 'this' with NULL
hseigel
parents: 50416
diff changeset
   988
  static bool is_valid_method(const Method* m);
14579
7f6ce6e3dd80 8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents: 14391
diff changeset
   989
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   990
  // Verify
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   991
  void verify() { verify_on(tty); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   992
  void verify_on(outputStream* st);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   993
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
  // Inlined elements
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
  address* native_function_addr() const          { assert(is_native(), "must be native"); return (address*) (this+1); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
  address* signature_handler_addr() const        { return native_function_addr() + 1; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
// Utility class for compressing line number tables
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
class CompressedLineNumberWriteStream: public CompressedWriteStream {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
  int _bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
  int _line;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
  // Constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
  CompressedLineNumberWriteStream(int initial_size) : CompressedWriteStream(initial_size), _bci(0), _line(0) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
  CompressedLineNumberWriteStream(u_char* buffer, int initial_size) : CompressedWriteStream(buffer, initial_size), _bci(0), _line(0) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
  // Write (bci, line number) pair to stream
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
  void write_pair_regular(int bci_delta, int line_delta);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
  inline void write_pair_inline(int bci, int line) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
    int bci_delta = bci - _bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
    int line_delta = line - _line;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
    _bci = bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
    _line = line;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
    // Skip (0,0) deltas - they do not add information and conflict with terminator.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
    if (bci_delta == 0 && line_delta == 0) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
    // Check if bci is 5-bit and line number 3-bit unsigned.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
    if (((bci_delta & ~0x1F) == 0) && ((line_delta & ~0x7) == 0)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
      // Compress into single byte.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
      jubyte value = ((jubyte) bci_delta << 3) | (jubyte) line_delta;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
      // Check that value doesn't match escape character.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
      if (value != 0xFF) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
        write_byte(value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
        return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
    write_pair_regular(bci_delta, line_delta);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
// Windows AMD64 + Apr 2005 PSDK with /O2 generates bad code for write_pair.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
// Disabling optimization doesn't work for methods in header files
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
// so we force it to call through the non-optimized version in the .cpp.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
// It's gross, but it's the only way we can ensure that all callers are
8303
81a0b8663748 7017824: Add support for creating 64-bit Visual Studio projects
sla
parents: 8076
diff changeset
  1040
// fixed.  _MSC_VER is defined by the windows compiler
81a0b8663748 7017824: Add support for creating 64-bit Visual Studio projects
sla
parents: 8076
diff changeset
  1041
#if defined(_M_AMD64) && _MSC_VER >= 1400
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
  void write_pair(int bci, int line);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1043
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
  void write_pair(int bci, int line) { write_pair_inline(bci, line); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1047
  // Write end-of-stream marker
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1048
  void write_terminator()                        { write_byte(0); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1049
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1050
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1051
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
// Utility class for decompressing line number tables
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1054
class CompressedLineNumberReadStream: public CompressedReadStream {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1055
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1056
  int _bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
  int _line;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
  // Constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
  CompressedLineNumberReadStream(u_char* buffer);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
  // Read (bci, line number) pair from stream. Returns false at end-of-stream.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
  bool read_pair();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
  // Accessing bci and line number (after calling read_pair)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
  int bci() const                               { return _bci; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
  int line() const                              { return _line; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
38059
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
  1069
#if INCLUDE_JVMTI
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
  1070
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1071
/// Fast Breakpoints.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1072
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
// If this structure gets more complicated (because bpts get numerous),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1074
// move it into its own header.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
// There is presently no provision for concurrent access
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
// to breakpoint lists, which is only OK for JVMTI because
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
// breakpoints are written only at safepoints, and are read
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
// concurrently only outside of safepoints.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12960
diff changeset
  1081
class BreakpointInfo : public CHeapObj<mtClass> {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
  friend class VMStructs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1084
  Bytecodes::Code  _orig_bytecode;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1085
  int              _bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1086
  u2               _name_index;       // of method
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1087
  u2               _signature_index;  // of method
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
  BreakpointInfo*  _next;             // simple storage allocation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
 public:
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1091
  BreakpointInfo(Method* m, int bci);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
  Bytecodes::Code orig_bytecode()                     { return _orig_bytecode; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
  void        set_orig_bytecode(Bytecodes::Code code) { _orig_bytecode = code; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
  int         bci()                                   { return _bci; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1097
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1098
  BreakpointInfo*          next() const               { return _next; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1099
  void                 set_next(BreakpointInfo* n)    { _next = n; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1100
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1101
  // helps for searchers
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1102
  bool match(const Method* m, int bci) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1103
    return bci == _bci && match(m);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1104
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1105
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1106
  bool match(const Method* m) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
    return _name_index == m->name_index() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1108
      _signature_index == m->signature_index();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1109
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1110
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1111
  void set(Method* method);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1112
  void clear(Method* method);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1113
};
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6974
diff changeset
  1114
38059
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
  1115
#endif // INCLUDE_JVMTI
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
  1116
13282
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1117
// Utility class for access exception handlers
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1118
class ExceptionTable : public StackObj {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1119
 private:
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1120
  ExceptionTableElement* _table;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1121
  u2  _length;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1122
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1123
 public:
17370
59a0620561fa 8003557: NPG: Klass* const k should be const Klass* k.
minqi
parents: 17002
diff changeset
  1124
  ExceptionTable(const Method* m) {
13282
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1125
    if (m->has_exception_handler()) {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1126
      _table = m->exception_table_start();
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1127
      _length = m->exception_table_length();
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1128
    } else {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1129
      _table = NULL;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1130
      _length = 0;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1131
    }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1132
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1133
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1134
  int length() const {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1135
    return _length;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1136
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1137
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1138
  u2 start_pc(int idx) const {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1139
    assert(idx < _length, "out of bounds");
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1140
    return _table[idx].start_pc;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1141
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1142
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1143
  void set_start_pc(int idx, u2 value) {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1144
    assert(idx < _length, "out of bounds");
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1145
    _table[idx].start_pc = value;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1146
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1147
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1148
  u2 end_pc(int idx) const {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1149
    assert(idx < _length, "out of bounds");
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1150
    return _table[idx].end_pc;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1151
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1152
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1153
  void set_end_pc(int idx, u2 value) {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1154
    assert(idx < _length, "out of bounds");
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1155
    _table[idx].end_pc = value;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1156
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1157
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1158
  u2 handler_pc(int idx) const {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1159
    assert(idx < _length, "out of bounds");
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1160
    return _table[idx].handler_pc;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1161
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1162
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1163
  void set_handler_pc(int idx, u2 value) {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1164
    assert(idx < _length, "out of bounds");
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1165
    _table[idx].handler_pc = value;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1166
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1167
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1168
  u2 catch_type_index(int idx) const {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1169
    assert(idx < _length, "out of bounds");
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1170
    return _table[idx].catch_type_index;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1171
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1172
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1173
  void set_catch_type_index(int idx, u2 value) {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1174
    assert(idx < _length, "out of bounds");
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1175
    _table[idx].catch_type_index = value;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1176
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1177
};
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1178
53244
9807daeb47c4 8216167: Update include guards to reflect correct directories
coleenp
parents: 53149
diff changeset
  1179
#endif // SHARE_OOPS_METHOD_HPP