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