hotspot/src/share/vm/runtime/frame.hpp
author vlivanov
Tue, 04 Mar 2014 02:23:16 -0800
changeset 23193 32ed95bda2f0
parent 22929 cb114f3238ef
child 25714 87fa6860b5ae
child 25715 d5a8dbdc5150
permissions -rw-r--r--
8025842: Convert warning("Thread holding lock at safepoint that vm can block on") to fatal(...) Reviewed-by: iveresov, roland, coleenp
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17872
diff changeset
     2
 * Copyright (c) 1997, 2013, 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: 5419
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5419
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: 5419
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: 6269
diff changeset
    25
#ifndef SHARE_VM_RUNTIME_FRAME_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
    26
#define SHARE_VM_RUNTIME_FRAME_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
    27
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    28
#include "oops/method.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
    29
#include "runtime/basicLock.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
    30
#include "runtime/monitorChunk.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
    31
#include "runtime/registerMap.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
    32
#include "utilities/top.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
    33
#ifdef COMPILER2
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
    34
#ifdef TARGET_ARCH_MODEL_x86_32
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
    35
# include "adfiles/adGlobals_x86_32.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
    36
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
    37
#ifdef TARGET_ARCH_MODEL_x86_64
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
    38
# include "adfiles/adGlobals_x86_64.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
    39
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
    40
#ifdef TARGET_ARCH_MODEL_sparc
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
    41
# include "adfiles/adGlobals_sparc.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
    42
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
    43
#ifdef TARGET_ARCH_MODEL_zero
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
    44
# include "adfiles/adGlobals_zero.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
    45
#endif
8107
78e5bd944384 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 8076
diff changeset
    46
#ifdef TARGET_ARCH_MODEL_arm
78e5bd944384 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 8076
diff changeset
    47
# include "adfiles/adGlobals_arm.hpp"
78e5bd944384 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 8076
diff changeset
    48
#endif
22807
1cf02ef734e2 8016586: PPC64 (part 3): basic changes for PPC64
goetz
parents: 22806
diff changeset
    49
#ifdef TARGET_ARCH_MODEL_ppc_32
1cf02ef734e2 8016586: PPC64 (part 3): basic changes for PPC64
goetz
parents: 22806
diff changeset
    50
# include "adfiles/adGlobals_ppc_32.hpp"
8107
78e5bd944384 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 8076
diff changeset
    51
#endif
22807
1cf02ef734e2 8016586: PPC64 (part 3): basic changes for PPC64
goetz
parents: 22806
diff changeset
    52
#ifdef TARGET_ARCH_MODEL_ppc_64
1cf02ef734e2 8016586: PPC64 (part 3): basic changes for PPC64
goetz
parents: 22806
diff changeset
    53
# include "adfiles/adGlobals_ppc_64.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
    54
#endif
22807
1cf02ef734e2 8016586: PPC64 (part 3): basic changes for PPC64
goetz
parents: 22806
diff changeset
    55
#endif // COMPILER2
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
    56
#ifdef ZERO
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
    57
#ifdef TARGET_ARCH_zero
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
    58
# include "stack_zero.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
    59
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
    60
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
    61
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
typedef class BytecodeInterpreter* interpreterState;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
class CodeBlob;
9437
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
    65
class FrameValues;
6176
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5547
diff changeset
    66
class vframeArray;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
// A frame represents a physical stack frame (an activation).  Frames
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
// can be C or Java frames, and the Java frames can be interpreted or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
// compiled.  In contrast, vframes represent source-level activations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
// so that one physical frame can correspond to multiple source level
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
// frames because of inlining.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
class frame VALUE_OBJ_CLASS_SPEC {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  // Instance variables:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
  intptr_t* _sp; // stack pointer (from Thread::last_Java_sp)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  address   _pc; // program counter (the next instruction after the call)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  CodeBlob* _cb; // CodeBlob that "owns" pc
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  enum deopt_state {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
    not_deoptimized,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
    is_deoptimized,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
    unknown
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  deopt_state _deopt_state;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  // Constructors
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  frame();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  // Accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  // pc: Returns the pc at which this frame will continue normally.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  // It must point at the beginning of the next instruction to execute.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  address pc() const             { return _pc; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  // This returns the pc that if you were in the debugger you'd see. Not
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  // the idealized value in the frame object. This undoes the magic conversion
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  // that happens for deoptimized frames. In addition it makes the value the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  // hardware would want to see in the native frame. The only user (at this point)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  // is deoptimization. It likely no one else should ever use it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  address raw_pc() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  void set_pc( address   newpc );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  intptr_t* sp() const           { return _sp; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  void set_sp( intptr_t* newsp ) { _sp = newsp; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  CodeBlob* cb() const           { return _cb; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  // patching operations
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
  void   patch_pc(Thread* thread, address pc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
  // Every frame needs to return a unique id which distinguishes it from all other frames.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  // For sparc and ia32 use sp. ia64 can have memory frames that are empty so multiple frames
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  // will have identical sp values. For ia64 the bsp (fp) value will serve. No real frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  // should have an id() of NULL so it is a distinguishing value for an unmatchable frame.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  // We also have relationals which allow comparing a frame to anoth frame's id() allow
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  // us to distinguish younger (more recent activation) from older (less recent activations)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  // A NULL id is only valid when comparing for equality.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  intptr_t* id(void) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  bool is_younger(intptr_t* id) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  bool is_older(intptr_t* id) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  // testers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  // Compares for strict equality. Rarely used or needed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  // It can return a different result than f1.id() == f2.id()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  bool equal(frame other) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  // type testers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  bool is_interpreted_frame()    const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  bool is_java_frame()           const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
  bool is_entry_frame()          const;             // Java frame called from C?
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17872
diff changeset
   140
  bool is_stub_frame()           const;
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 11571
diff changeset
   141
  bool is_ignored_frame()        const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  bool is_native_frame()         const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  bool is_runtime_frame()        const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  bool is_compiled_frame()       const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  bool is_safepoint_blob_frame() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  bool is_deoptimized_frame()    const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  // testers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  bool is_first_frame() const; // oldest frame? (has no sender)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  bool is_first_java_frame() const;              // same for Java frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
354
3b42d6fdcb82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 1
diff changeset
   152
  bool is_interpreted_frame_valid(JavaThread* thread) const;       // performs sanity checks on interpreted frames.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  // tells whether this frame is marked for deoptimization
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  bool should_be_deoptimized() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  // tells whether this frame can be deoptimized
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  bool can_be_deoptimized() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  // returns the frame size in stack slots
2880
c2974244a496 6848466: frame::frame_size() assertion failure with -XX:+DebugDeoptimization
cfang
parents: 670
diff changeset
   161
  int frame_size(RegisterMap* map) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  // returns the sending frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  frame sender(RegisterMap* map) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  // for Profiling - acting on another frame. walks sender frames
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  // if valid.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  frame profile_find_Java_sender_frame(JavaThread *thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  bool safe_for_sender(JavaThread *thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  // returns the sender, but skips conversion frames
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  frame real_sender(RegisterMap* map) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  // returns the the sending Java frame, skipping any intermediate C frames
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  // NB: receiver must not be first frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  frame java_sender() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  // Helper methods for better factored code in frame::sender
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  frame sender_for_compiled_frame(RegisterMap* map) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  frame sender_for_entry_frame(RegisterMap* map) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  frame sender_for_interpreter_frame(RegisterMap* map) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  frame sender_for_native_frame(RegisterMap* map) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  // All frames:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  // A low-level interface for vframes:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  intptr_t* addr_at(int index) const             { return &fp()[index];    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  intptr_t  at(int index) const                  { return *addr_at(index); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  // accessors for locals
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  oop obj_at(int offset) const                   { return *obj_at_addr(offset);  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
  void obj_at_put(int offset, oop value)         { *obj_at_addr(offset) = value; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  jint int_at(int offset) const                  { return *int_at_addr(offset);  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  void int_at_put(int offset, jint value)        { *int_at_addr(offset) = value; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  oop*      obj_at_addr(int offset) const        { return (oop*)     addr_at(offset); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   203
  oop*      adjusted_obj_at_addr(Method* method, int index) { return obj_at_addr(adjust_offset(method, index)); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  jint*    int_at_addr(int offset) const         { return (jint*)    addr_at(offset); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
  // Link (i.e., the pointer to the previous frame)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
  intptr_t* link() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
  void set_link(intptr_t* addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
  // Return address
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
  address  sender_pc() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  // Support for deoptimization
6269
10e06287c0b0 6975006: assert(check.is_deoptimized_frame()) failed: missed deopt
never
parents: 6176
diff changeset
   217
  void deoptimize(JavaThread* thread);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
  // The frame's original SP, before any extension by an interpreted callee;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
  // used for packing debug info into vframeArray objects and vframeArray lookup.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
  intptr_t* unextended_sp() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  // returns the stack pointer of the calling frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
  intptr_t* sender_sp() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
11486
cdc636532368 7120448: Fix FP values for compiled frames in frame::describe
bdelsart
parents: 10966
diff changeset
   226
  // Returns the real 'frame pointer' for the current frame.
cdc636532368 7120448: Fix FP values for compiled frames in frame::describe
bdelsart
parents: 10966
diff changeset
   227
  // This is the value expected by the platform ABI when it defines a
cdc636532368 7120448: Fix FP values for compiled frames in frame::describe
bdelsart
parents: 10966
diff changeset
   228
  // frame pointer register. It may differ from the effective value of
cdc636532368 7120448: Fix FP values for compiled frames in frame::describe
bdelsart
parents: 10966
diff changeset
   229
  // the FP register when that register is used in the JVM for other
cdc636532368 7120448: Fix FP values for compiled frames in frame::describe
bdelsart
parents: 10966
diff changeset
   230
  // purposes (like compiled frames on some platforms).
cdc636532368 7120448: Fix FP values for compiled frames in frame::describe
bdelsart
parents: 10966
diff changeset
   231
  // On other platforms, it is defined so that the stack area used by
cdc636532368 7120448: Fix FP values for compiled frames in frame::describe
bdelsart
parents: 10966
diff changeset
   232
  // this frame goes from real_fp() to sp().
cdc636532368 7120448: Fix FP values for compiled frames in frame::describe
bdelsart
parents: 10966
diff changeset
   233
  intptr_t* real_fp() const;
cdc636532368 7120448: Fix FP values for compiled frames in frame::describe
bdelsart
parents: 10966
diff changeset
   234
10539
f87cedf7983c 7087445: Improve platform independence of JSR292 shared code
bdelsart
parents: 9632
diff changeset
   235
  // Deoptimization info, if needed (platform dependent).
f87cedf7983c 7087445: Improve platform independence of JSR292 shared code
bdelsart
parents: 9632
diff changeset
   236
  // Stored in the initial_info field of the unroll info, to be used by
f87cedf7983c 7087445: Improve platform independence of JSR292 shared code
bdelsart
parents: 9632
diff changeset
   237
  // the platform dependent deoptimization blobs.
f87cedf7983c 7087445: Improve platform independence of JSR292 shared code
bdelsart
parents: 9632
diff changeset
   238
  intptr_t *initial_deoptimization_info();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
  // Interpreter frames:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
  intptr_t** interpreter_frame_locals_addr() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
  intptr_t*  interpreter_frame_bcx_addr() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  intptr_t*  interpreter_frame_mdx_addr() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
  // Locals
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
  // The _at version returns a pointer because the address is used for GC.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
  intptr_t* interpreter_frame_local_at(int index) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
  void interpreter_frame_set_locals(intptr_t* locs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  // byte code index/pointer (use these functions for unchecked frame access only!)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  intptr_t interpreter_frame_bcx() const                  { return *interpreter_frame_bcx_addr(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
  void interpreter_frame_set_bcx(intptr_t bcx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
  // byte code index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  jint interpreter_frame_bci() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  void interpreter_frame_set_bci(jint bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
  // byte code pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
  address interpreter_frame_bcp() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
  void    interpreter_frame_set_bcp(address bcp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
  // Unchecked access to the method data index/pointer.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
  // Only use this if you know what you are doing.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  intptr_t interpreter_frame_mdx() const                  { return *interpreter_frame_mdx_addr(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
  void interpreter_frame_set_mdx(intptr_t mdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
  // method data pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
  address interpreter_frame_mdp() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  void    interpreter_frame_set_mdp(address dp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
  // Find receiver out of caller's (compiled) argument list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
  oop retrieve_receiver(RegisterMap *reg_map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
  // Return the monitor owner and BasicLock for compiled synchronized
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
  // native methods so that biased locking can revoke the receiver's
7444
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7397
diff changeset
   281
  // bias if necessary.  This is also used by JVMTI's GetLocalInstance method
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7397
diff changeset
   282
  // (via VM_GetReceiver) to retrieve the receiver from a native wrapper frame.
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7397
diff changeset
   283
  BasicLock* get_native_monitor();
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7397
diff changeset
   284
  oop        get_native_receiver();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
  // Find receiver for an invoke when arguments are just pushed on stack (i.e., callee stack-frame is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
  // not setup)
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7444
diff changeset
   288
  oop interpreter_callee_receiver(Symbol* signature)     { return *interpreter_callee_receiver_addr(signature); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7444
diff changeset
   291
  oop* interpreter_callee_receiver_addr(Symbol* signature);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
  // expression stack (may go up or down, direction == 1 or -1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
  intptr_t* interpreter_frame_expression_stack() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  static  jint  interpreter_frame_expression_stack_direction();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  // The _at version returns a pointer because the address is used for GC.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  intptr_t* interpreter_frame_expression_stack_at(jint offset) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
  // top of expression stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  intptr_t* interpreter_frame_tos_at(jint offset) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  intptr_t* interpreter_frame_tos_address() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
  jint  interpreter_frame_expression_stack_size() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
  intptr_t* interpreter_frame_sender_sp() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
#ifndef CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
  // template based interpreter deoptimization support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
  void  set_interpreter_frame_sender_sp(intptr_t* sender_sp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
  void interpreter_frame_set_monitor_end(BasicObjectLock* value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
#endif // CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
22924
5da64eb25f2a 8035396: Introduce accessor for tmp_oop in frame.
goetz
parents: 22838
diff changeset
   317
  // Address of the temp oop in the frame. Needed as GC root.
5da64eb25f2a 8035396: Introduce accessor for tmp_oop in frame.
goetz
parents: 22838
diff changeset
   318
  oop* interpreter_frame_temp_oop_addr() const;
5da64eb25f2a 8035396: Introduce accessor for tmp_oop in frame.
goetz
parents: 22838
diff changeset
   319
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
  // BasicObjectLocks:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
  // interpreter_frame_monitor_begin is higher in memory than interpreter_frame_monitor_end
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  // Interpreter_frame_monitor_begin points to one element beyond the oldest one,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
  // interpreter_frame_monitor_end   points to the youngest one, or if there are none,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
  //                                 it points to one beyond where the first element will be.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
  // interpreter_frame_monitor_size  reports the allocation size of a monitor in the interpreter stack.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  //                                 this value is >= BasicObjectLock::size(), and may be rounded up
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
  BasicObjectLock* interpreter_frame_monitor_begin() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  BasicObjectLock* interpreter_frame_monitor_end()   const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
  BasicObjectLock* next_monitor_in_interpreter_frame(BasicObjectLock* current) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
  BasicObjectLock* previous_monitor_in_interpreter_frame(BasicObjectLock* current) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
  static int interpreter_frame_monitor_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
  void interpreter_frame_verify_monitor(BasicObjectLock* value) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  // Tells whether the current interpreter_frame frame pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  // corresponds to the old compiled/deoptimized fp
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  // The receiver used to be a top level frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  bool interpreter_frame_equals_unpacked_fp(intptr_t* fp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  // Return/result value from this interpreter frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  // If the method return type is T_OBJECT or T_ARRAY populates oop_result
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  // For other (non-T_VOID) the appropriate field in the jvalue is populated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  // with the result value.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
  // Should only be called when at method exit when the method is not
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
  // exiting due to an exception.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
  BasicType interpreter_frame_result(oop* oop_result, jvalue* value_result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
  // Method & constant pool cache
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   352
  Method* interpreter_frame_method() const;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   353
  void interpreter_frame_set_method(Method* method);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   354
  Method** interpreter_frame_method_addr() const;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   355
  ConstantPoolCache** interpreter_frame_cache_addr() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
  // Entry frames
18938
ff8f8cec9434 8016131: nsk/sysdict/vm/stress/chain tests crash the VM in 'entry_frame_is_first()'
rbackman
parents: 18025
diff changeset
   359
  JavaCallWrapper* entry_frame_call_wrapper() const { return *entry_frame_call_wrapper_addr(); }
ff8f8cec9434 8016131: nsk/sysdict/vm/stress/chain tests crash the VM in 'entry_frame_is_first()'
rbackman
parents: 18025
diff changeset
   360
  JavaCallWrapper* entry_frame_call_wrapper_if_safe(JavaThread* thread) const;
ff8f8cec9434 8016131: nsk/sysdict/vm/stress/chain tests crash the VM in 'entry_frame_is_first()'
rbackman
parents: 18025
diff changeset
   361
  JavaCallWrapper** entry_frame_call_wrapper_addr() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
  intptr_t* entry_frame_argument_at(int offset) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
  // tells whether there is another chunk of Delta stack above
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
  bool entry_frame_is_first() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
  // Compiled frames:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
  // Given the index of a local, and the number of argument words
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
  // in this stack frame, tell which word of the stack frame to find
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
  // the local in.  Arguments are stored above the ofp/rpc pair,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
  // while other locals are stored below it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
  // Since monitors (BasicLock blocks) are also assigned indexes,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  // but may have different storage requirements, their presence
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
  // can also affect the calculation of offsets.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
  static int local_offset_for_compiler(int local_index, int nof_args, int max_nof_locals, int max_nof_monitors);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
  // Given the index of a monitor, etc., tell which word of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
  // stack frame contains the start of the BasicLock block.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
  // Note that the local index by convention is the __higher__
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
  // of the two indexes allocated to the block.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
  static int monitor_offset_for_compiler(int local_index, int nof_args, int max_nof_locals, int max_nof_monitors);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
  // Tell the smallest value that local_offset_for_compiler will attain.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
  // This is used to help determine how much stack frame to allocate.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
  static int min_local_offset_for_compiler(int nof_args, int max_nof_locals, int max_nof_monitors);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
  // Tells if this register must be spilled during a call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
  // On Intel, all registers are smashed by calls.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  static bool volatile_across_calls(Register reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
  // Safepoints
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
  oop saved_oop_result(RegisterMap* map) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  void set_saved_oop_result(RegisterMap* map, oop obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
  // For debugging
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
  const char* print_name() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
9437
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   404
  void describe_pd(FrameValues& values, int frame_no);
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   405
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
  void print_value() const { print_value_on(tty,NULL); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
  void print_value_on(outputStream* st, JavaThread *thread) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
  void print_on(outputStream* st) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
  void interpreter_frame_print_on(outputStream* st) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
  void print_on_error(outputStream* st, char* buf, int buflen, bool verbose = false) const;
19952
bc974e92f881 8022335: Native stack walk while generating hs_err does not work on Windows x64
iklam
parents: 18938
diff changeset
   412
  static void print_C_frame(outputStream* st, char* buf, int buflen, address pc);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
9437
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   414
  // Add annotated descriptions of memory locations belonging to this frame to values
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   415
  void describe(FrameValues& values, int frame_no);
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   416
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  // Conversion from an VMReg to physical stack location
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
  oop* oopmapreg_to_location(VMReg reg, const RegisterMap* regmap) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
  // Oops-do's
17872
2c49e72dcf08 8009981: nashorn tests fail with -XX:+VerifyStack
roland
parents: 14633
diff changeset
   421
  void oops_compiled_arguments_do(Symbol* signature, bool has_receiver, bool has_appendix, const RegisterMap* reg_map, OopClosure* f);
22899
e2a6bf7f343a 8035393: Use CLDClosure instead of CLDToOopClosure in frame::oops_interpreted_do
stefank
parents: 19952
diff changeset
   422
  void oops_interpreted_do(OopClosure* f, CLDClosure* cld_f, const RegisterMap* map, bool query_oop_map_cache = true);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
 private:
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7444
diff changeset
   425
  void oops_interpreted_arguments_do(Symbol* signature, bool has_receiver, OopClosure* f);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  // Iteration of oops
22899
e2a6bf7f343a 8035393: Use CLDClosure instead of CLDToOopClosure in frame::oops_interpreted_do
stefank
parents: 19952
diff changeset
   428
  void oops_do_internal(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf, RegisterMap* map, bool use_interpreter_oop_map_cache);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
  void oops_entry_do(OopClosure* f, const RegisterMap* map);
3908
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 3261
diff changeset
   430
  void oops_code_blob_do(OopClosure* f, CodeBlobClosure* cf, const RegisterMap* map);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   431
  int adjust_offset(Method* method, int index); // helper for above fn
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
  // Memory management
22899
e2a6bf7f343a 8035393: Use CLDClosure instead of CLDToOopClosure in frame::oops_interpreted_do
stefank
parents: 19952
diff changeset
   434
  void oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf, RegisterMap* map) { oops_do_internal(f, cld_f, cf, map, true); }
3908
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 3261
diff changeset
   435
  void nmethods_do(CodeBlobClosure* cf);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   437
  // RedefineClasses support for finding live interpreted methods on the stack
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   438
  void metadata_do(void f(Metadata*));
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   439
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
  void gc_prologue();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
  void gc_epilogue();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
  void pd_gc_epilog();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
# ifdef ENABLE_ZAP_DEAD_LOCALS
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
  class CheckValueClosure: public OopClosure {
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 354
diff changeset
   447
   public:
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 354
diff changeset
   448
    void do_oop(oop* p);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 354
diff changeset
   449
    void do_oop(narrowOop* p) { ShouldNotReachHere(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
  static CheckValueClosure _check_value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
  class CheckOopClosure: public OopClosure {
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 354
diff changeset
   454
   public:
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 354
diff changeset
   455
    void do_oop(oop* p);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 354
diff changeset
   456
    void do_oop(narrowOop* p) { ShouldNotReachHere(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
  static CheckOopClosure _check_oop;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
  static void check_derived_oop(oop* base, oop* derived);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
  class ZapDeadClosure: public OopClosure {
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 354
diff changeset
   463
   public:
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 354
diff changeset
   464
    void do_oop(oop* p);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 354
diff changeset
   465
    void do_oop(narrowOop* p) { ShouldNotReachHere(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
  static ZapDeadClosure _zap_dead;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
  // Zapping
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
  void zap_dead_locals            (JavaThread* thread, const RegisterMap* map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
  void zap_dead_interpreted_locals(JavaThread* thread, const RegisterMap* map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
  void zap_dead_compiled_locals   (JavaThread* thread, const RegisterMap* map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
  void zap_dead_entry_locals      (JavaThread* thread, const RegisterMap* map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
  void zap_dead_deoptimized_locals(JavaThread* thread, const RegisterMap* map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
# endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
  // Verification
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
  void verify(const RegisterMap* map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
  static bool verify_return_pc(address x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
  static bool is_bci(intptr_t bcx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
  // Usage:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
  // assert(frame::verify_return_pc(return_address), "must be a return pc");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
  int pd_oop_map_offset_adjustment() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
   486
#ifdef TARGET_ARCH_x86
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
   487
# include "frame_x86.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
   488
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
   489
#ifdef TARGET_ARCH_sparc
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
   490
# include "frame_sparc.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
   491
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
   492
#ifdef TARGET_ARCH_zero
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
   493
# include "frame_zero.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
   494
#endif
8107
78e5bd944384 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 8076
diff changeset
   495
#ifdef TARGET_ARCH_arm
78e5bd944384 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 8076
diff changeset
   496
# include "frame_arm.hpp"
78e5bd944384 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 8076
diff changeset
   497
#endif
78e5bd944384 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 8076
diff changeset
   498
#ifdef TARGET_ARCH_ppc
78e5bd944384 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 8076
diff changeset
   499
# include "frame_ppc.hpp"
78e5bd944384 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 8076
diff changeset
   500
#endif
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
   501
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
11571
23f825a42a85 7120468: SPARC/x86: use frame::describe to enhance trace_method_handle
bdelsart
parents: 11486
diff changeset
   504
#ifndef PRODUCT
9437
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   505
// A simple class to describe a location on the stack
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   506
class FrameValue VALUE_OBJ_CLASS_SPEC {
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   507
 public:
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   508
  intptr_t* location;
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   509
  char* description;
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   510
  int owner;
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   511
  int priority;
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   512
};
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   513
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   514
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   515
// A collection of described stack values that can print a symbolic
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   516
// description of the stack memory.  Interpreter frame values can be
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   517
// in the caller frames so all the values are collected first and then
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   518
// sorted before being printed.
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   519
class FrameValues {
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   520
 private:
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   521
  GrowableArray<FrameValue> _values;
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   522
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   523
  static int compare(FrameValue* a, FrameValue* b) {
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   524
    if (a->location == b->location) {
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   525
      return a->priority - b->priority;
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   526
    }
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   527
    return a->location - b->location;
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   528
  }
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   529
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   530
 public:
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   531
  // Used by frame functions to describe locations.
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   532
  void describe(int owner, intptr_t* location, const char* description, int priority = 0);
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   533
11571
23f825a42a85 7120468: SPARC/x86: use frame::describe to enhance trace_method_handle
bdelsart
parents: 11486
diff changeset
   534
#ifdef ASSERT
9632
cd86c748c12b 7043301: assert(locals < caller->fp() || locals > (caller->fp() + 16)) failed: locals in save area
never
parents: 9630
diff changeset
   535
  void validate();
11571
23f825a42a85 7120468: SPARC/x86: use frame::describe to enhance trace_method_handle
bdelsart
parents: 11486
diff changeset
   536
#endif
10966
0c9ed2dfc6a2 7090904: JSR 292: JRuby junit test crashes in PSScavengeRootsClosure::do_oop
twisti
parents: 10539
diff changeset
   537
  void print(JavaThread* thread);
9437
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   538
};
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   539
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   540
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
// StackFrameStream iterates through the frames of a thread starting from
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
// top most frame. It automatically takes care of updating the location of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
// all (callee-saved) registers. Notice: If a thread is stopped at
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
// a safepoint, all registers are saved, not only the callee-saved ones.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
// Use:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
//   for(StackFrameStream fst(thread); !fst.is_done(); fst.next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
//     ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
//   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
class StackFrameStream : public StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  frame       _fr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
  RegisterMap _reg_map;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
  bool        _is_done;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
   StackFrameStream(JavaThread *thread, bool update = true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
  // Iteration
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
  bool is_done()                  { return (_is_done) ? true : (_is_done = _fr.is_first_frame(), false); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
  void next()                     { if (!_is_done) _fr = _fr.sender(&_reg_map); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
  // Query
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
  frame *current()                { return &_fr; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
  RegisterMap* register_map()     { return &_reg_map; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
};
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
   570
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6269
diff changeset
   571
#endif // SHARE_VM_RUNTIME_FRAME_HPP