< prev index next >

src/hotspot/cpu/x86/interp_masm_x86.hpp

Print this page

176   void pop(TosState state);        // transition vtos -> state
177   void push(TosState state);       // transition state -> vtos
178 
179   // These are dummies to prevent surprise implicit conversions to Register
180   void pop(void* v); // Add unimplemented ambiguous method
181   void push(void* v);   // Add unimplemented ambiguous method
182 
183   void empty_expression_stack() {
184     movptr(rsp, Address(rbp, frame::interpreter_frame_monitor_block_top_offset * wordSize));
185     // NULL last_sp until next java call
186     movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD);
187     NOT_LP64(empty_FPU_stack());
188   }
189 
190   // Helpers for swap and dup
191   void load_ptr(int n, Register val);
192   void store_ptr(int n, Register val);
193 
194   // Generate a subtype check: branch to ok_is_subtype if sub_klass is
195   // a subtype of super_klass.
196   void gen_subtype_check( Register sub_klass, Label &ok_is_subtype );
197 
198   // Dispatching
199   void dispatch_prolog(TosState state, int step = 0);
200   void dispatch_epilog(TosState state, int step = 0);
201   // dispatch via rbx (assume rbx is loaded already)
202   void dispatch_only(TosState state, bool generate_poll = false);
203   // dispatch normal table via rbx (assume rbx is loaded already)
204   void dispatch_only_normal(TosState state);
205   void dispatch_only_noverify(TosState state);
206   // load rbx from [_bcp_register + step] and dispatch via rbx
207   void dispatch_next(TosState state, int step = 0, bool generate_poll = false);
208   // load rbx from [_bcp_register] and dispatch via rbx and table
209   void dispatch_via (TosState state, address* table);
210 
211   // jump to an invoked target
212   void prepare_to_jump_from_interpreted();
213   void jump_from_interpreted(Register method, Register temp);
214 
215   // narrow int return value
216   void narrow(Register result);
217 
218   // Returning from interpreted functions
219   //
220   // Removes the current activation (incl. unlocking of monitors)
221   // and sets up the return address.  This code is also used for
222   // exception unwindwing. In that case, we do not want to throw
223   // IllegalMonitorStateExceptions, since that might get us into an
224   // infinite rethrow exception loop.
225   // Additionally this code is used for popFrame and earlyReturn.
226   // In popFrame case we want to skip throwing an exception,
227   // installing an exception, and notifying jvmdi.
228   // In earlyReturn case we only want to skip throwing an exception
229   // and installing an exception.
230   void remove_activation(TosState state, Register ret_addr,
231                          bool throw_monitor_exception = true,
232                          bool install_monitor_exception = true,
233                          bool notify_jvmdi = true);
234   void get_method_counters(Register method, Register mcs, Label& skip);
235 























236   // Object locking
237   void lock_object  (Register lock_reg);
238   void unlock_object(Register lock_reg);
239 
240   // Interpreter profiling operations
241   void set_method_data_pointer_for_bcp();
242   void test_method_data_pointer(Register mdp, Label& zero_continue);
243   void verify_method_data_pointer();
244 
245   void set_mdp_data_at(Register mdp_in, int constant, Register value);
246   void increment_mdp_data_at(Address data, bool decrement = false);
247   void increment_mdp_data_at(Register mdp_in, int constant,
248                              bool decrement = false);
249   void increment_mdp_data_at(Register mdp_in, Register reg, int constant,
250                              bool decrement = false);
251   void increment_mask_and_jump(Address counter_addr,
252                                int increment, Address mask,
253                                Register scratch, bool preloaded,
254                                Condition cond, Label* where);
255   void set_mdp_flag_at(Register mdp_in, int flag_constant);
256   void test_mdp_data_at(Register mdp_in, int offset, Register value,
257                         Register test_value_out,
258                         Label& not_equal_continue);
259 
260   void record_klass_in_profile(Register receiver, Register mdp,
261                                Register reg2, bool is_virtual_call);
262   void record_klass_in_profile_helper(Register receiver, Register mdp,
263                                       Register reg2, int start_row,
264                                       Label& done, bool is_virtual_call);
265   void record_item_in_profile_helper(Register item, Register mdp,
266                                      Register reg2, int start_row, Label& done, int total_rows,
267                                      OffsetFunction item_offset_fn, OffsetFunction item_count_offset_fn,
268                                      int non_profiled_offset);
269 
270   void update_mdp_by_offset(Register mdp_in, int offset_of_offset);
271   void update_mdp_by_offset(Register mdp_in, Register reg, int offset_of_disp);
272   void update_mdp_by_constant(Register mdp_in, int constant);
273   void update_mdp_for_ret(Register return_bci);
274 
275   void profile_taken_branch(Register mdp, Register bumped_count);
276   void profile_not_taken_branch(Register mdp);
277   void profile_call(Register mdp);
278   void profile_final_call(Register mdp);
279   void profile_virtual_call(Register receiver, Register mdp,
280                             Register scratch2,
281                             bool receiver_can_be_null = false);
282   void profile_ret(Register return_bci, Register mdp);
283   void profile_null_seen(Register mdp);
284   void profile_typecheck(Register mdp, Register klass, Register scratch);
285   void profile_typecheck_failed(Register mdp);
286   void profile_switch_default(Register mdp);
287   void profile_switch_case(Register index_in_scratch, Register mdp,
288                            Register scratch2);



289 
290   // Debugging
291   // only if +VerifyOops && state == atos
292 #define interp_verify_oop(reg, state) _interp_verify_oop(reg, state, __FILE__, __LINE__);
293   void _interp_verify_oop(Register reg, TosState state, const char* file, int line);
294   // only if +VerifyFPU  && (state == ftos || state == dtos)
295   void verify_FPU(int stack_depth, TosState state = ftos);
296 
297   typedef enum { NotifyJVMTI, SkipNotifyJVMTI } NotifyMethodExitMode;
298 
299   // support for jvmti/dtrace
300   void notify_method_entry();
301   void notify_method_exit(TosState state, NotifyMethodExitMode mode);
302 
303  private:
304 
305   Register _locals_register; // register that contains the pointer to the locals
306   Register _bcp_register; // register that contains the bcp
307 
308  public:

176   void pop(TosState state);        // transition vtos -> state
177   void push(TosState state);       // transition state -> vtos
178 
179   // These are dummies to prevent surprise implicit conversions to Register
180   void pop(void* v); // Add unimplemented ambiguous method
181   void push(void* v);   // Add unimplemented ambiguous method
182 
183   void empty_expression_stack() {
184     movptr(rsp, Address(rbp, frame::interpreter_frame_monitor_block_top_offset * wordSize));
185     // NULL last_sp until next java call
186     movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD);
187     NOT_LP64(empty_FPU_stack());
188   }
189 
190   // Helpers for swap and dup
191   void load_ptr(int n, Register val);
192   void store_ptr(int n, Register val);
193 
194   // Generate a subtype check: branch to ok_is_subtype if sub_klass is
195   // a subtype of super_klass.
196   void gen_subtype_check(Register sub_klass, Label &ok_is_subtype, bool profile = true);
197 
198   // Dispatching
199   void dispatch_prolog(TosState state, int step = 0);
200   void dispatch_epilog(TosState state, int step = 0);
201   // dispatch via rbx (assume rbx is loaded already)
202   void dispatch_only(TosState state, bool generate_poll = false);
203   // dispatch normal table via rbx (assume rbx is loaded already)
204   void dispatch_only_normal(TosState state);
205   void dispatch_only_noverify(TosState state);
206   // load rbx from [_bcp_register + step] and dispatch via rbx
207   void dispatch_next(TosState state, int step = 0, bool generate_poll = false);
208   // load rbx from [_bcp_register] and dispatch via rbx and table
209   void dispatch_via (TosState state, address* table);
210 
211   // jump to an invoked target
212   void prepare_to_jump_from_interpreted();
213   void jump_from_interpreted(Register method, Register temp);
214 
215   // narrow int return value
216   void narrow(Register result);
217 
218   // Returning from interpreted functions
219   //
220   // Removes the current activation (incl. unlocking of monitors)
221   // and sets up the return address.  This code is also used for
222   // exception unwindwing. In that case, we do not want to throw
223   // IllegalMonitorStateExceptions, since that might get us into an
224   // infinite rethrow exception loop.
225   // Additionally this code is used for popFrame and earlyReturn.
226   // In popFrame case we want to skip throwing an exception,
227   // installing an exception, and notifying jvmdi.
228   // In earlyReturn case we only want to skip throwing an exception
229   // and installing an exception.
230   void remove_activation(TosState state, Register ret_addr,
231                          bool throw_monitor_exception = true,
232                          bool install_monitor_exception = true,
233                          bool notify_jvmdi = true);
234   void get_method_counters(Register method, Register mcs, Label& skip);
235 
236   // Kills t1 and t2, perserves klass, return allocation in new_obj
237   void allocate_instance(Register klass, Register new_obj,
238                          Register t1, Register t2,
239                          bool clear_fields, Label& alloc_failed);
240   // Allocate instance in "obj" and read in the content of the inline field
241   // NOTES:
242   //   - input holder object via "obj", which must be rax,
243   //     will return new instance via the same reg
244   //   - assumes holder_klass and valueKlass field klass have both been resolved
245   //   - 32 bits: kills rdi and rsi
246   void read_inlined_field(Register holder_klass,
247                             Register field_index, Register field_offset,
248                             Register obj = rax);
249 
250   // Allocate value buffer in "obj" and read in flattened element at the given index
251   // NOTES:
252   //   - Return via "obj" must be rax
253   //   - kills all given regs
254   //   - 32 bits: kills rdi and rsi
255   void read_flattened_element(Register array, Register index,
256                               Register t1, Register t2,
257                               Register obj = rax);
258 
259   // Object locking
260   void lock_object  (Register lock_reg);
261   void unlock_object(Register lock_reg);
262 
263   // Interpreter profiling operations
264   void set_method_data_pointer_for_bcp();
265   void test_method_data_pointer(Register mdp, Label& zero_continue);
266   void verify_method_data_pointer();
267 
268   void set_mdp_data_at(Register mdp_in, int constant, Register value);
269   void increment_mdp_data_at(Address data, bool decrement = false);
270   void increment_mdp_data_at(Register mdp_in, int constant,
271                              bool decrement = false);
272   void increment_mdp_data_at(Register mdp_in, Register reg, int constant,
273                              bool decrement = false);
274   void increment_mask_and_jump(Address counter_addr,
275                                int increment, Address mask,
276                                Register scratch, bool preloaded,
277                                Condition cond, Label* where);
278   void set_mdp_flag_at(Register mdp_in, int flag_constant);
279   void test_mdp_data_at(Register mdp_in, int offset, Register value,
280                         Register test_value_out,
281                         Label& not_equal_continue);
282 
283   void record_klass_in_profile(Register receiver, Register mdp,
284                                Register reg2, bool is_virtual_call);
285   void record_klass_in_profile_helper(Register receiver, Register mdp,
286                                       Register reg2, int start_row,
287                                       Label& done, bool is_virtual_call);
288   void record_item_in_profile_helper(Register item, Register mdp,
289                                      Register reg2, int start_row, Label& done, int total_rows,
290                                      OffsetFunction item_offset_fn, OffsetFunction item_count_offset_fn,
291                                      int non_profiled_offset);
292 
293   void update_mdp_by_offset(Register mdp_in, int offset_of_offset);
294   void update_mdp_by_offset(Register mdp_in, Register reg, int offset_of_disp);
295   void update_mdp_by_constant(Register mdp_in, int constant);
296   void update_mdp_for_ret(Register return_bci);
297 
298   void profile_taken_branch(Register mdp, Register bumped_count);
299   void profile_not_taken_branch(Register mdp, bool acmp = false);
300   void profile_call(Register mdp);
301   void profile_final_call(Register mdp);
302   void profile_virtual_call(Register receiver, Register mdp,
303                             Register scratch2,
304                             bool receiver_can_be_null = false);
305   void profile_ret(Register return_bci, Register mdp);
306   void profile_null_seen(Register mdp);
307   void profile_typecheck(Register mdp, Register klass, Register scratch);
308   void profile_typecheck_failed(Register mdp);
309   void profile_switch_default(Register mdp);
310   void profile_switch_case(Register index_in_scratch, Register mdp,
311                            Register scratch2);
312   void profile_array(Register mdp, Register array, Register tmp);
313   void profile_element(Register mdp, Register element, Register tmp);
314   void profile_acmp(Register mdp, Register left, Register right, Register tmp);
315 
316   // Debugging
317   // only if +VerifyOops && state == atos
318 #define interp_verify_oop(reg, state) _interp_verify_oop(reg, state, __FILE__, __LINE__);
319   void _interp_verify_oop(Register reg, TosState state, const char* file, int line);
320   // only if +VerifyFPU  && (state == ftos || state == dtos)
321   void verify_FPU(int stack_depth, TosState state = ftos);
322 
323   typedef enum { NotifyJVMTI, SkipNotifyJVMTI } NotifyMethodExitMode;
324 
325   // support for jvmti/dtrace
326   void notify_method_entry();
327   void notify_method_exit(TosState state, NotifyMethodExitMode mode);
328 
329  private:
330 
331   Register _locals_register; // register that contains the pointer to the locals
332   Register _bcp_register; // register that contains the bcp
333 
334  public:
< prev index next >