hotspot/src/cpu/x86/vm/frame_x86.hpp
author duke
Sat, 01 Dec 2007 00:00:00 +0000
changeset 1 489c9b5090e2
child 4752 67a506670cd0
permissions -rw-r--r--
Initial load
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
     2
 * Copyright 1997-2007 Sun Microsystems, Inc.  All Rights Reserved.
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
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    19
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    20
 * CA 95054 USA or visit www.sun.com if you need additional information or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    21
 * have any questions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
489c9b5090e2 Initial load
duke
parents:
diff changeset
    25
// A frame represents a physical stack frame (an activation).  Frames can be
489c9b5090e2 Initial load
duke
parents:
diff changeset
    26
// C or Java frames, and the Java frames can be interpreted or compiled.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    27
// In contrast, vframes represent source-level activations, so that one physical frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
    28
// can correspond to multiple source level frames because of inlining.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
// A frame is comprised of {pc, fp, sp}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
// ------------------------------ Asm interpreter ----------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
// Layout of asm interpreter frame:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
//    [expression stack      ] * <- sp
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
//    [monitors              ]   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
//     ...                        | monitor block size
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
//    [monitors              ]   /
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
//    [monitor block size    ]
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
//    [byte code index/pointr]                   = bcx()                bcx_offset
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
//    [pointer to locals     ]                   = locals()             locals_offset
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
//    [constant pool cache   ]                   = cache()              cache_offset
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
//    [methodData            ]                   = mdp()                mdx_offset
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
//    [methodOop             ]                   = method()             method_offset
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
//    [last sp               ]                   = last_sp()            last_sp_offset
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
//    [old stack pointer     ]                     (sender_sp)          sender_sp_offset
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
//    [old frame pointer     ]   <- fp           = link()
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
//    [return pc             ]
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
//    [oop temp              ]                     (only for native calls)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
//    [locals and parameters ]
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
//                               <- sender sp
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
// ------------------------------ Asm interpreter ----------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
// ------------------------------ C++ interpreter ----------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
// Layout of C++ interpreter frame: (While executing in BytecodeInterpreter::run)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
//                             <- SP (current esp/rsp)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
//    [local variables         ] BytecodeInterpreter::run local variables
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
//    ...                        BytecodeInterpreter::run local variables
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
//    [local variables         ] BytecodeInterpreter::run local variables
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
//    [old frame pointer       ]   fp [ BytecodeInterpreter::run's ebp/rbp ]
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
//    [return pc               ]  (return to frame manager)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
//    [interpreter_state*      ]  (arg to BytecodeInterpreter::run)   --------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
//    [expression stack        ] <- last_Java_sp                           |
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
//    [...                     ] * <- interpreter_state.stack              |
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
//    [expression stack        ] * <- interpreter_state.stack_base         |
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
//    [monitors                ]   \                                       |
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
//     ...                          | monitor block size                   |
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
//    [monitors                ]   / <- interpreter_state.monitor_base     |
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
//    [struct interpretState   ] <-----------------------------------------|
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
//    [return pc               ] (return to callee of frame manager [1]
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
//    [locals and parameters   ]
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
//                               <- sender sp
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
// [1] When the c++ interpreter calls a new method it returns to the frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
//     manager which allocates a new frame on the stack. In that case there
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
//     is no real callee of this newly allocated frame. The frame manager is
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
//     aware of the  additional frame(s) and will pop them as nested calls
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
//     complete. Howevers tTo make it look good in the debugger the frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
//     manager actually installs a dummy pc pointing to RecursiveInterpreterActivation
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
//     with a fake interpreter_state* parameter to make it easy to debug
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
//     nested calls.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
// Note that contrary to the layout for the assembly interpreter the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
// expression stack allocated for the C++ interpreter is full sized.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
// However this is not as bad as it seems as the interpreter frame_manager
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
// will truncate the unused space on succesive method calls.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
// ------------------------------ C++ interpreter ----------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  enum {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
    pc_return_offset                                 =  0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
    // All frames
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
    link_offset                                      =  0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
    return_addr_offset                               =  1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
    // non-interpreter frames
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
    sender_sp_offset                                 =  2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
#ifndef CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
    // Interpreter frames
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
    interpreter_frame_result_handler_offset          =  3, // for native calls only
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
    interpreter_frame_oop_temp_offset                =  2, // for native calls only
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
    interpreter_frame_sender_sp_offset               = -1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
    // outgoing sp before a call to an invoked method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
    interpreter_frame_last_sp_offset                 = interpreter_frame_sender_sp_offset - 1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
    interpreter_frame_method_offset                  = interpreter_frame_last_sp_offset - 1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
    interpreter_frame_mdx_offset                     = interpreter_frame_method_offset - 1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
    interpreter_frame_cache_offset                   = interpreter_frame_mdx_offset - 1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
    interpreter_frame_locals_offset                  = interpreter_frame_cache_offset - 1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
    interpreter_frame_bcx_offset                     = interpreter_frame_locals_offset - 1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
    interpreter_frame_initial_sp_offset              = interpreter_frame_bcx_offset - 1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
    interpreter_frame_monitor_block_top_offset       = interpreter_frame_initial_sp_offset,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
    interpreter_frame_monitor_block_bottom_offset    = interpreter_frame_initial_sp_offset,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
#endif // CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
    // Entry frames
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
#ifdef AMD64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
#ifdef _WIN64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
    entry_frame_after_call_words                     =  8,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
    entry_frame_call_wrapper_offset                  =  2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
    arg_reg_save_area_bytes                          = 32, // Register argument save area
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
    entry_frame_after_call_words                     = 13,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
    entry_frame_call_wrapper_offset                  = -6,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
    arg_reg_save_area_bytes                          =  0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
#endif // _WIN64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
    entry_frame_call_wrapper_offset                  =  2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
#endif // AMD64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
    // Native frames
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
    native_frame_initial_param_offset                =  2
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  intptr_t ptr_at(int offset) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
    return *ptr_at_addr(offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  void ptr_at_put(int offset, intptr_t value) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
    *ptr_at_addr(offset) = value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  // an additional field beyond _sp and _pc:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  intptr_t*   _fp; // frame pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  // The interpreter and adapters will extend the frame of the caller.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  // Since oopMaps are based on the sp of the caller before extension
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  // we need to know that value. However in order to compute the address
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  // of the return address we need the real "raw" sp. Since sparc already
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  // uses sp() to mean "raw" sp and unextended_sp() to mean the caller's
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  // original sp we use that convention.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  intptr_t*     _unextended_sp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  intptr_t* ptr_at_addr(int offset) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
    return (intptr_t*) addr_at(offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  // Constructors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  frame(intptr_t* sp, intptr_t* fp, address pc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  frame(intptr_t* sp, intptr_t* unextended_sp, intptr_t* fp, address pc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  frame(intptr_t* sp, intptr_t* fp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  // accessors for the instance variables
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  intptr_t*   fp() const { return _fp; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  inline address* sender_pc_addr() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  // return address of param, zero origin index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  inline address* native_param_addr(int idx) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  // expression stack tos if we are nested in a java call
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  intptr_t* interpreter_frame_last_sp() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
#ifndef CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  // deoptimization support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  void interpreter_frame_set_last_sp(intptr_t* sp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
#endif // CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
#ifdef CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  inline interpreterState get_interpreterState() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
#endif // CC_INTERP