src/hotspot/share/oops/method.hpp
author vlivanov
Fri, 19 Jul 2019 16:25:04 +0300
changeset 55749 cff8aad2593f
parent 55479 80b27dc96ca3
child 57710 05ff6e27de45
permissions -rw-r--r--
8227260: JNI upcalls should bypass class initialization barrier in c2i adapter Reviewed-by: eosterlund, dholmes, mdoerr, dpochepk
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
54432
532e88de77eb 8221470: Print methods in exception messages in java-like Syntax.
goetz
parents: 54042
diff changeset
   183
  // C string, for the purpose of providing more useful
532e88de77eb 8221470: Print methods in exception messages in java-like Syntax.
goetz
parents: 54042
diff changeset
   184
  // fatal error handling. The string is allocated in resource
1
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
54432
532e88de77eb 8221470: Print methods in exception messages in java-like Syntax.
goetz
parents: 54042
diff changeset
   193
  // Get return type + klass name + "." + method name + ( parameters types )
532e88de77eb 8221470: Print methods in exception messages in java-like Syntax.
goetz
parents: 54042
diff changeset
   194
  // as a C string or print it to an outputStream.
532e88de77eb 8221470: Print methods in exception messages in java-like Syntax.
goetz
parents: 54042
diff changeset
   195
  // This is to be used to assemble strings passed to Java, so that
532e88de77eb 8221470: Print methods in exception messages in java-like Syntax.
goetz
parents: 54042
diff changeset
   196
  // the text more resembles Java code. Used in exception messages.
532e88de77eb 8221470: Print methods in exception messages in java-like Syntax.
goetz
parents: 54042
diff changeset
   197
  // Memory is allocated in the resource area; the caller needs
532e88de77eb 8221470: Print methods in exception messages in java-like Syntax.
goetz
parents: 54042
diff changeset
   198
  // a ResourceMark.
532e88de77eb 8221470: Print methods in exception messages in java-like Syntax.
goetz
parents: 54042
diff changeset
   199
  const char* external_name() const;
532e88de77eb 8221470: Print methods in exception messages in java-like Syntax.
goetz
parents: 54042
diff changeset
   200
  void  print_external_name(outputStream *os) const;
532e88de77eb 8221470: Print methods in exception messages in java-like Syntax.
goetz
parents: 54042
diff changeset
   201
532e88de77eb 8221470: Print methods in exception messages in java-like Syntax.
goetz
parents: 54042
diff changeset
   202
  static const char* external_name(                  Klass* klass, Symbol* method_name, Symbol* signature);
532e88de77eb 8221470: Print methods in exception messages in java-like Syntax.
goetz
parents: 54042
diff changeset
   203
  static void  print_external_name(outputStream *os, Klass* klass, Symbol* method_name, Symbol* signature);
532e88de77eb 8221470: Print methods in exception messages in java-like Syntax.
goetz
parents: 54042
diff changeset
   204
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   205
  Bytecodes::Code java_code_at(int bci) const {
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   206
    return Bytecodes::java_code_at(this, bcp_from(bci));
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   207
  }
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   208
  Bytecodes::Code code_at(int bci) const {
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   209
    return Bytecodes::code_at(this, bcp_from(bci));
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   210
  }
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   211
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
  // JVMTI breakpoints
38059
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
   213
#if !INCLUDE_JVMTI
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
   214
  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
   215
    ShouldNotReachHere();
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
   216
    return Bytecodes::_shouldnotreachhere;
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
   217
  }
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
   218
  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
   219
    ShouldNotReachHere();
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
   220
  };
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
   221
  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
   222
#else // !INCLUDE_JVMTI
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   223
  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
   224
  void set_orig_bytecode_at(int bci, Bytecodes::Code code);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  void set_breakpoint(int bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  void clear_breakpoint(int bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
  void clear_all_breakpoints();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
  // Tracking number of breakpoints, for fullspeed debugging.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  // Only mutated by VM thread.
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   230
  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
   231
    MethodCounters* mcs = method_counters();
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   232
    if (mcs == NULL) {
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   233
      return 0;
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   234
    } else {
24443
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   235
      return mcs->number_of_breakpoints();
17000
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
  }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   238
  void incr_number_of_breakpoints(TRAPS)         {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   239
    MethodCounters* mcs = get_method_counters(CHECK);
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   240
    if (mcs != NULL) {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   241
      mcs->incr_number_of_breakpoints();
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   242
    }
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
  void decr_number_of_breakpoints(TRAPS)         {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   245
    MethodCounters* mcs = get_method_counters(CHECK);
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   246
    if (mcs != NULL) {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   247
      mcs->decr_number_of_breakpoints();
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   248
    }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   249
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
  // Initialization only
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   251
  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
   252
    MethodCounters* mcs = method_counters();
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   253
    if (mcs != NULL) {
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   254
      mcs->clear_number_of_breakpoints();
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   255
    }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   256
  }
38059
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
   257
#endif // !INCLUDE_JVMTI
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   259
  // index into InstanceKlass methods() array
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 10008
diff changeset
   260
  // note: also used by jfr
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  u2 method_idnum() const           { return constMethod()->method_idnum(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
  void set_method_idnum(u2 idnum)   { constMethod()->set_method_idnum(idnum); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
29316
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 27643
diff changeset
   264
  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
   265
  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
   266
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
  // code size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
  int code_size() const                  { return constMethod()->code_size(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
33209
43d7a2139756 8135284: Remove Method::_method_size field
minqi
parents: 32820
diff changeset
   270
  // 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
   271
  int method_size() const                { return sizeof(Method)/wordSize + ( is_native() ? 2 : 0 ); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   273
  // constant pool for Klass* holding this method
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   274
  ConstantPool* constants() const              { return constMethod()->constants(); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   275
  void set_constants(ConstantPool* c)          { constMethod()->set_constants(c); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
  // max stack
13396
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 13391
diff changeset
   278
  // 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
   279
  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
   280
  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
   281
  void      set_max_stack(int size)              {        constMethod()->set_max_stack(size); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
  // max locals
14745
03904dd8649b 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing.
jiangli
parents: 14587
diff changeset
   284
  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
   285
  void set_max_locals(int size)                  { constMethod()->set_max_locals(size); }
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   286
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   287
  int highest_comp_level() const;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   288
  void set_highest_comp_level(int level);
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   289
  int highest_osr_comp_level() const;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   290
  void set_highest_osr_comp_level(int level);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
47799
1772ebf07d1f 8152470: Add COMPILER2_OR_JVMCI definition
jcm
parents: 47634
diff changeset
   292
#if COMPILER2_OR_JVMCI
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
  // 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
   294
  void interpreter_throwout_increment(TRAPS) {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   295
    MethodCounters* mcs = get_method_counters(CHECK);
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   296
    if (mcs != NULL) {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   297
      mcs->interpreter_throwout_increment();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  }
37272
c427db4ea8c4 8148639: Some MethodCounter fields can be excluded when not including C2
cjplummer
parents: 36350
diff changeset
   300
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   302
  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
   303
    MethodCounters* mcs = method_counters();
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   304
    if (mcs == NULL) {
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   305
      return 0;
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   306
    } else {
24443
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   307
      return mcs->interpreter_throwout_count();
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   308
    }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   309
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
  // size of parameters
14745
03904dd8649b 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing.
jiangli
parents: 14587
diff changeset
   312
  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
   313
  void set_size_of_parameters(int size)          { constMethod()->set_size_of_parameters(size); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  bool has_stackmap_table() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
    return constMethod()->has_stackmap_table();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   319
  Array<u1>* stackmap_data() const {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
    return constMethod()->stackmap_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   323
  void set_stackmap_data(Array<u1>* sd) {
6974
a013f1c533a5 6991315: RedefineClasses fails with java.lang.VerifyError
kamg
parents: 6463
diff changeset
   324
    constMethod()->set_stackmap_data(sd);
a013f1c533a5 6991315: RedefineClasses fails with java.lang.VerifyError
kamg
parents: 6463
diff changeset
   325
  }
a013f1c533a5 6991315: RedefineClasses fails with java.lang.VerifyError
kamg
parents: 6463
diff changeset
   326
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  // exception handler table
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
  bool has_exception_handler() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
                             { return constMethod()->has_exception_handler(); }
13282
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   330
  int exception_table_length() const
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   331
                             { return constMethod()->exception_table_length(); }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   332
  ExceptionTableElement* exception_table_start() const
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   333
                             { return constMethod()->exception_table_start(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
  // Finds the first entry point bci of an exception handler for an
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
  // exception of klass ex_klass thrown at throw_bci. A value of NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  // for ex_klass indicates that the exception klass is not known; in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  // this case it matches any constraint class. Returns -1 if the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  // exception cannot be handled in this method. The handler
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  // constraint classes are loaded if necessary. Note that this may
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
  // throw an exception if loading of the constraint classes causes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  // an IllegalAccessError (bugid 4307310) or an OutOfMemoryError.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  // If an exception is thrown, returns the bci of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  // exception handler which caused the exception to be thrown, which
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  // is needed for proper retries. See, for example,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
  // InterpreterRuntime::exception_handler_for_exception.
46727
6e4a84748e2c 8183039: Re-examine methodHandle methods uninlined by 8144256
coleenp
parents: 46625
diff changeset
   347
  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
   348
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
  // method data access
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   350
  MethodData* method_data() const              {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
    return _method_data;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
  }
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   353
49340
4e82736053ae 8191102: Incorrect include file use in classLoader.hpp
hseigel
parents: 48557
diff changeset
   354
  void set_method_data(MethodData* data);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   356
  MethodCounters* method_counters() const {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   357
    return _method_counters;
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   358
  }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   359
26799
0c349e16bbe8 8058564: Tiered compilation performance drop in PIT
iveresov
parents: 26558
diff changeset
   360
  void clear_method_counters() {
0c349e16bbe8 8058564: Tiered compilation performance drop in PIT
iveresov
parents: 26558
diff changeset
   361
    _method_counters = NULL;
0c349e16bbe8 8058564: Tiered compilation performance drop in PIT
iveresov
parents: 26558
diff changeset
   362
  }
0c349e16bbe8 8058564: Tiered compilation performance drop in PIT
iveresov
parents: 26558
diff changeset
   363
47634
6a0c42c40cd1 8188220: Remove Atomic::*_ptr() uses and overloads from hotspot
coleenp
parents: 47216
diff changeset
   364
  bool init_method_counters(MethodCounters* counters);
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   365
8667
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
   366
#ifdef TIERED
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
   367
  // 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
   368
  // 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
   369
  int prev_event_count() const                   {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   370
    if (method_counters() == NULL) {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   371
      return 0;
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   372
    } else {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   373
      return method_counters()->interpreter_invocation_count();
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   374
    }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   375
  }
24443
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   376
  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
   377
    MethodCounters* mcs = method_counters();
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   378
    if (mcs != NULL) {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   379
      mcs->set_interpreter_invocation_count(count);
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   380
    }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   381
  }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   382
  jlong prev_time() const                        {
24443
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   383
    MethodCounters* mcs = method_counters();
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   384
    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
   385
  }
24443
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   386
  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
   387
    MethodCounters* mcs = method_counters();
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   388
    if (mcs != NULL) {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   389
      mcs->set_prev_time(time);
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   390
    }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   391
  }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   392
  float rate() const                             {
24443
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   393
    MethodCounters* mcs = method_counters();
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   394
    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
   395
  }
24443
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   396
  void set_rate(float rate) {
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   397
    MethodCounters* mcs = method_counters();
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   398
    if (mcs != NULL) {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   399
      mcs->set_rate(rate);
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   400
    }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   401
  }
42650
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   402
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   403
#if INCLUDE_AOT
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   404
  void set_aot_code(CompiledMethod* aot_code) {
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   405
    _aot_code = aot_code;
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   406
  }
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   407
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   408
  CompiledMethod* aot_code() const {
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   409
    return _aot_code;
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   410
  }
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   411
#else
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   412
  CompiledMethod* aot_code() const { return NULL; }
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   413
#endif // INCLUDE_AOT
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   414
#endif // TIERED
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   415
24442
4d4ae31dea26 8032463: VirtualDispatch test timeout with DeoptimizeALot
iveresov
parents: 24322
diff changeset
   416
  int nmethod_age() const {
4d4ae31dea26 8032463: VirtualDispatch test timeout with DeoptimizeALot
iveresov
parents: 24322
diff changeset
   417
    if (method_counters() == NULL) {
4d4ae31dea26 8032463: VirtualDispatch test timeout with DeoptimizeALot
iveresov
parents: 24322
diff changeset
   418
      return INT_MAX;
4d4ae31dea26 8032463: VirtualDispatch test timeout with DeoptimizeALot
iveresov
parents: 24322
diff changeset
   419
    } else {
4d4ae31dea26 8032463: VirtualDispatch test timeout with DeoptimizeALot
iveresov
parents: 24322
diff changeset
   420
      return method_counters()->nmethod_age();
4d4ae31dea26 8032463: VirtualDispatch test timeout with DeoptimizeALot
iveresov
parents: 24322
diff changeset
   421
    }
4d4ae31dea26 8032463: VirtualDispatch test timeout with DeoptimizeALot
iveresov
parents: 24322
diff changeset
   422
  }
8667
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
   423
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   424
  int invocation_count();
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   425
  int backedge_count();
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   426
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   427
  bool was_executed_more_than(int n);
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   428
  bool was_never_executed()                      { return !was_executed_more_than(0); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 33230
diff changeset
   430
  static void build_interpreter_method_data(const methodHandle& method, TRAPS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   432
  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
   433
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   434
  int interpreter_invocation_count() {
24443
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   435
    if (TieredCompilation) {
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   436
      return invocation_count();
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   437
    } else {
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   438
      MethodCounters* mcs = method_counters();
7aaf1b306b55 8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents: 24442
diff changeset
   439
      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
   440
    }
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   441
  }
47799
1772ebf07d1f 8152470: Add COMPILER2_OR_JVMCI definition
jcm
parents: 47634
diff changeset
   442
#if COMPILER2_OR_JVMCI
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   443
  int increment_interpreter_invocation_count(TRAPS) {
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   444
    if (TieredCompilation) ShouldNotReachHere();
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   445
    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
   446
    return (mcs == NULL) ? 0 : mcs->increment_interpreter_invocation_count();
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   447
  }
37272
c427db4ea8c4 8148639: Some MethodCounter fields can be excluded when not including C2
cjplummer
parents: 36350
diff changeset
   448
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
#ifndef PRODUCT
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   451
  int  compiled_invocation_count() const         { return _compiled_invocation_count;  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
  void set_compiled_invocation_count(int count)  { _compiled_invocation_count = count; }
23526
6851d341ad52 8037970: make PrintMethodData a diagnostic options
roland
parents: 23219
diff changeset
   453
#else
6851d341ad52 8037970: make PrintMethodData a diagnostic options
roland
parents: 23219
diff changeset
   454
  // for PrintMethodData in a product build
6851d341ad52 8037970: make PrintMethodData a diagnostic options
roland
parents: 23219
diff changeset
   455
  int  compiled_invocation_count() const         { return 0;  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
#endif // not PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
2131
98f9cef66a34 6810672: Comment typos
twisti
parents: 1894
diff changeset
   458
  // Clear (non-shared space) pointers which could not be relevant
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
  // if this (shared) method were mapped into another JVM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
  void remove_unshareable_info();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
  // nmethod/verified compiler entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
  address verified_code_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
  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
   465
  CompiledMethod* volatile code() const;
55479
80b27dc96ca3 8226699: [BACKOUT] JDK-8221734 Deoptimize with handshakes
dcubed
parents: 55206
diff changeset
   466
  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
   467
  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
   468
  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
   469
    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
   470
  }
54927
1512d88b24c6 8207812: Implement Dynamic CDS Archive
ccheung
parents: 54721
diff changeset
   471
  void set_adapter_trampoline(AdapterHandlerEntry** trampoline) {
1512d88b24c6 8207812: Implement Dynamic CDS Archive
ccheung
parents: 54721
diff changeset
   472
    constMethod()->set_adapter_trampoline(trampoline);
1512d88b24c6 8207812: Implement Dynamic CDS Archive
ccheung
parents: 54721
diff changeset
   473
  }
37439
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   474
  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
   475
    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
   476
  }
54927
1512d88b24c6 8207812: Implement Dynamic CDS Archive
ccheung
parents: 54721
diff changeset
   477
  void set_from_compiled_entry(address entry) {
1512d88b24c6 8207812: Implement Dynamic CDS Archive
ccheung
parents: 54721
diff changeset
   478
    _from_compiled_entry =  entry;
1512d88b24c6 8207812: Implement Dynamic CDS Archive
ccheung
parents: 54721
diff changeset
   479
  }
37439
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   480
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
  address get_i2c_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
  address get_c2i_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
  address get_c2i_unverified_entry();
55749
cff8aad2593f 8227260: JNI upcalls should bypass class initialization barrier in c2i adapter
vlivanov
parents: 55479
diff changeset
   484
  address get_c2i_no_clinit_check_entry();
37439
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   485
  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
   486
    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
   487
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
  // setup entry points
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 33230
diff changeset
   489
  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
   490
  // 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
   491
  void unlink_method() NOT_CDS_RETURN;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
46746
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46727
diff changeset
   493
  virtual void metaspace_pointers_do(MetaspaceClosure* iter);
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46727
diff changeset
   494
  virtual MetaspaceObj::Type type() const { return MethodType; }
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46727
diff changeset
   495
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
  // vtable index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  enum VtableIndexFlag {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
    // Valid vtable indexes are non-negative (>= 0).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
    // 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
   500
    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
   501
    pending_itable_index    = -9,  // itable index will be assigned
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
    invalid_vtable_index    = -4,  // distinct from any valid vtable index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
    garbage_vtable_index    = -3,  // not yet linked; no vtable layout yet
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
    nonvirtual_vtable_index = -2   // there is no need for vtable dispatch
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
    // 6330203 Note:  Do not use -1, which was overloaded with many meanings.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
  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
   508
  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
   509
  int  vtable_index() const                      { return _vtable_index; }
39714
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 39450
diff changeset
   510
  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
   511
  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
   512
  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
   513
  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
   514
                                                   return itable_index_max - _vtable_index; }
39714
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 39450
diff changeset
   515
  void set_itable_index(int index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
  // interpreter entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
  address interpreter_entry() const              { return _i2i_entry; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
  // 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
   520
  void set_interpreter_entry(address entry) {
54927
1512d88b24c6 8207812: Implement Dynamic CDS Archive
ccheung
parents: 54721
diff changeset
   521
    assert(!is_shared(),
1512d88b24c6 8207812: Implement Dynamic CDS Archive
ccheung
parents: 54721
diff changeset
   522
           "shared method's interpreter entry should not be changed at run time");
37439
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   523
    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
   524
      _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
   525
    }
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   526
    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
   527
      _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
   528
    }
e8970711113b 8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents: 36350
diff changeset
   529
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
  // native function (used for native methods only)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
  enum {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
    native_bind_event_is_interesting = true
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
  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
   536
  address critical_native_function();
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11480
diff changeset
   537
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
  // Must specify a real function (not NULL).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
  // Use clear_native_function() to unregister.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
  void set_native_function(address function, bool post_event_flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
  bool has_native_function() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
  void clear_native_function();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
  // signature handler (used for native methods only)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
  address signature_handler() const              { return *(signature_handler_addr()); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
  void set_signature_handler(address handler);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
  // Interpreter oopmap support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
  void mask_for(int bci, InterpreterOopMap* mask);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
  // operations on invocation counter
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   552
  void print_invocation_count();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
  // byte codes
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 3824
diff changeset
   555
  void    set_code(address code)      { return constMethod()->set_code(code); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  address code_base() const           { return constMethod()->code_base(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
  bool    contains(address bcp) const { return constMethod()->contains(bcp); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
  // prints byte codes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
  void print_codes() const            { print_codes_on(tty); }
23526
6851d341ad52 8037970: make PrintMethodData a diagnostic options
roland
parents: 23219
diff changeset
   561
  void print_codes_on(outputStream* st) const;
6851d341ad52 8037970: make PrintMethodData a diagnostic options
roland
parents: 23219
diff changeset
   562
  void print_codes_on(int from, int to, outputStream* st) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
15102
0a86564e5f61 8004728: Add hotspot support for parameter reflection
coleenp
parents: 15098
diff changeset
   564
  // method parameters
15744
fd58c7e770b3 8007153: Ensure that MethodParameters API works properly with RedefineClasses
emc
parents: 15601
diff changeset
   565
  bool has_method_parameters() const
fd58c7e770b3 8007153: Ensure that MethodParameters API works properly with RedefineClasses
emc
parents: 15601
diff changeset
   566
                         { return constMethod()->has_method_parameters(); }
15102
0a86564e5f61 8004728: Add hotspot support for parameter reflection
coleenp
parents: 15098
diff changeset
   567
  int method_parameters_length() const
0a86564e5f61 8004728: Add hotspot support for parameter reflection
coleenp
parents: 15098
diff changeset
   568
                         { return constMethod()->method_parameters_length(); }
0a86564e5f61 8004728: Add hotspot support for parameter reflection
coleenp
parents: 15098
diff changeset
   569
  MethodParametersElement* method_parameters_start() const
0a86564e5f61 8004728: Add hotspot support for parameter reflection
coleenp
parents: 15098
diff changeset
   570
                          { return constMethod()->method_parameters_start(); }
0a86564e5f61 8004728: Add hotspot support for parameter reflection
coleenp
parents: 15098
diff changeset
   571
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
  // checked exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
  int checked_exceptions_length() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
                         { return constMethod()->checked_exceptions_length(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
  CheckedExceptionElement* checked_exceptions_start() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
                          { return constMethod()->checked_exceptions_start(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
  // localvariable table
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
  bool has_localvariable_table() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
                          { return constMethod()->has_localvariable_table(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
  int localvariable_table_length() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
                        { return constMethod()->localvariable_table_length(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
  LocalVariableTableElement* localvariable_table_start() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
                         { return constMethod()->localvariable_table_start(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
  bool has_linenumber_table() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
                              { return constMethod()->has_linenumber_table(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
  u_char* compressed_linenumber_table() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
                       { return constMethod()->compressed_linenumber_table(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   591
  // 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
   592
  InstanceKlass* method_holder() const         { return constants()->pool_holder(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
  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
   595
  Symbol* klass_name() const;                    // returns the name of the method holder
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
  BasicType result_type() const;                 // type of the method result
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
  bool is_returning_oop() const                  { BasicType r = result_type(); return (r == T_OBJECT || r == T_ARRAY); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
  bool is_returning_fp() const                   { BasicType r = result_type(); return (r == T_FLOAT || r == T_DOUBLE); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
  // Checked exceptions thrown by this method (resolved to mirrors)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
  objArrayHandle resolved_checked_exceptions(TRAPS) { return resolved_checked_exceptions_impl(this, THREAD); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
  // Access flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
  bool is_public() const                         { return access_flags().is_public();      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
  bool is_private() const                        { return access_flags().is_private();     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
  bool is_protected() const                      { return access_flags().is_protected();   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
  bool is_package_private() const                { return !is_public() && !is_private() && !is_protected(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
  bool is_static() const                         { return access_flags().is_static();      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
  bool is_final() const                          { return access_flags().is_final();       }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
  bool is_synchronized() const                   { return access_flags().is_synchronized();}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
  bool is_native() const                         { return access_flags().is_native();      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
  bool is_abstract() const                       { return access_flags().is_abstract();    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
  bool is_strict() const                         { return access_flags().is_strict();      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
  bool is_synthetic() const                      { return access_flags().is_synthetic();   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
  // returns true if contains only return operation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
  bool is_empty_method() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
  // returns true if this is a vanilla constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
  bool is_vanilla_constructor() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
  // checks method and its method holder
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
  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
   624
  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
   625
  // interface method declared with 'default' - excludes private interface methods
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20017
diff changeset
   626
  bool is_default_method() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
  // true if method needs no dynamic dispatch (final and/or no vtable entry)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
  bool can_be_statically_bound() const;
54721
3661ad97da8f 8223171: Redundant nmethod dependencies for effectively final methods
vlivanov
parents: 54432
diff changeset
   630
  bool can_be_statically_bound(InstanceKlass* context) const;
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19720
diff changeset
   631
  bool can_be_statically_bound(AccessFlags class_access_flags) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
  // returns true if the method has any backward branches.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
  bool has_loops() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
    return access_flags().loops_flag_init() ? access_flags().has_loops() : compute_has_loops_flag();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
  bool compute_has_loops_flag();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
  bool has_jsrs() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
    return access_flags().has_jsrs();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
  void set_has_jsrs() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
    _access_flags.set_has_jsrs();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
  // returns true if the method has any monitors.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
  bool has_monitors() const                      { return is_synchronized() || access_flags().has_monitor_bytecodes(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
  bool has_monitor_bytecodes() const             { return access_flags().has_monitor_bytecodes(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
  void set_has_monitor_bytecodes()               { _access_flags.set_has_monitor_bytecodes(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
  // monitor matching. This returns a conservative estimate of whether the monitorenter/monitorexit bytecodes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
  // 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
   655
  // has not been computed yet.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
  bool guaranteed_monitor_matching() const       { return access_flags().is_monitor_matching(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
  void set_guaranteed_monitor_matching()         { _access_flags.set_monitor_matching(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
  // returns true if the method is an accessor function (setter/getter).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
  bool is_accessor() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
34169
b0b7187852b7 8140650: Method::is_accessor should cover getters and setters for all types
shade
parents: 33230
diff changeset
   662
  // 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
   663
  bool is_getter() const;
b0b7187852b7 8140650: Method::is_accessor should cover getters and setters for all types
shade
parents: 33230
diff changeset
   664
b0b7187852b7 8140650: Method::is_accessor should cover getters and setters for all types
shade
parents: 33230
diff changeset
   665
  // 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
   666
  bool is_setter() const;
b0b7187852b7 8140650: Method::is_accessor should cover getters and setters for all types
shade
parents: 33230
diff changeset
   667
27643
fe8f95a2d9bc 8056071: compiler/whitebox/IsMethodCompilableTest.java fails with 'method() is not compilable after 3 iterations'
thartmann
parents: 27478
diff changeset
   668
  // 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
   669
  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
   670
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
  // returns true if the method is an initializer (<init> or <clinit>).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
  bool is_initializer() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
8653
8797d788a4f1 6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents: 8313
diff changeset
   674
  // 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
   675
  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
   676
8797d788a4f1 6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents: 8313
diff changeset
   677
  // 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
   678
  // 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
   679
  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
   680
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38144
diff changeset
   681
  // returns true if the method name is <init>
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38144
diff changeset
   682
  bool is_object_initializer() const;
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38144
diff changeset
   683
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
  // compiled code support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
  // NOTE: code() is inherently racy as deopt can be clearing code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
  // simultaneously. Use with caution.
49340
4e82736053ae 8191102: Incorrect include file use in classLoader.hpp
hseigel
parents: 48557
diff changeset
   687
  bool has_compiled_code() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
42650
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   689
#ifdef TIERED
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   690
  bool has_aot_code() const                      { return aot_code() != NULL; }
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   691
#endif
1f304d0c888b 8171008: Integrate AOT compiler into JDK
kvn
parents: 42040
diff changeset
   692
55105
9ad765641e8f 8223213: Implement fast class initialization checks on x86-64
vlivanov
parents: 55005
diff changeset
   693
  bool needs_clinit_barrier() const;
9ad765641e8f 8223213: Implement fast class initialization checks on x86-64
vlivanov
parents: 55005
diff changeset
   694
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
  // sizing
44524
b0d3e8ba6f27 8170812: Metaspace corruption caused by incorrect memory size for MethodCounters
aph
parents: 43453
diff changeset
   696
  static int header_size()                       {
46619
a3919f5e8d2b 8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents: 46618
diff changeset
   697
    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
   698
  }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   699
  static int size(bool is_native);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   700
  int size() const                               { return method_size(); }
15437
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 15110
diff changeset
   701
#if INCLUDE_SERVICES
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 15110
diff changeset
   702
  void collect_statistics(KlassSizeStats *sz) const;
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 15110
diff changeset
   703
#endif
31790
4a08476437e8 8025692: Log what methods are touched at run-time
minqi
parents: 31587
diff changeset
   704
  void log_touched(TRAPS);
4a08476437e8 8025692: Log what methods are touched at run-time
minqi
parents: 31587
diff changeset
   705
  static void print_touched_methods(outputStream* out);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
  // interpreter support
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   708
  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
   709
  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
   710
  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
   711
  static ByteSize code_offset()                  { return byte_offset_of(Method, _code); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
  static ByteSize method_data_offset()           {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   713
    return byte_offset_of(Method, _method_data);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
  }
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   715
  static ByteSize method_counters_offset()       {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   716
    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
   717
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
#ifndef PRODUCT
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   719
  static ByteSize compiled_invocation_counter_offset() { return byte_offset_of(Method, _compiled_invocation_count); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
#endif // not PRODUCT
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   721
  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
   722
  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
   723
  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
   724
  static ByteSize signature_handler_offset()     { return in_ByteSize(sizeof(Method) + wordSize);      }
48557
2e867226b914 8174962: Better interface invocations
vlivanov
parents: 47799
diff changeset
   725
  static ByteSize itable_index_offset()          { return byte_offset_of(Method, _vtable_index ); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
  // for code generation
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   728
  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
   729
  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
   730
  static int intrinsic_id_size_in_bytes()        { return sizeof(u2); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
  // Static methods that are used to implement member methods where an exposed this pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
  // is needed due to possible GCs
23515
f4872ef5df09 8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents: 23219
diff changeset
   734
  static objArrayHandle resolved_checked_exceptions_impl(Method* method, TRAPS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
  // Returns the byte code index from the byte code pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
  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
   738
  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
   739
  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
   740
  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
   741
  int validate_bci(int bci) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
  // Returns the line number for a bci if debugging information for the method is prowided,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
  // -1 is returned otherwise.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
  int line_number_from_bci(int bci) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
  // Reflection support
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   748
  bool is_overridden_in(Klass* k) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15744
diff changeset
   750
  // Stack walking support
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15744
diff changeset
   751
  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
   752
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2154
diff changeset
   753
  // JSR 292 support
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   754
  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
   755
  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
   756
  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
   757
  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
   758
                                                   Symbol* signature, //anything at all
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   759
                                                   TRAPS);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   760
  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
   761
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32820
diff changeset
   762
  enum {
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32820
diff changeset
   763
    // How many extra stack entries for invokedynamic
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32820
diff changeset
   764
    extra_stack_entries_for_jsr292 = 1
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32820
diff changeset
   765
  };
17875
9d4aa49a1d76 8010460: Interpreter on some platforms loads ConstMethod::_max_stack and misses extra stack slots for JSR 292
roland
parents: 17372
diff changeset
   766
9d4aa49a1d76 8010460: Interpreter on some platforms loads ConstMethod::_max_stack and misses extra stack slots for JSR 292
roland
parents: 17372
diff changeset
   767
  // this operates only on invoke methods:
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2154
diff changeset
   768
  // 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
   769
  // Account for the extra appendix argument for invokehandle/invokedynamic
24322
c2978d1578e3 8036956: remove EnableInvokeDynamic flag
anoll
parents: 23872
diff changeset
   770
  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
   771
  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
   772
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
  // RedefineClasses() support:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
  bool is_old() const                               { return access_flags().is_old(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
  void set_is_old()                                 { _access_flags.set_is_old(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
  bool is_obsolete() const                          { return access_flags().is_obsolete(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
  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
   778
  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
   779
  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
   780
b7df27df6384 8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents: 25895
diff changeset
   781
  bool is_running_emcp() const {
b7df27df6384 8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents: 25895
diff changeset
   782
    // 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
   783
    // 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
   784
    // 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
   785
    // pool might be different.
b7df27df6384 8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents: 25895
diff changeset
   786
    // 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
   787
    // 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
   788
    return (_flags & _running_emcp) != 0;
b7df27df6384 8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents: 25895
diff changeset
   789
  }
b7df27df6384 8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents: 25895
diff changeset
   790
b7df27df6384 8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents: 25895
diff changeset
   791
  void set_running_emcp(bool x) {
b7df27df6384 8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents: 25895
diff changeset
   792
    _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
   793
  }
b7df27df6384 8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents: 25895
diff changeset
   794
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   795
  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
   796
  void set_on_stack(const bool value);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   797
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   798
  // 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
   799
  bool should_not_be_cached() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
  // JVMTI Native method prefixing support:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
  bool is_prefixed_native() const                   { return access_flags().is_prefixed_native(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
  void set_is_prefixed_native()                     { _access_flags.set_is_prefixed_native(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
  // Rewriting support
46727
6e4a84748e2c 8183039: Re-examine methodHandle methods uninlined by 8144256
coleenp
parents: 46625
diff changeset
   806
  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
   807
                                          u_char* new_compressed_linenumber_table, int new_compressed_linenumber_size, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   809
  // jmethodID handling
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   810
  // 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
   811
  // 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
   812
  // 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
   813
  // 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
   814
  // 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
   815
  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
   816
  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
   817
27478
0eedae0228ac 8062116: JVMTI GetClassMethods is Slow
jmanson
parents: 27434
diff changeset
   818
  // Ensure there is enough capacity in the internal tracking data
0eedae0228ac 8062116: JVMTI GetClassMethods is Slow
jmanson
parents: 27434
diff changeset
   819
  // structures to hold the number of jmethodIDs you plan to generate.
0eedae0228ac 8062116: JVMTI GetClassMethods is Slow
jmanson
parents: 27434
diff changeset
   820
  // This saves substantial time doing allocations.
0eedae0228ac 8062116: JVMTI GetClassMethods is Slow
jmanson
parents: 27434
diff changeset
   821
  static void ensure_jmethod_ids(ClassLoaderData* loader_data, int capacity);
0eedae0228ac 8062116: JVMTI GetClassMethods is Slow
jmanson
parents: 27434
diff changeset
   822
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   823
  // 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
   824
  // 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
   825
  // result guaranteed not to be NULL.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   826
  inline static Method* resolve_jmethod_id(jmethodID mid) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   827
    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
   828
    return *((Method**)mid);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   829
  }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   830
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   831
  // 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
   832
  // 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
   833
  // 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
   834
  static Method* checked_resolve_jmethod_id(jmethodID mid);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   835
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   836
  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
   837
  static bool is_method_id(jmethodID mid);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   838
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   839
  // Clear methods
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   840
  static void clear_jmethod_ids(ClassLoaderData* loader_data);
49348
fde3feaaa4ed 8198926: Move ClassLoaderData::_dependencies to ClassLoaderData::_handles
coleenp
parents: 49340
diff changeset
   841
  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
   842
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
  // Get this method's jmethodID -- allocate if it doesn't exist
46341
4c676683bdb9 8176705: Remove static functions in InstanceKlass
hseigel
parents: 46329
diff changeset
   844
  jmethodID jmethod_id()                            { return method_holder()->get_jmethod_id(this); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
  // Lookup the jmethodID for this method.  Return NULL if not found.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
  // NOTE that this function can be called from a signal handler
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
  // (see AsyncGetCallTrace support for Forte Analyzer) and this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
  // needs to be async-safe. No allocation should be done and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
  // 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
   851
  jmethodID find_jmethod_id_or_null()               { return method_holder()->jmethod_id_or_null(this); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
  // Support for inlining of intrinsic methods
3273
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2570
diff changeset
   854
  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
   855
  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
   856
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2570
diff changeset
   857
  // 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
   858
  void init_intrinsic_id();     // updates from _none if a match
34666
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 34185
diff changeset
   859
  static vmSymbols::SID klass_id_for_intrinsics(const Klass* holder);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
23219
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   861
  bool caller_sensitive() {
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   862
    return (_flags & _caller_sensitive) != 0;
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   863
  }
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   864
  void set_caller_sensitive(bool x) {
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   865
    _flags = x ? (_flags | _caller_sensitive) : (_flags & ~_caller_sensitive);
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   866
  }
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   867
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   868
  bool force_inline() {
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   869
    return (_flags & _force_inline) != 0;
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   870
  }
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   871
  void set_force_inline(bool x) {
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   872
    _flags = x ? (_flags | _force_inline) : (_flags & ~_force_inline);
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   873
  }
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   874
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   875
  bool dont_inline() {
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   876
    return (_flags & _dont_inline) != 0;
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   877
  }
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   878
  void set_dont_inline(bool x) {
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   879
    _flags = x ? (_flags | _dont_inline) : (_flags & ~_dont_inline);
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   880
  }
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   881
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   882
  bool is_hidden() {
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   883
    return (_flags & _hidden) != 0;
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   884
  }
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   885
  void set_hidden(bool x) {
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   886
    _flags = x ? (_flags | _hidden) : (_flags & ~_hidden);
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   887
  }
69e72eaf9f51 8037043: put Method flag bits in predictable positions
twisti
parents: 22876
diff changeset
   888
31587
e48945b7849c 8076112: Add @HotSpotIntrinsicCandidate annotation to indicate methods for which Java Runtime has intrinsics
zmajo
parents: 31228
diff changeset
   889
  bool intrinsic_candidate() {
e48945b7849c 8076112: Add @HotSpotIntrinsicCandidate annotation to indicate methods for which Java Runtime has intrinsics
zmajo
parents: 31228
diff changeset
   890
    return (_flags & _intrinsic_candidate) != 0;
e48945b7849c 8076112: Add @HotSpotIntrinsicCandidate annotation to indicate methods for which Java Runtime has intrinsics
zmajo
parents: 31228
diff changeset
   891
  }
e48945b7849c 8076112: Add @HotSpotIntrinsicCandidate annotation to indicate methods for which Java Runtime has intrinsics
zmajo
parents: 31228
diff changeset
   892
  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
   893
    _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
   894
  }
e48945b7849c 8076112: Add @HotSpotIntrinsicCandidate annotation to indicate methods for which Java Runtime has intrinsics
zmajo
parents: 31228
diff changeset
   895
31228
8e427370cdd1 8074551: GWT can be marked non-compilable due to deopt count pollution
vlivanov
parents: 29316
diff changeset
   896
  bool has_injected_profile() {
8e427370cdd1 8074551: GWT can be marked non-compilable due to deopt count pollution
vlivanov
parents: 29316
diff changeset
   897
    return (_flags & _has_injected_profile) != 0;
8e427370cdd1 8074551: GWT can be marked non-compilable due to deopt count pollution
vlivanov
parents: 29316
diff changeset
   898
  }
8e427370cdd1 8074551: GWT can be marked non-compilable due to deopt count pollution
vlivanov
parents: 29316
diff changeset
   899
  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
   900
    _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
   901
  }
8e427370cdd1 8074551: GWT can be marked non-compilable due to deopt count pollution
vlivanov
parents: 29316
diff changeset
   902
35071
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 34666
diff changeset
   903
  bool has_reserved_stack_access() {
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 34666
diff changeset
   904
    return (_flags & _reserved_stack_access) != 0;
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 34666
diff changeset
   905
  }
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 34666
diff changeset
   906
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 34666
diff changeset
   907
  void set_has_reserved_stack_access(bool x) {
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 34666
diff changeset
   908
    _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
   909
  }
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 34666
diff changeset
   910
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents: 49348
diff changeset
   911
  JFR_ONLY(DEFINE_TRACE_FLAG_ACCESSOR;)
43453
a2097d148d0e 8171960: Event-based tracing needs separate flag representation for Method
mgronlun
parents: 42650
diff changeset
   912
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   913
  ConstMethod::MethodType method_type() const {
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   914
      return _constMethod->method_type();
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   915
  }
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   916
  bool is_overpass() const { return method_type() == ConstMethod::OVERPASS; }
13291
9de3b1387cb8 6711908: JVM needs direct access to some annotations
jrose
parents: 12960
diff changeset
   917
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
  // On-stack replacement support
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   919
  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
   920
   return method_holder()->lookup_osr_nmethod(this, InvocationEntryBci, level, match_level) != NULL;
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   921
  }
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   922
27434
b4b185d05bb5 8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents: 26799
diff changeset
   923
  int mark_osr_nmethods() {
b4b185d05bb5 8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents: 26799
diff changeset
   924
    return method_holder()->mark_osr_nmethods(this);
b4b185d05bb5 8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents: 26799
diff changeset
   925
  }
b4b185d05bb5 8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents: 26799
diff changeset
   926
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   927
  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
   928
    return method_holder()->lookup_osr_nmethod(this, bci, level, match_level);
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   929
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
  // Find if klass for method is loaded
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
  bool is_klass_loaded_by_klass_index(int klass_index) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
  bool is_klass_loaded(int refinfo_index, bool must_be_resolved = false) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
  // Indicates whether compilation failed earlier for this method, or
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
  // whether it is not compilable for another reason like having a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   937
  // breakpoint set in it.
13891
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   938
  bool  is_not_compilable(int comp_level = CompLevel_any) const;
55206
2fe2063fe567 8225019: Update JVMCI
kvn
parents: 55105
diff changeset
   939
  void set_not_compilable(const char* reason, int comp_level = CompLevel_all, bool report = true);
2fe2063fe567 8225019: Update JVMCI
kvn
parents: 55105
diff changeset
   940
  void set_not_compilable_quietly(const char* reason, int comp_level = CompLevel_all) {
2fe2063fe567 8225019: Update JVMCI
kvn
parents: 55105
diff changeset
   941
    set_not_compilable(reason, comp_level, false);
4756
da88c27a9241 6923043: failed nightly tests which use -XX:+PrintCompilation -Xcomp -XX:CompileOnly
kvn
parents: 4750
diff changeset
   942
  }
13891
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   943
  bool  is_not_osr_compilable(int comp_level = CompLevel_any) const;
55206
2fe2063fe567 8225019: Update JVMCI
kvn
parents: 55105
diff changeset
   944
  void set_not_osr_compilable(const char* reason, int comp_level = CompLevel_all, bool report = true);
2fe2063fe567 8225019: Update JVMCI
kvn
parents: 55105
diff changeset
   945
  void set_not_osr_compilable_quietly(const char* reason, int comp_level = CompLevel_all) {
2fe2063fe567 8225019: Update JVMCI
kvn
parents: 55105
diff changeset
   946
    set_not_osr_compilable(reason, comp_level, false);
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   947
  }
19720
1f9f216fa43e 8023976: assert(!CompilationPolicy::can_be_compiled(this, comp_level)) failed: sanity check
vlivanov
parents: 17875
diff changeset
   948
  bool is_always_compilable() const;
13891
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   949
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   950
 private:
15479
e3c00ec80145 8006613: adding reason to made_not_compilable
vlivanov
parents: 15110
diff changeset
   951
  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
   952
20695
4f5a5e95090b 8025566: EXCEPTION_ACCESS_VIOLATION in compiled by C1 String.valueOf method
twisti
parents: 20017
diff changeset
   953
 public:
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   954
  MethodCounters* get_method_counters(TRAPS) {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   955
    if (_method_counters == NULL) {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   956
      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
   957
    }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   958
    return _method_counters;
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   959
  }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
   960
16689
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16617
diff changeset
   961
  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
   962
  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
   963
  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
   964
  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
   965
  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
   966
  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
   967
16689
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16617
diff changeset
   968
  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
   969
  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
   970
  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
   971
  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
   972
  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
   973
  void clear_not_c2_osr_compilable()          {       _access_flags.clear_not_c2_osr_compilable(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
  // Background compilation support
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   976
  bool queued_for_compilation() const  { return access_flags().queued_for_compilation(); }
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   977
  void set_queued_for_compilation()    { _access_flags.set_queued_for_compilation();     }
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   978
  void clear_queued_for_compilation()  { _access_flags.clear_queued_for_compilation();   }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
  // Resolve all classes in signature, return 'true' if successful
46727
6e4a84748e2c 8183039: Re-examine methodHandle methods uninlined by 8144256
coleenp
parents: 46625
diff changeset
   981
  static bool load_signature_classes(const methodHandle& m, TRAPS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
  // 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
   984
  static bool has_unloaded_classes_in_signature(const methodHandle& m, TRAPS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
  // Printing
15591
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 15450
diff changeset
   987
  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
   988
#if INCLUDE_JVMTI
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 15450
diff changeset
   989
  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
   990
#else
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   991
  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
   992
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
  // Helper routine used for method sorting
53432
1ec56532ae0c 8217424: Remove the idempotent parameter to Method::sort_methods
iklam
parents: 53244
diff changeset
   995
  static void sort_methods(Array<Method*>* methods, bool set_idnums = true);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   997
  // 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
   998
  void deallocate_contents(ClassLoaderData* loader_data);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   999
53904
9c3fe09f69bc 8078725: method adjustments can be done just once for all classes involved into redefinition
coleenp
parents: 53432
diff changeset
  1000
  Method* get_new_method() const {
9c3fe09f69bc 8078725: method adjustments can be done just once for all classes involved into redefinition
coleenp
parents: 53432
diff changeset
  1001
    InstanceKlass* holder = method_holder();
9c3fe09f69bc 8078725: method adjustments can be done just once for all classes involved into redefinition
coleenp
parents: 53432
diff changeset
  1002
    Method* new_method = holder->method_with_idnum(orig_method_idnum());
9c3fe09f69bc 8078725: method adjustments can be done just once for all classes involved into redefinition
coleenp
parents: 53432
diff changeset
  1003
9c3fe09f69bc 8078725: method adjustments can be done just once for all classes involved into redefinition
coleenp
parents: 53432
diff changeset
  1004
    assert(new_method != NULL, "method_with_idnum() should not be NULL");
9c3fe09f69bc 8078725: method adjustments can be done just once for all classes involved into redefinition
coleenp
parents: 53432
diff changeset
  1005
    assert(this != new_method, "sanity check");
9c3fe09f69bc 8078725: method adjustments can be done just once for all classes involved into redefinition
coleenp
parents: 53432
diff changeset
  1006
    return new_method;
9c3fe09f69bc 8078725: method adjustments can be done just once for all classes involved into redefinition
coleenp
parents: 53432
diff changeset
  1007
  }
9c3fe09f69bc 8078725: method adjustments can be done just once for all classes involved into redefinition
coleenp
parents: 53432
diff changeset
  1008
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1009
  // Printing
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1010
#ifndef PRODUCT
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1011
  void print_on(outputStream* st) const;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1012
#endif
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1013
  void print_value_on(outputStream* st) const;
35463
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 35071
diff changeset
  1014
  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
  1015
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1016
  const char* internal_name() const { return "{method}"; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1017
14579
7f6ce6e3dd80 8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents: 14391
diff changeset
  1018
  // Check for valid method pointer
24457
0e20b36df5c4 8038212: Method::is_valid_method() check has performance regression impact for stackwalking
coleenp
parents: 24322
diff changeset
  1019
  static bool has_method_vptr(const void* ptr);
51263
b5aac518b097 8207779: Method::is_valid_method() compares 'this' with NULL
hseigel
parents: 50416
diff changeset
  1020
  static bool is_valid_method(const Method* m);
14579
7f6ce6e3dd80 8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents: 14391
diff changeset
  1021
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1022
  // Verify
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1023
  void verify() { verify_on(tty); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1024
  void verify_on(outputStream* st);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1025
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
  // Inlined elements
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
  address* native_function_addr() const          { assert(is_native(), "must be native"); return (address*) (this+1); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
  address* signature_handler_addr() const        { return native_function_addr() + 1; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
// Utility class for compressing line number tables
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
class CompressedLineNumberWriteStream: public CompressedWriteStream {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
  int _bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
  int _line;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
  // Constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
  CompressedLineNumberWriteStream(int initial_size) : CompressedWriteStream(initial_size), _bci(0), _line(0) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1043
  CompressedLineNumberWriteStream(u_char* buffer, int initial_size) : CompressedWriteStream(buffer, initial_size), _bci(0), _line(0) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
  // Write (bci, line number) pair to stream
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
  void write_pair_regular(int bci_delta, int line_delta);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1047
54042
6dd6f988b4e4 8219860: Cleanup ClassFileParser::parse_linenumber_table
redestad
parents: 53904
diff changeset
  1048
  // If (bci delta, line delta) fits in (5-bit unsigned, 3-bit unsigned)
6dd6f988b4e4 8219860: Cleanup ClassFileParser::parse_linenumber_table
redestad
parents: 53904
diff changeset
  1049
  // we save it as one byte, otherwise we write a 0xFF escape character
6dd6f988b4e4 8219860: Cleanup ClassFileParser::parse_linenumber_table
redestad
parents: 53904
diff changeset
  1050
  // and use regular compression. 0x0 is used as end-of-stream terminator.
6dd6f988b4e4 8219860: Cleanup ClassFileParser::parse_linenumber_table
redestad
parents: 53904
diff changeset
  1051
  void write_pair_inline(int bci, int line);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
  void write_pair(int bci, int line);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1054
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1055
  // Write end-of-stream marker
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1056
  void write_terminator()                        { write_byte(0); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
// Utility class for decompressing line number tables
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
class CompressedLineNumberReadStream: public CompressedReadStream {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
  int _bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
  int _line;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
  // Constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
  CompressedLineNumberReadStream(u_char* buffer);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1069
  // Read (bci, line number) pair from stream. Returns false at end-of-stream.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1070
  bool read_pair();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1071
  // Accessing bci and line number (after calling read_pair)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1072
  int bci() const                               { return _bci; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
  int line() const                              { return _line; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1074
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
38059
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
  1077
#if INCLUDE_JVMTI
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
  1078
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
/// Fast Breakpoints.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1081
// If this structure gets more complicated (because bpts get numerous),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
// move it into its own header.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1084
// There is presently no provision for concurrent access
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1085
// to breakpoint lists, which is only OK for JVMTI because
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1086
// breakpoints are written only at safepoints, and are read
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1087
// concurrently only outside of safepoints.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12960
diff changeset
  1089
class BreakpointInfo : public CHeapObj<mtClass> {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
  friend class VMStructs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
  Bytecodes::Code  _orig_bytecode;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
  int              _bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
  u2               _name_index;       // of method
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
  u2               _signature_index;  // of method
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
  BreakpointInfo*  _next;             // simple storage allocation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1097
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1098
 public:
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1099
  BreakpointInfo(Method* m, int bci);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1100
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1101
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1102
  Bytecodes::Code orig_bytecode()                     { return _orig_bytecode; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1103
  void        set_orig_bytecode(Bytecodes::Code code) { _orig_bytecode = code; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1104
  int         bci()                                   { return _bci; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1105
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1106
  BreakpointInfo*          next() const               { return _next; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
  void                 set_next(BreakpointInfo* n)    { _next = n; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1108
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1109
  // helps for searchers
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1110
  bool match(const Method* m, int bci) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1111
    return bci == _bci && match(m);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1112
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1113
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1114
  bool match(const Method* m) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1115
    return _name_index == m->name_index() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1116
      _signature_index == m->signature_index();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1117
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1118
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1119
  void set(Method* method);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1120
  void clear(Method* method);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1121
};
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6974
diff changeset
  1122
38059
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
  1123
#endif // INCLUDE_JVMTI
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 37449
diff changeset
  1124
13282
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1125
// Utility class for access exception handlers
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1126
class ExceptionTable : public StackObj {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1127
 private:
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1128
  ExceptionTableElement* _table;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1129
  u2  _length;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1130
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1131
 public:
17370
59a0620561fa 8003557: NPG: Klass* const k should be const Klass* k.
minqi
parents: 17002
diff changeset
  1132
  ExceptionTable(const Method* m) {
13282
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1133
    if (m->has_exception_handler()) {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1134
      _table = m->exception_table_start();
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1135
      _length = m->exception_table_length();
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1136
    } else {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1137
      _table = NULL;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1138
      _length = 0;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1139
    }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1140
  }
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
  int length() const {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1143
    return _length;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1144
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1145
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1146
  u2 start_pc(int idx) const {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1147
    assert(idx < _length, "out of bounds");
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1148
    return _table[idx].start_pc;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1149
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1150
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1151
  void set_start_pc(int idx, u2 value) {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1152
    assert(idx < _length, "out of bounds");
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1153
    _table[idx].start_pc = value;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1154
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1155
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1156
  u2 end_pc(int idx) const {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1157
    assert(idx < _length, "out of bounds");
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1158
    return _table[idx].end_pc;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1159
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1160
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1161
  void set_end_pc(int idx, u2 value) {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1162
    assert(idx < _length, "out of bounds");
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1163
    _table[idx].end_pc = value;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1164
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1165
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1166
  u2 handler_pc(int idx) const {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1167
    assert(idx < _length, "out of bounds");
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1168
    return _table[idx].handler_pc;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1169
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1170
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1171
  void set_handler_pc(int idx, u2 value) {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1172
    assert(idx < _length, "out of bounds");
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1173
    _table[idx].handler_pc = value;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1174
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1175
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1176
  u2 catch_type_index(int idx) const {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1177
    assert(idx < _length, "out of bounds");
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1178
    return _table[idx].catch_type_index;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1179
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1180
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1181
  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
  1182
    assert(idx < _length, "out of bounds");
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1183
    _table[idx].catch_type_index = value;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1184
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1185
};
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
  1186
53244
9807daeb47c4 8216167: Update include guards to reflect correct directories
coleenp
parents: 53149
diff changeset
  1187
#endif // SHARE_OOPS_METHOD_HPP