hotspot/src/share/vm/oops/method.hpp
author jiangli
Tue, 08 Jan 2013 13:01:19 -0500
changeset 15109 088b1ea04490
parent 14745 03904dd8649b
child 15110 b09370d81054
permissions -rw-r--r--
8001341: SIGSEGV in methodOopDesc::fast_exception_handler_bci_for(KlassHandle,int,Thread*)+0x3e9. Summary: Use methodHandle. Reviewed-by: coleenp, acorn, twisti, sspitsyn
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
11637
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11480
diff changeset
     2
 * Copyright (c) 1997, 2012, 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
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6974
diff changeset
    25
#ifndef SHARE_VM_OOPS_METHODOOP_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6974
diff changeset
    26
#define SHARE_VM_OOPS_METHODOOP_HPP
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"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6974
diff changeset
    30
#include "compiler/oopMap.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6974
diff changeset
    31
#include "interpreter/invocationCounter.hpp"
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
    32
#include "oops/annotations.hpp"
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
    33
#include "oops/constantPool.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6974
diff changeset
    34
#include "oops/instanceKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6974
diff changeset
    35
#include "oops/oop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6974
diff changeset
    36
#include "oops/typeArrayOop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6974
diff changeset
    37
#include "utilities/accessFlags.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6974
diff changeset
    38
#include "utilities/growableArray.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6974
diff changeset
    39
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
    40
// A Method* represents a Java method.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
// Memory layout (each line represents a word). Note that most applications load thousands of methods,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
// so keeping the size of this structure small has a big impact on footprint.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
// We put all oops and method_size first for better gc cache locality.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
//
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
    47
// The actual bytecodes are inlined after the end of the Method struct.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
// There are bits in the access_flags telling whether inlined tables are present.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
// Note that accessing the line number and local variable tables is not performance critical at all.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
// Accessing the checked exceptions table is used by reflection, so we put that last to make access
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
// to it fast.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
// The line number table is compressed and inlined following the byte codes. It is found as the first
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
// byte following the byte codes. The checked exceptions table and the local variable table are inlined
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
// after the line number table, and indexed from the end of the method. We do not compress the checked
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
// exceptions table since the average length is less than 2, and do not bother to compress the local
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
// variable table either since it is mostly absent.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
// Note that native_function and signature_handler has to be at fixed offsets (required by the interpreter)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
// |------------------------------------------------------|
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
// | header                                               |
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
// | klass                                                |
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
// |------------------------------------------------------|
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
    66
// | ConstMethod*                   (oop)                 |
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
// |------------------------------------------------------|
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
// | methodData                     (oop)                 |
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
// | interp_invocation_count                              |
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
// |------------------------------------------------------|
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
// | access_flags                                         |
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
// | vtable_index                                         |
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
// |------------------------------------------------------|
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
// | result_index (C++ interpreter only)                  |
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
// |------------------------------------------------------|
14745
03904dd8649b 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing.
jiangli
parents: 14587
diff changeset
    76
// | method_size             |   intrinsic_id|   flags    |
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
// |------------------------------------------------------|
14586
1262473e8fc1 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents: 14391
diff changeset
    78
// | throwout_count          |   num_breakpoints          |
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
// |------------------------------------------------------|
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
// | invocation_counter                                   |
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
// | backedge_counter                                     |
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
// |------------------------------------------------------|
8667
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
    83
// |           prev_time (tiered only, 64 bit wide)       |
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
    84
// |                                                      |
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
    85
// |------------------------------------------------------|
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
    86
// |                  rate (tiered)                       |
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
    87
// |------------------------------------------------------|
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
// | code                           (pointer)             |
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
// | i2i                            (pointer)             |
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
// | adapter                        (pointer)             |
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
// | from_compiled_entry            (pointer)             |
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
// | from_interpreted_entry         (pointer)             |
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
// |------------------------------------------------------|
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
// | native_function       (present only if native)       |
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
// | signature_handler     (present only if native)       |
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
// |------------------------------------------------------|
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
class CheckedExceptionElement;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
class LocalVariableTableElement;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
class AdapterHandlerEntry;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   102
class MethodData;
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   103
class ConstMethod;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   105
class Method : public Metadata {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
 friend class VMStructs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
 private:
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   108
  ConstMethod*      _constMethod;                // Method read-only data.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   109
  MethodData*       _method_data;
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   110
  int               _interpreter_invocation_count; // Count of times invoked (reused as prev_event_count in tiered)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
  AccessFlags       _access_flags;               // Access flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
  int               _vtable_index;               // vtable index of this method (see VtableIndexFlag)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
                                                 // note: can have vtables with >2**16 elements (because of inheritance)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
#ifdef CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  int               _result_index;               // C++ interpreter needs for converting results to/from stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  u2                _method_size;                // size of this object
3273
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2570
diff changeset
   118
  u1                _intrinsic_id;               // vmSymbols::intrinsic_id (0 == _none)
13291
9de3b1387cb8 6711908: JVM needs direct access to some annotations
jrose
parents: 12960
diff changeset
   119
  u1                _jfr_towrite  : 1,           // Flags
9de3b1387cb8 6711908: JVM needs direct access to some annotations
jrose
parents: 12960
diff changeset
   120
                    _force_inline : 1,
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   121
                    _hidden       : 1,
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   122
                    _dont_inline  : 1,
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   123
                                  : 4;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  u2                _interpreter_throwout_count; // Count of times method was exited via exception while interpreting
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  u2                _number_of_breakpoints;      // fullspeed debugging support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  InvocationCounter _invocation_counter;         // Incremented before each activation of the method - used to trigger frequency-based optimizations
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  InvocationCounter _backedge_counter;           // Incremented before each backedge taken - used to trigger frequencey-based optimizations
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   128
8667
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
   129
#ifdef TIERED
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
   130
  jlong             _prev_time;                   // Previous time the rate was acquired
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
   131
  float             _rate;                        // Events (invocation and backedge counter increments) per millisecond
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
   132
#endif
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
   133
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  int               _compiled_invocation_count;  // Number of nmethod invocations so far (for perf. debugging)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  // Entry point for calling both from and to the interpreter.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  address _i2i_entry;           // All-args-on-stack calling convention
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   139
  // Adapter blob (i2c/c2i) for this Method*. Set once when method is linked.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  AdapterHandlerEntry* _adapter;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  // Entry point for calling from compiled code, to compiled code if it exists
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  // or else the interpreter.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  volatile address _from_compiled_entry;        // Cache of: _code ? _code->entry_point() : _adapter->c2i_entry()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  // The entry point for calling both from and to compiled code is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  // "_code->entry_point()".  Because of tiered compilation and de-opt, this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  // field can come and go.  It can transition from NULL to not-null at any
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  // time (whenever a compile completes).  It can transition from not-null to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  // NULL only at safepoints (because of a de-opt).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  nmethod* volatile _code;                       // Points to the corresponding piece of native code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  volatile address           _from_interpreted_entry; // Cache of _code ? _adapter->i2c_entry() : _i2i_entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   152
  // Constructor
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   153
  Method(ConstMethod* xconst, AccessFlags access_flags, int size);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
 public:
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   155
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   156
  static Method* allocate(ClassLoaderData* loader_data,
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   157
                          int byte_code_size,
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   158
                          AccessFlags access_flags,
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   159
                          int compressed_line_number_size,
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   160
                          int localvariable_table_length,
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   161
                          int exception_table_length,
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   162
                          int checked_exceptions_length,
14586
1262473e8fc1 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents: 14391
diff changeset
   163
                          u2 generic_signature_index,
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   164
                          ConstMethod::MethodType method_type,
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   165
                          TRAPS);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   166
14579
7f6ce6e3dd80 8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents: 14391
diff changeset
   167
  // 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
   168
  Method(){}
13736
5b15a8f57979 7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type
coleenp
parents: 13728
diff changeset
   169
5b15a8f57979 7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type
coleenp
parents: 13728
diff changeset
   170
  // The Method vtable is restored by this call when the Method is in the
5b15a8f57979 7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type
coleenp
parents: 13728
diff changeset
   171
  // shared archive.  See patch_klass_vtables() in metaspaceShared.cpp for
5b15a8f57979 7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type
coleenp
parents: 13728
diff changeset
   172
  // all the gory details.  SA, dtrace and pstack helpers distinguish metadata
5b15a8f57979 7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type
coleenp
parents: 13728
diff changeset
   173
  // by their vtable.
5b15a8f57979 7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type
coleenp
parents: 13728
diff changeset
   174
  void restore_vtable() { guarantee(is_method(), "vtable restored by this call"); }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   175
  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
   176
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  // 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
   178
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   179
  ConstMethod* constMethod() const             { return _constMethod; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   180
  void set_constMethod(ConstMethod* xconst)    { _constMethod = xconst; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  static address make_adapters(methodHandle mh, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  volatile address from_compiled_entry() const   { return (address)OrderAccess::load_ptr_acquire(&_from_compiled_entry); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  volatile address from_interpreted_entry() const{ return (address)OrderAccess::load_ptr_acquire(&_from_interpreted_entry); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  // access flag
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  AccessFlags access_flags() const               { return _access_flags;  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  void set_access_flags(AccessFlags flags)       { _access_flags = flags; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  // name
12937
0032fb2caff6 7172967: Eliminate constMethod's _method backpointer to methodOop.
jiangli
parents: 11637
diff changeset
   192
  Symbol* name() const                           { return constants()->symbol_at(name_index()); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  int name_index() const                         { return constMethod()->name_index();         }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  void set_name_index(int index)                 { constMethod()->set_name_index(index);       }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
  // signature
12937
0032fb2caff6 7172967: Eliminate constMethod's _method backpointer to methodOop.
jiangli
parents: 11637
diff changeset
   197
  Symbol* signature() const                      { return constants()->symbol_at(signature_index()); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  int signature_index() const                    { return constMethod()->signature_index();         }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  void set_signature_index(int index)            { constMethod()->set_signature_index(index);       }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  // generics support
12937
0032fb2caff6 7172967: Eliminate constMethod's _method backpointer to methodOop.
jiangli
parents: 11637
diff changeset
   202
  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
   203
  int generic_signature_index() const            { return constMethod()->generic_signature_index(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  void set_generic_signature_index(int index)    { constMethod()->set_generic_signature_index(index); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  // annotations support
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   207
  AnnotationArray* annotations() const           {
14391
df0a1573d5bd 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents: 14385
diff changeset
   208
    InstanceKlass* ik = method_holder();
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   209
    if (ik->annotations() == NULL) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   210
      return NULL;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   211
    }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   212
    return ik->annotations()->get_method_annotations_of(method_idnum());
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   213
  }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   214
  AnnotationArray* parameter_annotations() const {
14391
df0a1573d5bd 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents: 14385
diff changeset
   215
    InstanceKlass* ik = method_holder();
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   216
    if (ik->annotations() == NULL) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   217
      return NULL;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   218
    }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   219
    return ik->annotations()->get_method_parameter_annotations_of(method_idnum());
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   220
  }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   221
  AnnotationArray* annotation_default() const    {
14391
df0a1573d5bd 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents: 14385
diff changeset
   222
    InstanceKlass* ik = method_holder();
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   223
    if (ik->annotations() == NULL) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   224
      return NULL;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   225
    }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   226
    return ik->annotations()->get_method_default_annotations_of(method_idnum());
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   227
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
#ifdef CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
  void set_result_index(BasicType type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
  int  result_index()                            { return _result_index; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
  // Helper routine: get klass name + "." + method name + signature as
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  // C string, for the purpose of providing more useful NoSuchMethodErrors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  // and fatal error handling. The string is allocated in resource
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  // 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
   238
  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
   239
  char* name_and_sig_as_C_string(char* buf, int size) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   241
  // 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
   242
  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
   243
  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
   244
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   245
  Bytecodes::Code java_code_at(int bci) const {
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   246
    return Bytecodes::java_code_at(this, bcp_from(bci));
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   247
  }
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   248
  Bytecodes::Code code_at(int bci) const {
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   249
    return Bytecodes::code_at(this, bcp_from(bci));
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   250
  }
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   251
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  // JVMTI breakpoints
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   253
  Bytecodes::Code orig_bytecode_at(int bci) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  void        set_orig_bytecode_at(int bci, Bytecodes::Code code);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  void set_breakpoint(int bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  void clear_breakpoint(int bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
  void clear_all_breakpoints();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
  // Tracking number of breakpoints, for fullspeed debugging.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
  // Only mutated by VM thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  u2   number_of_breakpoints() const             { return _number_of_breakpoints; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  void incr_number_of_breakpoints()              { ++_number_of_breakpoints; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
  void decr_number_of_breakpoints()              { --_number_of_breakpoints; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
  // Initialization only
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
  void clear_number_of_breakpoints()             { _number_of_breakpoints = 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   266
  // index into InstanceKlass methods() array
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 10008
diff changeset
   267
  // note: also used by jfr
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
  u2 method_idnum() const           { return constMethod()->method_idnum(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  void set_method_idnum(u2 idnum)   { constMethod()->set_method_idnum(idnum); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
  // code size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
  int code_size() const                  { return constMethod()->code_size(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  // method size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
  int method_size() const                        { return _method_size; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
  void set_method_size(int size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
    assert(0 <= size && size < (1 << 16), "invalid method size");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
    _method_size = size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   281
  // constant pool for Klass* holding this method
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   282
  ConstantPool* constants() const              { return constMethod()->constants(); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   283
  void set_constants(ConstantPool* c)          { constMethod()->set_constants(c); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
  // max stack
13396
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 13391
diff changeset
   286
  // 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
   287
  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
   288
  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
   289
  void      set_max_stack(int size)              {        constMethod()->set_max_stack(size); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
  // max locals
14745
03904dd8649b 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing.
jiangli
parents: 14587
diff changeset
   292
  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
   293
  void set_max_locals(int size)                  { constMethod()->set_max_locals(size); }
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   294
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   295
  int highest_comp_level() const;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   296
  void set_highest_comp_level(int level);
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   297
  int highest_osr_comp_level() const;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   298
  void set_highest_osr_comp_level(int level);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  // Count of times method was exited via exception while interpreting
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  void interpreter_throwout_increment() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
    if (_interpreter_throwout_count < 65534) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
      _interpreter_throwout_count++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
  int  interpreter_throwout_count() const        { return _interpreter_throwout_count; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
  void set_interpreter_throwout_count(int count) { _interpreter_throwout_count = count; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
  // size of parameters
14745
03904dd8649b 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing.
jiangli
parents: 14587
diff changeset
   311
  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
   312
  void set_size_of_parameters(int size)          { constMethod()->set_size_of_parameters(size); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
  bool has_stackmap_table() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
    return constMethod()->has_stackmap_table();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   318
  Array<u1>* stackmap_data() const {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
    return constMethod()->stackmap_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   322
  void set_stackmap_data(Array<u1>* sd) {
6974
a013f1c533a5 6991315: RedefineClasses fails with java.lang.VerifyError
kamg
parents: 6463
diff changeset
   323
    constMethod()->set_stackmap_data(sd);
a013f1c533a5 6991315: RedefineClasses fails with java.lang.VerifyError
kamg
parents: 6463
diff changeset
   324
  }
a013f1c533a5 6991315: RedefineClasses fails with java.lang.VerifyError
kamg
parents: 6463
diff changeset
   325
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
  // exception handler table
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  bool has_exception_handler() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
                             { return constMethod()->has_exception_handler(); }
13282
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   329
  int exception_table_length() const
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   330
                             { return constMethod()->exception_table_length(); }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   331
  ExceptionTableElement* exception_table_start() const
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   332
                             { return constMethod()->exception_table_start(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
  // Finds the first entry point bci of an exception handler for an
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
  // exception of klass ex_klass thrown at throw_bci. A value of NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
  // for ex_klass indicates that the exception klass is not known; in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  // this case it matches any constraint class. Returns -1 if the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  // exception cannot be handled in this method. The handler
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  // constraint classes are loaded if necessary. Note that this may
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  // throw an exception if loading of the constraint classes causes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
  // an IllegalAccessError (bugid 4307310) or an OutOfMemoryError.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  // If an exception is thrown, returns the bci of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  // exception handler which caused the exception to be thrown, which
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  // is needed for proper retries. See, for example,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  // InterpreterRuntime::exception_handler_for_exception.
15109
088b1ea04490 8001341: SIGSEGV in methodOopDesc::fast_exception_handler_bci_for(KlassHandle,int,Thread*)+0x3e9.
jiangli
parents: 14745
diff changeset
   346
  static int fast_exception_handler_bci_for(methodHandle mh, KlassHandle ex_klass, int throw_bci, TRAPS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
  // method data access
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   349
  MethodData* method_data() const              {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
    return _method_data;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
  }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   352
  void set_method_data(MethodData* data)       {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   353
    _method_data = data;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
  // invocation counter
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   357
  InvocationCounter* invocation_counter() { return &_invocation_counter; }
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   358
  InvocationCounter* backedge_counter()   { return &_backedge_counter; }
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   359
8667
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
   360
#ifdef TIERED
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
   361
  // 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
   362
  // We can do that since interpreter_invocation_count is not used in tiered.
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
   363
  int prev_event_count() const                   { return _interpreter_invocation_count;  }
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
   364
  void set_prev_event_count(int count)           { _interpreter_invocation_count = count; }
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
   365
  jlong prev_time() const                        { return _prev_time; }
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
   366
  void set_prev_time(jlong time)                 { _prev_time = time; }
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
   367
  float rate() const                             { return _rate; }
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
   368
  void set_rate(float rate)                      { _rate = rate; }
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
   369
#endif
b32929355d27 7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents: 8313
diff changeset
   370
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   371
  int invocation_count();
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   372
  int backedge_count();
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   373
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   374
  bool was_executed_more_than(int n);
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   375
  bool was_never_executed()                      { return !was_executed_more_than(0); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
  static void build_interpreter_method_data(methodHandle method, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   379
  int interpreter_invocation_count() {
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   380
    if (TieredCompilation) return invocation_count();
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   381
    else return _interpreter_invocation_count;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   382
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
  void set_interpreter_invocation_count(int count) { _interpreter_invocation_count = count; }
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   384
  int increment_interpreter_invocation_count() {
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   385
    if (TieredCompilation) ShouldNotReachHere();
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   386
    return ++_interpreter_invocation_count;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   387
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
#ifndef PRODUCT
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   390
  int  compiled_invocation_count() const         { return _compiled_invocation_count;  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  void set_compiled_invocation_count(int count)  { _compiled_invocation_count = count; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
#endif // not PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
2131
98f9cef66a34 6810672: Comment typos
twisti
parents: 1894
diff changeset
   394
  // Clear (non-shared space) pointers which could not be relevant
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
  // if this (shared) method were mapped into another JVM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
  void remove_unshareable_info();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  // nmethod/verified compiler entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
  address verified_code_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
  bool check_code() const;      // Not inline to avoid circular ref
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
  nmethod* volatile code() const                 { assert( check_code(), "" ); return (nmethod *)OrderAccess::load_ptr_acquire(&_code); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
  void clear_code();            // Clear out any compiled code
4750
71fd601907dc 4360113: Evict nmethods when code cache gets full
kvn
parents: 4581
diff changeset
   403
  static void set_code(methodHandle mh, nmethod* code);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
  void set_adapter_entry(AdapterHandlerEntry* adapter) {  _adapter = adapter; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
  address get_i2c_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
  address get_c2i_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
  address get_c2i_unverified_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
  AdapterHandlerEntry* adapter() {  return _adapter; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
  // setup entry points
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
  void link_method(methodHandle method, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
  // clear entry points. Used by sharing code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
  void unlink_method();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
  // vtable index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
  enum VtableIndexFlag {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
    // Valid vtable indexes are non-negative (>= 0).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
    // These few negative values are used as sentinels.
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2154
diff changeset
   418
    highest_unused_vtable_index_value = -5,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
    invalid_vtable_index    = -4,  // distinct from any valid vtable index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
    garbage_vtable_index    = -3,  // not yet linked; no vtable layout yet
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
    nonvirtual_vtable_index = -2   // there is no need for vtable dispatch
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
    // 6330203 Note:  Do not use -1, which was overloaded with many meanings.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
  DEBUG_ONLY(bool valid_vtable_index() const     { return _vtable_index >= nonvirtual_vtable_index; })
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
  int  vtable_index() const                      { assert(valid_vtable_index(), "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
                                                   return _vtable_index; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  void set_vtable_index(int index)               { _vtable_index = index; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
  // interpreter entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
  address interpreter_entry() const              { return _i2i_entry; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
  // Only used when first initialize so we can set _i2i_entry and _from_interpreted_entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
  void set_interpreter_entry(address entry)      { _i2i_entry = entry;  _from_interpreted_entry = entry; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
  int  interpreter_kind(void) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
     return constMethod()->interpreter_kind();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
  void set_interpreter_kind();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
  void set_interpreter_kind(int kind) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
    constMethod()->set_interpreter_kind(kind);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
  // native function (used for native methods only)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
  enum {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
    native_bind_event_is_interesting = true
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
  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
   446
  address critical_native_function();
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11480
diff changeset
   447
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
  // Must specify a real function (not NULL).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
  // Use clear_native_function() to unregister.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
  void set_native_function(address function, bool post_event_flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
  bool has_native_function() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
  void clear_native_function();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
  // signature handler (used for native methods only)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
  address signature_handler() const              { return *(signature_handler_addr()); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
  void set_signature_handler(address handler);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
  // Interpreter oopmap support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
  void mask_for(int bci, InterpreterOopMap* mask);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
  // operations on invocation counter
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   463
  void print_invocation_count();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
  // byte codes
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 3824
diff changeset
   467
  void    set_code(address code)      { return constMethod()->set_code(code); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
  address code_base() const           { return constMethod()->code_base(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
  bool    contains(address bcp) const { return constMethod()->contains(bcp); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
  // prints byte codes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
  void print_codes() const            { print_codes_on(tty); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
  void print_codes_on(outputStream* st) const                      PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
  void print_codes_on(int from, int to, outputStream* st) const    PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
  // checked exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
  int checked_exceptions_length() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
                         { return constMethod()->checked_exceptions_length(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
  CheckedExceptionElement* checked_exceptions_start() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
                          { return constMethod()->checked_exceptions_start(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
  // localvariable table
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
  bool has_localvariable_table() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
                          { return constMethod()->has_localvariable_table(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  int localvariable_table_length() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
                        { return constMethod()->localvariable_table_length(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
  LocalVariableTableElement* localvariable_table_start() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
                         { return constMethod()->localvariable_table_start(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
  bool has_linenumber_table() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
                              { return constMethod()->has_linenumber_table(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
  u_char* compressed_linenumber_table() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
                       { return constMethod()->compressed_linenumber_table(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   495
  // 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
   496
  InstanceKlass* method_holder() const         { return constants()->pool_holder(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
  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
   499
  Symbol* klass_name() const;                    // returns the name of the method holder
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
  BasicType result_type() const;                 // type of the method result
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
  int result_type_index() const;                 // type index of the method result
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
  bool is_returning_oop() const                  { BasicType r = result_type(); return (r == T_OBJECT || r == T_ARRAY); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
  bool is_returning_fp() const                   { BasicType r = result_type(); return (r == T_FLOAT || r == T_DOUBLE); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
  // Checked exceptions thrown by this method (resolved to mirrors)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
  objArrayHandle resolved_checked_exceptions(TRAPS) { return resolved_checked_exceptions_impl(this, THREAD); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
  // Access flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
  bool is_public() const                         { return access_flags().is_public();      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
  bool is_private() const                        { return access_flags().is_private();     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  bool is_protected() const                      { return access_flags().is_protected();   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
  bool is_package_private() const                { return !is_public() && !is_private() && !is_protected(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
  bool is_static() const                         { return access_flags().is_static();      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
  bool is_final() const                          { return access_flags().is_final();       }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
  bool is_synchronized() const                   { return access_flags().is_synchronized();}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
  bool is_native() const                         { return access_flags().is_native();      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
  bool is_abstract() const                       { return access_flags().is_abstract();    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
  bool is_strict() const                         { return access_flags().is_strict();      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
  bool is_synthetic() const                      { return access_flags().is_synthetic();   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
  // returns true if contains only return operation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
  bool is_empty_method() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
  // returns true if this is a vanilla constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
  bool is_vanilla_constructor() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
  // checks method and its method holder
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
  bool is_final_method() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
  bool is_strict_method() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
  // true if method needs no dynamic dispatch (final and/or no vtable entry)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
  bool can_be_statically_bound() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
  // returns true if the method has any backward branches.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
  bool has_loops() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
    return access_flags().loops_flag_init() ? access_flags().has_loops() : compute_has_loops_flag();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
  bool compute_has_loops_flag();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
  bool has_jsrs() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
    return access_flags().has_jsrs();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
  void set_has_jsrs() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
    _access_flags.set_has_jsrs();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
  // returns true if the method has any monitors.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
  bool has_monitors() const                      { return is_synchronized() || access_flags().has_monitor_bytecodes(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
  bool has_monitor_bytecodes() const             { return access_flags().has_monitor_bytecodes(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
  void set_has_monitor_bytecodes()               { _access_flags.set_has_monitor_bytecodes(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
  // monitor matching. This returns a conservative estimate of whether the monitorenter/monitorexit bytecodes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
  // 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
   556
  // has not been computed yet.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
  bool guaranteed_monitor_matching() const       { return access_flags().is_monitor_matching(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
  void set_guaranteed_monitor_matching()         { _access_flags.set_monitor_matching(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
  // returns true if the method is an accessor function (setter/getter).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
  bool is_accessor() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
  // returns true if the method is an initializer (<init> or <clinit>).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
  bool is_initializer() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
8653
8797d788a4f1 6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents: 8313
diff changeset
   566
  // 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
   567
  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
   568
8797d788a4f1 6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents: 8313
diff changeset
   569
  // 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
   570
  // 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
   571
  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
   572
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
  // compiled code support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
  // NOTE: code() is inherently racy as deopt can be clearing code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
  // simultaneously. Use with caution.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
  bool has_compiled_code() const                 { return code() != NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
  // sizing
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   579
  static int header_size()                       { return sizeof(Method)/HeapWordSize; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   580
  static int size(bool is_native);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   581
  int size() const                               { return method_size(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
  // interpreter support
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   584
  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
   585
  static ByteSize access_flags_offset()          { return byte_offset_of(Method, _access_flags      ); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
#ifdef CC_INTERP
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   587
  static ByteSize result_index_offset()          { return byte_offset_of(Method, _result_index ); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
#endif /* CC_INTERP */
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   589
  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
   590
  static ByteSize code_offset()                  { return byte_offset_of(Method, _code); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   591
  static ByteSize invocation_counter_offset()    { return byte_offset_of(Method, _invocation_counter); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   592
  static ByteSize backedge_counter_offset()      { return byte_offset_of(Method, _backedge_counter); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
  static ByteSize method_data_offset()           {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   594
    return byte_offset_of(Method, _method_data);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
  }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   596
  static ByteSize interpreter_invocation_counter_offset() { return byte_offset_of(Method, _interpreter_invocation_count); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
#ifndef PRODUCT
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   598
  static ByteSize compiled_invocation_counter_offset() { return byte_offset_of(Method, _compiled_invocation_count); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
#endif // not PRODUCT
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   600
  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
   601
  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
   602
  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
   603
  static ByteSize signature_handler_offset()     { return in_ByteSize(sizeof(Method) + wordSize);      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
  // for code generation
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   606
  static int method_data_offset_in_bytes()       { return offset_of(Method, _method_data); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
  static int interpreter_invocation_counter_offset_in_bytes()
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   608
                                                 { return offset_of(Method, _interpreter_invocation_count); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   609
  static int intrinsic_id_offset_in_bytes()      { return offset_of(Method, _intrinsic_id); }
6463
f4362c8da849 6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents: 6453
diff changeset
   610
  static int intrinsic_id_size_in_bytes()        { return sizeof(u1); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
  // Static methods that are used to implement member methods where an exposed this pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
  // is needed due to possible GCs
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   614
  static objArrayHandle resolved_checked_exceptions_impl(Method* this_oop, TRAPS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
  // Returns the byte code index from the byte code pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
  int     bci_from(address bcp) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
  address bcp_from(int     bci) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
  int validate_bci_from_bcx(intptr_t bcx) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
  // Returns the line number for a bci if debugging information for the method is prowided,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
  // -1 is returned otherwise.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
  int line_number_from_bci(int bci) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
  // Reflection support
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   626
  bool is_overridden_in(Klass* k) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2154
diff changeset
   628
  // JSR 292 support
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   629
  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
   630
  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
   631
  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
   632
  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
   633
                                                   Symbol* signature, //anything at all
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   634
                                                   TRAPS);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   635
  static Klass* check_non_bcp_klass(Klass* klass);
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2154
diff changeset
   636
  // these operate only on invoke methods:
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2154
diff changeset
   637
  // presize interpreter frames for extra interpreter stack entries, if needed
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
   638
  // method handles want to be able to push a few extra values (e.g., a bound receiver), and
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
   639
  // invokedynamic sometimes needs to push a bootstrap method, call site, and arglist,
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
   640
  // all without checking for a stack overflow
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   641
  static int extra_stack_entries() { return EnableInvokeDynamic ? 2 : 0; }
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2154
diff changeset
   642
  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
   643
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
  // RedefineClasses() support:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
  bool is_old() const                               { return access_flags().is_old(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
  void set_is_old()                                 { _access_flags.set_is_old(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
  bool is_obsolete() const                          { return access_flags().is_obsolete(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
  void set_is_obsolete()                            { _access_flags.set_is_obsolete(); }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   649
  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
   650
  void set_on_stack(const bool value);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   651
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   652
  // 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
   653
  bool should_not_be_cached() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
  // JVMTI Native method prefixing support:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
  bool is_prefixed_native() const                   { return access_flags().is_prefixed_native(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
  void set_is_prefixed_native()                     { _access_flags.set_is_prefixed_native(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
  // Rewriting support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
  static methodHandle clone_with_new_data(methodHandle m, u_char* new_code, int new_code_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
                                          u_char* new_compressed_linenumber_table, int new_compressed_linenumber_size, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   663
  // jmethodID handling
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   664
  // 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
   665
  // 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
   666
  // 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
   667
  // 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
   668
  // 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
   669
  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
   670
  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
   671
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   672
  // 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
   673
  // 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
   674
  // result guaranteed not to be NULL.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   675
  inline static Method* resolve_jmethod_id(jmethodID mid) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   676
    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
   677
    return *((Method**)mid);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   678
  }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   679
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   680
  // 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
   681
  // 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
   682
  // 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
   683
  static Method* checked_resolve_jmethod_id(jmethodID mid);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   684
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   685
  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
   686
  static bool is_method_id(jmethodID mid);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   687
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   688
  // Clear methods
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   689
  static void clear_jmethod_ids(ClassLoaderData* loader_data);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   690
  static void print_jmethod_ids(ClassLoaderData* loader_data, outputStream* out) PRODUCT_RETURN;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   691
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
  // Get this method's jmethodID -- allocate if it doesn't exist
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
  jmethodID jmethod_id()                            { methodHandle this_h(this);
14391
df0a1573d5bd 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents: 14385
diff changeset
   694
                                                      return InstanceKlass::get_jmethod_id(method_holder(), this_h); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
  // Lookup the jmethodID for this method.  Return NULL if not found.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
  // NOTE that this function can be called from a signal handler
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
  // (see AsyncGetCallTrace support for Forte Analyzer) and this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
  // needs to be async-safe. No allocation should be done and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
  // 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
   701
  jmethodID find_jmethod_id_or_null()               { return method_holder()->jmethod_id_or_null(this); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
  // JNI static invoke cached itable index accessors
14391
df0a1573d5bd 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents: 14385
diff changeset
   704
  int cached_itable_index()                         { return method_holder()->cached_itable_index(method_idnum()); }
df0a1573d5bd 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents: 14385
diff changeset
   705
  void set_cached_itable_index(int index)           { method_holder()->set_cached_itable_index(method_idnum(), index); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
  // Support for inlining of intrinsic methods
3273
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2570
diff changeset
   708
  vmIntrinsics::ID intrinsic_id() const          { return (vmIntrinsics::ID) _intrinsic_id;           }
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2570
diff changeset
   709
  void     set_intrinsic_id(vmIntrinsics::ID id) {                           _intrinsic_id = (u1) id; }
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2570
diff changeset
   710
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2570
diff changeset
   711
  // 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
   712
  void init_intrinsic_id();     // updates from _none if a match
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   713
  static vmSymbols::SID klass_id_for_intrinsics(Klass* holder);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 10008
diff changeset
   715
  bool jfr_towrite()                 { return _jfr_towrite; }
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 10008
diff changeset
   716
  void set_jfr_towrite(bool towrite) { _jfr_towrite = towrite; }
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 10008
diff changeset
   717
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   718
  bool     force_inline()       { return _force_inline;     }
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   719
  void set_force_inline(bool x) {        _force_inline = x; }
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   720
  bool     dont_inline()        { return _dont_inline;      }
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   721
  void set_dont_inline(bool x)  {        _dont_inline = x;  }
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   722
  bool  is_hidden()             { return _hidden;           }
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   723
  void set_hidden(bool x)       {        _hidden = x;       }
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   724
  ConstMethod::MethodType method_type() const {
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   725
      return _constMethod->method_type();
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   726
  }
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13891
diff changeset
   727
  bool is_overpass() const { return method_type() == ConstMethod::OVERPASS; }
13291
9de3b1387cb8 6711908: JVM needs direct access to some annotations
jrose
parents: 12960
diff changeset
   728
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
  // On-stack replacement support
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   730
  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
   731
   return method_holder()->lookup_osr_nmethod(this, InvocationEntryBci, level, match_level) != NULL;
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   732
  }
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   733
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   734
  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
   735
    return method_holder()->lookup_osr_nmethod(this, bci, level, match_level);
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   736
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
  // Inline cache support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
  void cleanup_inline_caches();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
  // Find if klass for method is loaded
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
  bool is_klass_loaded_by_klass_index(int klass_index) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
  bool is_klass_loaded(int refinfo_index, bool must_be_resolved = false) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
  // Indicates whether compilation failed earlier for this method, or
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
  // whether it is not compilable for another reason like having a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
  // breakpoint set in it.
13891
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   748
  bool  is_not_compilable(int comp_level = CompLevel_any) const;
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   749
  void set_not_compilable(int comp_level = CompLevel_all, bool report = true);
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   750
  void set_not_compilable_quietly(int comp_level = CompLevel_all) {
4756
da88c27a9241 6923043: failed nightly tests which use -XX:+PrintCompilation -Xcomp -XX:CompileOnly
kvn
parents: 4750
diff changeset
   751
    set_not_compilable(comp_level, false);
da88c27a9241 6923043: failed nightly tests which use -XX:+PrintCompilation -Xcomp -XX:CompileOnly
kvn
parents: 4750
diff changeset
   752
  }
13891
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   753
  bool  is_not_osr_compilable(int comp_level = CompLevel_any) const;
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   754
  void set_not_osr_compilable(int comp_level = CompLevel_all, bool report = true);
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   755
  void set_not_osr_compilable_quietly(int comp_level = CompLevel_all) {
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   756
    set_not_osr_compilable(comp_level, false);
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   757
  }
13891
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   758
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   759
 private:
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   760
  void print_made_not_compilable(int comp_level, bool is_osr, bool report);
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   761
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   762
 public:
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   763
  bool  is_not_c1_compilable() const          { return access_flags().is_not_c1_compilable(); }
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   764
  void set_not_c1_compilable()                {       _access_flags.set_not_c1_compilable();  }
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   765
  bool  is_not_c2_compilable() const          { return access_flags().is_not_c2_compilable(); }
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   766
  void set_not_c2_compilable()                {       _access_flags.set_not_c2_compilable();  }
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   767
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   768
  bool  is_not_c1_osr_compilable() const      { return is_not_c1_compilable(); }  // don't waste an accessFlags bit
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   769
  void set_not_c1_osr_compilable()            {       set_not_c1_compilable(); }  // don't waste an accessFlags bit
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   770
  bool  is_not_c2_osr_compilable() const      { return access_flags().is_not_c2_osr_compilable(); }
35dabd293e56 7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents: 13736
diff changeset
   771
  void set_not_c2_osr_compilable()            {       _access_flags.set_not_c2_osr_compilable();  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
  // Background compilation support
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   774
  bool queued_for_compilation() const  { return access_flags().queued_for_compilation(); }
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   775
  void set_queued_for_compilation()    { _access_flags.set_queued_for_compilation();     }
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   776
  void clear_queued_for_compilation()  { _access_flags.clear_queued_for_compilation();   }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
  // Resolve all classes in signature, return 'true' if successful
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
  static bool load_signature_classes(methodHandle m, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
  // Return if true if not all classes references in signature, including return type, has been loaded
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
  static bool has_unloaded_classes_in_signature(methodHandle m, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
  // Printing
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   785
  void print_short_name(outputStream* st = tty)  /*PRODUCT_RETURN*/; // prints as klassname::methodname; Exposed so field engineers can debug VM
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   786
  void print_name(outputStream* st = tty)        PRODUCT_RETURN; // prints as "virtual void foo(int)"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
  // Helper routine used for method sorting
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   789
  static void sort_methods(Array<Method*>* methods,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   790
                           Array<AnnotationArray*>* methods_annotations,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   791
                           Array<AnnotationArray*>* methods_parameter_annotations,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   792
                           Array<AnnotationArray*>* methods_default_annotations,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
                           bool idempotent = false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   795
  // 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
   796
  void deallocate_contents(ClassLoaderData* loader_data);
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
  // Printing
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   799
#ifndef PRODUCT
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   800
  void print_on(outputStream* st) const;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   801
#endif
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   802
  void print_value_on(outputStream* st) const;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   803
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   804
  const char* internal_name() const { return "{method}"; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   805
14579
7f6ce6e3dd80 8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents: 14391
diff changeset
   806
  // Check for valid method pointer
7f6ce6e3dd80 8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents: 14391
diff changeset
   807
  bool is_valid_method() const;
7f6ce6e3dd80 8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents: 14391
diff changeset
   808
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   809
  // Verify
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   810
  void verify() { verify_on(tty); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   811
  void verify_on(outputStream* st);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   812
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
  // Inlined elements
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
  address* native_function_addr() const          { assert(is_native(), "must be native"); return (address*) (this+1); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
  address* signature_handler_addr() const        { return native_function_addr() + 1; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
// Utility class for compressing line number tables
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
class CompressedLineNumberWriteStream: public CompressedWriteStream {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
  int _bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
  int _line;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
  // Constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
  CompressedLineNumberWriteStream(int initial_size) : CompressedWriteStream(initial_size), _bci(0), _line(0) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
  CompressedLineNumberWriteStream(u_char* buffer, int initial_size) : CompressedWriteStream(buffer, initial_size), _bci(0), _line(0) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
  // Write (bci, line number) pair to stream
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
  void write_pair_regular(int bci_delta, int line_delta);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
  inline void write_pair_inline(int bci, int line) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
    int bci_delta = bci - _bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
    int line_delta = line - _line;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
    _bci = bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
    _line = line;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
    // Skip (0,0) deltas - they do not add information and conflict with terminator.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
    if (bci_delta == 0 && line_delta == 0) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
    // Check if bci is 5-bit and line number 3-bit unsigned.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
    if (((bci_delta & ~0x1F) == 0) && ((line_delta & ~0x7) == 0)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
      // Compress into single byte.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
      jubyte value = ((jubyte) bci_delta << 3) | (jubyte) line_delta;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
      // Check that value doesn't match escape character.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
      if (value != 0xFF) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
        write_byte(value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
        return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
    write_pair_regular(bci_delta, line_delta);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
// Windows AMD64 + Apr 2005 PSDK with /O2 generates bad code for write_pair.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
// Disabling optimization doesn't work for methods in header files
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
// so we force it to call through the non-optimized version in the .cpp.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
// It's gross, but it's the only way we can ensure that all callers are
8303
81a0b8663748 7017824: Add support for creating 64-bit Visual Studio projects
sla
parents: 8076
diff changeset
   859
// fixed.  _MSC_VER is defined by the windows compiler
81a0b8663748 7017824: Add support for creating 64-bit Visual Studio projects
sla
parents: 8076
diff changeset
   860
#if defined(_M_AMD64) && _MSC_VER >= 1400
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
  void write_pair(int bci, int line);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
  void write_pair(int bci, int line) { write_pair_inline(bci, line); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
  // Write end-of-stream marker
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
  void write_terminator()                        { write_byte(0); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
// Utility class for decompressing line number tables
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
class CompressedLineNumberReadStream: public CompressedReadStream {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
  int _bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
  int _line;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
  // Constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
  CompressedLineNumberReadStream(u_char* buffer);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
  // Read (bci, line number) pair from stream. Returns false at end-of-stream.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
  bool read_pair();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
  // Accessing bci and line number (after calling read_pair)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
  int bci() const                               { return _bci; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
  int line() const                              { return _line; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
/// Fast Breakpoints.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
// If this structure gets more complicated (because bpts get numerous),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
// move it into its own header.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
// There is presently no provision for concurrent access
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
// to breakpoint lists, which is only OK for JVMTI because
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
// breakpoints are written only at safepoints, and are read
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
// concurrently only outside of safepoints.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12960
diff changeset
   898
class BreakpointInfo : public CHeapObj<mtClass> {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
  friend class VMStructs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
  Bytecodes::Code  _orig_bytecode;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
  int              _bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
  u2               _name_index;       // of method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
  u2               _signature_index;  // of method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
  BreakpointInfo*  _next;             // simple storage allocation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
 public:
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   908
  BreakpointInfo(Method* m, int bci);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
  Bytecodes::Code orig_bytecode()                     { return _orig_bytecode; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
  void        set_orig_bytecode(Bytecodes::Code code) { _orig_bytecode = code; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
  int         bci()                                   { return _bci; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
  BreakpointInfo*          next() const               { return _next; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
  void                 set_next(BreakpointInfo* n)    { _next = n; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
  // helps for searchers
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   919
  bool match(const Method* m, int bci) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
    return bci == _bci && match(m);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   923
  bool match(const Method* m) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
    return _name_index == m->name_index() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
      _signature_index == m->signature_index();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   928
  void set(Method* method);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   929
  void clear(Method* method);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
};
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6974
diff changeset
   931
13282
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   932
// Utility class for access exception handlers
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   933
class ExceptionTable : public StackObj {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   934
 private:
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   935
  ExceptionTableElement* _table;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   936
  u2  _length;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   937
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   938
 public:
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   939
  ExceptionTable(Method* m) {
13282
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   940
    if (m->has_exception_handler()) {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   941
      _table = m->exception_table_start();
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   942
      _length = m->exception_table_length();
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   943
    } else {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   944
      _table = NULL;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   945
      _length = 0;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   946
    }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   947
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   948
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   949
  int length() const {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   950
    return _length;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   951
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   952
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   953
  u2 start_pc(int idx) const {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   954
    assert(idx < _length, "out of bounds");
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   955
    return _table[idx].start_pc;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   956
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   957
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   958
  void set_start_pc(int idx, u2 value) {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   959
    assert(idx < _length, "out of bounds");
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   960
    _table[idx].start_pc = value;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   961
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   962
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   963
  u2 end_pc(int idx) const {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   964
    assert(idx < _length, "out of bounds");
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   965
    return _table[idx].end_pc;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   966
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   967
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   968
  void set_end_pc(int idx, u2 value) {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   969
    assert(idx < _length, "out of bounds");
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   970
    _table[idx].end_pc = value;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   971
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   972
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   973
  u2 handler_pc(int idx) const {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   974
    assert(idx < _length, "out of bounds");
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   975
    return _table[idx].handler_pc;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   976
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   977
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   978
  void set_handler_pc(int idx, u2 value) {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   979
    assert(idx < _length, "out of bounds");
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   980
    _table[idx].handler_pc = value;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   981
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   982
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   983
  u2 catch_type_index(int idx) const {
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   984
    assert(idx < _length, "out of bounds");
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   985
    return _table[idx].catch_type_index;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   986
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   987
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   988
  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
   989
    assert(idx < _length, "out of bounds");
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   990
    _table[idx].catch_type_index = value;
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   991
  }
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   992
};
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 12960
diff changeset
   993
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6974
diff changeset
   994
#endif // SHARE_VM_OOPS_METHODOOP_HPP