hotspot/src/cpu/x86/vm/interp_masm_x86_32.hpp
author jrose
Wed, 08 Apr 2009 10:56:49 -0700
changeset 2534 08dac9ce0cd7
parent 2105 347008ce7984
child 2570 ecc7862946d4
permissions -rw-r--r--
6655638: dynamic languages need method handles Summary: initial implementation, with known omissions (x86/64, sparc, compiler optim., c-oops, C++ interp.) Reviewed-by: kvn, twisti, never
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
2105
347008ce7984 6814575: Update copyright year
xdono
parents: 1888
diff changeset
     2
 * Copyright 1997-2009 Sun Microsystems, Inc.  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
 *
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
// This file specializes the assember with interpreter-specific macros
489c9b5090e2 Initial load
duke
parents:
diff changeset
    26
489c9b5090e2 Initial load
duke
parents:
diff changeset
    27
489c9b5090e2 Initial load
duke
parents:
diff changeset
    28
class InterpreterMacroAssembler: public MacroAssembler {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
#ifndef CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
  // Interpreter specific version of call_VM_base
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
  virtual void call_VM_leaf_base(
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
    address entry_point,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
    int     number_of_arguments
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
  );
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
  virtual void call_VM_base(
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
    Register oop_result,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
    Register java_thread,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
    Register last_java_sp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
    address  entry_point,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
    int      number_of_arguments,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
    bool     check_exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
  );
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
  virtual void check_and_handle_popframe(Register java_thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
  virtual void check_and_handle_earlyret(Register java_thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
  // base routine for all dispatches
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
  void dispatch_base(TosState state, address* table, bool verifyoop = true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
#endif /* CC_INTERP */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
  InterpreterMacroAssembler(CodeBuffer* code) : MacroAssembler(code) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  void load_earlyret_value(TosState state);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
  // Interpreter-specific registers
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
#ifdef CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
  void save_bcp()                                          { /*  not needed in c++ interpreter and harmless */ }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  void restore_bcp()                                       { /*  not needed in c++ interpreter and harmless */ }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
  // Helpers for runtime call arguments/results
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
  void get_method(Register reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 1
diff changeset
    68
  void save_bcp()                                          { movptr(Address(rbp, frame::interpreter_frame_bcx_offset * wordSize), rsi); }
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 1
diff changeset
    69
  void restore_bcp()                                       { movptr(rsi, Address(rbp, frame::interpreter_frame_bcx_offset * wordSize)); }
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 1
diff changeset
    70
  void restore_locals()                                    { movptr(rdi, Address(rbp, frame::interpreter_frame_locals_offset * wordSize)); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  // Helpers for runtime call arguments/results
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 1
diff changeset
    73
  void get_method(Register reg)                            { movptr(reg, Address(rbp, frame::interpreter_frame_method_offset * wordSize)); }
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 1
diff changeset
    74
  void get_constant_pool(Register reg)                     { get_method(reg); movptr(reg, Address(reg, methodOopDesc::constants_offset())); }
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 1
diff changeset
    75
  void get_constant_pool_cache(Register reg)               { get_constant_pool(reg); movptr(reg, Address(reg, constantPoolOopDesc::cache_offset_in_bytes())); }
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 1
diff changeset
    76
  void get_cpool_and_tags(Register cpool, Register tags)   { get_constant_pool(cpool); movptr(tags, Address(cpool, constantPoolOopDesc::tags_offset_in_bytes()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
  void get_unsigned_2_byte_index_at_bcp(Register reg, int bcp_offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  void get_cache_and_index_at_bcp(Register cache, Register index, int bcp_offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  void get_cache_entry_pointer_at_bcp(Register cache, Register tmp, int bcp_offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  // Expression stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  void f2ieee();                                           // truncate ftos to 32bits
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  void d2ieee();                                           // truncate dtos to 64bits
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  void pop_ptr(Register r = rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
  void pop_ptr(Register r, Register tag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  void pop_i(Register r = rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  void pop_l(Register lo = rax, Register hi = rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  void pop_f();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  void pop_d();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  void pop_ftos_to_rsp();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  void pop_dtos_to_rsp();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  void push_ptr(Register r = rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  void push_ptr(Register r, Register tag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  void push_i(Register r = rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  void push_l(Register lo = rax, Register hi = rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  void push_d(Register r = rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  void push_f();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  void pop(TosState state);        // transition vtos -> state
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  void push(TosState state);       // transition state -> vtos
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 1
diff changeset
   105
  void pop(Register r ) { ((MacroAssembler*)this)->pop(r); }
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 1
diff changeset
   106
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 1
diff changeset
   107
  void push(Register r ) { ((MacroAssembler*)this)->push(r); }
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 1
diff changeset
   108
  void push(int32_t imm ) { ((MacroAssembler*)this)->push(imm); }
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 1
diff changeset
   109
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 1
diff changeset
   110
  // These are dummies to prevent surprise implicit conversions to Register
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 1
diff changeset
   111
  void pop(void* v ); // Add unimplemented ambiguous method
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 1
diff changeset
   112
  void push(void* v );   // Add unimplemented ambiguous method
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 1
diff changeset
   113
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
  DEBUG_ONLY(void verify_stack_tag(frame::Tag t);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 1
diff changeset
   116
#endif // CC_INTERP
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 1
diff changeset
   117
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
#ifndef CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  void empty_expression_stack()                            {
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 1
diff changeset
   121
       movptr(rsp, Address(rbp, frame::interpreter_frame_monitor_block_top_offset * wordSize));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
      // NULL last_sp until next java call
1888
bbf498fb4354 6787106: Hotspot 32 bit build fails on platforms having different definitions for intptr_t & int32_t
xlu
parents: 1217
diff changeset
   123
      movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), NULL_WORD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  // Tagged stack helpers for swap and dup
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  void load_ptr_and_tag(int n, Register val, Register tag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  void store_ptr_and_tag(int n, Register val, Register tag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  // Tagged Local support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  void tag_local(frame::Tag tag, int n);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  void tag_local(Register tag, int n);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  void tag_local(frame::Tag tag, Register idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  void tag_local(Register tag, Register idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  void verify_local_tag(frame::Tag tag, int n);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
  void verify_local_tag(frame::Tag tag, Register idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
#endif // ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  // Super call_VM calls - correspond to MacroAssembler::call_VM(_leaf) calls
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  void super_call_VM_leaf(address entry_point);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  void super_call_VM_leaf(address entry_point, Register arg_1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  void super_call_VM_leaf(address entry_point, Register arg_1, Register arg_2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  void super_call_VM_leaf(address entry_point, Register arg_1, Register arg_2, Register arg_3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  // Generate a subtype check: branch to ok_is_subtype if sub_klass is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  // a subtype of super_klass.  EAX holds the super_klass.  Blows ECX
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  // and EDI.  Register sub_klass cannot be any of the above.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  void gen_subtype_check( Register sub_klass, Label &ok_is_subtype );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  // Dispatching
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  void dispatch_prolog(TosState state, int step = 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  void dispatch_epilog(TosState state, int step = 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  void dispatch_only(TosState state);                      // dispatch via rbx, (assume rbx, is loaded already)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  void dispatch_only_normal(TosState state);               // dispatch normal table via rbx, (assume rbx, is loaded already)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  void dispatch_only_noverify(TosState state);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  void dispatch_next(TosState state, int step = 0);        // load rbx, from [esi + step] and dispatch via rbx,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  void dispatch_via (TosState state, address* table);      // load rbx, from [esi] and dispatch via rbx, and table
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  // jump to an invoked target
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2105
diff changeset
   164
  void prepare_to_jump_from_interpreted();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  void jump_from_interpreted(Register method, Register temp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  // Returning from interpreted functions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  // Removes the current activation (incl. unlocking of monitors)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
  // and sets up the return address.  This code is also used for
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  // exception unwindwing. In that case, we do not want to throw
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  // IllegalMonitorStateExceptions, since that might get us into an
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  // infinite rethrow exception loop.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  // Additionally this code is used for popFrame and earlyReturn.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  // In popFrame case we want to skip throwing an exception,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  // installing an exception, and notifying jvmdi.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  // In earlyReturn case we only want to skip throwing an exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  // and installing an exception.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  void remove_activation(TosState state, Register ret_addr,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
                         bool throw_monitor_exception = true,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
                         bool install_monitor_exception = true,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
                         bool notify_jvmdi = true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
#endif /* !CC_INTERP */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  // Debugging
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
  void verify_oop(Register reg, TosState state = atos);    // only if +VerifyOops && state == atos
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
#ifndef CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  void verify_FPU(int stack_depth, TosState state = ftos); // only if +VerifyFPU  && (state == ftos || state == dtos)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
#endif /* !CC_INTERP */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  // Object locking
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  void lock_object  (Register lock_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  void unlock_object(Register lock_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
#ifndef CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  // Interpreter profiling operations
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  void set_method_data_pointer_for_bcp();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
  void test_method_data_pointer(Register mdp, Label& zero_continue);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  void verify_method_data_pointer();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  void set_mdp_data_at(Register mdp_in, int constant, Register value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  void increment_mdp_data_at(Address data, bool decrement = false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  void increment_mdp_data_at(Register mdp_in, int constant,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
                             bool decrement = false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
  void increment_mdp_data_at(Register mdp_in, Register reg, int constant,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
                             bool decrement = false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
  void set_mdp_flag_at(Register mdp_in, int flag_constant);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
  void test_mdp_data_at(Register mdp_in, int offset, Register value,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
                        Register test_value_out,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
                        Label& not_equal_continue);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
  void record_klass_in_profile(Register receiver, Register mdp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
                               Register reg2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  void record_klass_in_profile_helper(Register receiver, Register mdp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
                                      Register reg2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
                                      int start_row, Label& done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
  void update_mdp_by_offset(Register mdp_in, int offset_of_offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
  void update_mdp_by_offset(Register mdp_in, Register reg, int offset_of_disp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
  void update_mdp_by_constant(Register mdp_in, int constant);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  void update_mdp_for_ret(Register return_bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  void profile_taken_branch(Register mdp, Register bumped_count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  void profile_not_taken_branch(Register mdp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
  void profile_call(Register mdp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
  void profile_final_call(Register mdp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  void profile_virtual_call(Register receiver, Register mdp, Register scratch2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
  void profile_ret(Register return_bci, Register mdp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
  void profile_null_seen(Register mdp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
  void profile_typecheck(Register mdp, Register klass, Register scratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
  void profile_typecheck_failed(Register mdp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
  void profile_switch_default(Register mdp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  void profile_switch_case(Register index_in_scratch, Register mdp, Register scratch2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
#endif /* !CC_INTERP */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  typedef enum { NotifyJVMTI, SkipNotifyJVMTI } NotifyMethodExitMode;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
  // support for jvmti
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
  void notify_method_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
  void notify_method_exit(TosState state, NotifyMethodExitMode mode);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
};