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