src/share/vm/shark/sharkTopLevelBlock.hpp - platform/external/jetbrains/jdk8u_hotspot - Git at Google

 /*
  * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
  * Copyright 2008, 2009, 2010 Red Hat, Inc.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  *
  */

 #ifndef SHARE_VM_SHARK_SHARKTOPLEVELBLOCK_HPP
 #define SHARE_VM_SHARK_SHARKTOPLEVELBLOCK_HPP

 #include "ci/ciStreams.hpp"
 #include "ci/ciType.hpp"
 #include "ci/ciTypeFlow.hpp"
 #include "interpreter/bytecodes.hpp"
 #include "memory/allocation.hpp"
 #include "shark/llvmHeaders.hpp"
 #include "shark/sharkBlock.hpp"
 #include "shark/sharkBuilder.hpp"
 #include "shark/sharkFunction.hpp"
 #include "shark/sharkState.hpp"
 #include "shark/sharkValue.hpp"

 class SharkTopLevelBlock : public SharkBlock {
  public:
   SharkTopLevelBlock(SharkFunction* function, ciTypeFlow::Block* ciblock)
     : SharkBlock(function),
       _function(function),
       _ciblock(ciblock),
       _entered(false),
       _has_trap(false),
       _needs_phis(false),
       _entry_state(NULL),
       _entry_block(NULL) {}

  private:
   SharkFunction*     _function;
   ciTypeFlow::Block* _ciblock;

  public:
   SharkFunction* function() const {
     return _function;
   }
   ciTypeFlow::Block* ciblock() const {
     return _ciblock;
   }

   // Function properties
  public:
   SharkStack* stack() const {
     return function()->stack();
   }

   // Typeflow properties
  public:
   int index() const {
     return ciblock()->pre_order();
   }
   bool is_backedge_copy() const {
     return ciblock()->is_backedge_copy();
   }
   int stack_depth_at_entry() const {
     return ciblock()->stack_size();
   }
   ciType* local_type_at_entry(int index) const {
     return ciblock()->local_type_at(index);
   }
   ciType* stack_type_at_entry(int slot) const {
     return ciblock()->stack_type_at(slot);
   }
   int start() const {
     return ciblock()->start();
   }
   int limit() const {
     return ciblock()->limit();
   }
   bool falls_through() const {
     return ciblock()->control() == ciBlock::fall_through_bci;
   }
   int num_successors() const {
     return ciblock()->successors()->length();
   }
   SharkTopLevelBlock* successor(int index) const {
     return function()->block(ciblock()->successors()->at(index)->pre_order());
   }
   SharkTopLevelBlock* bci_successor(int bci) const;

   // Exceptions
  private:
   GrowableArray<ciExceptionHandler*>* _exc_handlers;
   GrowableArray<SharkTopLevelBlock*>* _exceptions;

  private:
   void compute_exceptions();

  private:
   int num_exceptions() const {
     return _exc_handlers->length();
   }
   ciExceptionHandler* exc_handler(int index) const {
     return _exc_handlers->at(index);
   }
   SharkTopLevelBlock* exception(int index) const {
     return _exceptions->at(index);
   }

   // Traps
  private:
   bool _has_trap;
   int  _trap_request;
   int  _trap_bci;

   void set_trap(int trap_request, int trap_bci) {
     assert(!has_trap(), "shouldn't have");
     _has_trap     = true;
     _trap_request = trap_request;
     _trap_bci     = trap_bci;
   }

  private:
   bool has_trap() {
     return _has_trap;
   }
   int trap_request() {
     assert(has_trap(), "should have");
     return _trap_request;
   }
   int trap_bci() {
     assert(has_trap(), "should have");
     return _trap_bci;
   }

  private:
   void scan_for_traps();

  private:
   bool static_field_ok_in_clinit(ciField* field);

   // Entry state
  private:
   bool _entered;
   bool _needs_phis;

  public:
   bool entered() const {
     return _entered;
   }
   bool needs_phis() const {
     return _needs_phis;
   }

  private:
   void enter(SharkTopLevelBlock* predecessor, bool is_exception);

  public:
   void enter() {
     enter(NULL, false);
   }

  private:
   SharkState* _entry_state;

  private:
   SharkState* entry_state();

  private:
   llvm::BasicBlock* _entry_block;

  public:
   llvm::BasicBlock* entry_block() const {
     return _entry_block;
   }

  public:
   void initialize();

  public:
   void add_incoming(SharkState* incoming_state);

   // Method
  public:
   llvm::Value* method() {
     return current_state()->method();
   }

   // Temporary oop storage
  public:
   void set_oop_tmp(llvm::Value* value) {
     assert(value, "value must be non-NULL (will be reset by get_oop_tmp)");
     assert(!current_state()->oop_tmp(), "oop_tmp gets and sets must match");
     current_state()->set_oop_tmp(value);
   }
   llvm::Value* get_oop_tmp() {
     llvm::Value* value = current_state()->oop_tmp();
     assert(value, "oop_tmp gets and sets must match");
     current_state()->set_oop_tmp(NULL);
     return value;
   }

   // Cache and decache
  private:
   void decache_for_Java_call(ciMethod* callee);
   void cache_after_Java_call(ciMethod* callee);
   void decache_for_VM_call();
   void cache_after_VM_call();
   void decache_for_trap();

   // Monitors
  private:
   int num_monitors() {
     return current_state()->num_monitors();
   }
   int set_num_monitors(int num_monitors) {
     current_state()->set_num_monitors(num_monitors);
   }

   // Code generation
  public:
   void emit_IR();

   // Branch helpers
  private:
   void do_branch(int successor_index);

   // Zero checks
  private:
   void do_zero_check(SharkValue* value);
   void zero_check_value(SharkValue* value, llvm::BasicBlock* continue_block);

  public:
   void do_deferred_zero_check(SharkValue*       value,
                               int               bci,
                               SharkState*       saved_state,
                               llvm::BasicBlock* continue_block);
   // Exceptions
  private:
   llvm::Value* pending_exception_address() const {
     return builder()->CreateAddressOfStructEntry(
       thread(), Thread::pending_exception_offset(),
       llvm::PointerType::getUnqual(SharkType::oop_type()),
       "pending_exception_addr");
   }
   llvm::LoadInst* get_pending_exception() const {
     return builder()->CreateLoad(
       pending_exception_address(), "pending_exception");
   }
   void clear_pending_exception() const {
     builder()->CreateStore(LLVMValue::null(), pending_exception_address());
   }
  public:
   enum ExceptionActionMask {
     // The actual bitmasks that things test against
     EAM_CHECK         = 1, // whether to check for pending exceptions
     EAM_HANDLE        = 2, // whether to attempt to handle pending exceptions
     EAM_MONITOR_FUDGE = 4, // whether the monitor count needs adjusting

     // More convenient values for passing
     EX_CHECK_NONE     = 0,
     EX_CHECK_NO_CATCH = EAM_CHECK,
     EX_CHECK_FULL     = EAM_CHECK | EAM_HANDLE
   };
   void check_pending_exception(int action);
   void handle_exception(llvm::Value* exception, int action);
   void marshal_exception_fast(int num_options);
   void marshal_exception_slow(int num_options);
   llvm::BasicBlock* handler_for_exception(int index);

   // VM calls
  private:
   llvm::CallInst* call_vm(llvm::Value*  callee,
                           llvm::Value** args_start,
                           llvm::Value** args_end,
                           int           exception_action) {
     decache_for_VM_call();
     stack()->CreateSetLastJavaFrame();
     llvm::CallInst *res = builder()->CreateCall(callee, llvm::makeArrayRef(args_start, args_end));
     stack()->CreateResetLastJavaFrame();
     cache_after_VM_call();
     if (exception_action & EAM_CHECK) {
       check_pending_exception(exception_action);
       current_state()->set_has_safepointed(true);
     }
     return res;
   }

  public:
   llvm::CallInst* call_vm(llvm::Value* callee,
                           int          exception_action) {
     llvm::Value *args[] = {thread()};
     return call_vm(callee, args, args + 1, exception_action);
   }
   llvm::CallInst* call_vm(llvm::Value* callee,
                           llvm::Value* arg1,
                           int          exception_action) {
     llvm::Value *args[] = {thread(), arg1};
     return call_vm(callee, args, args + 2, exception_action);
   }
   llvm::CallInst* call_vm(llvm::Value* callee,
                           llvm::Value* arg1,
                           llvm::Value* arg2,
                           int          exception_action) {
     llvm::Value *args[] = {thread(), arg1, arg2};
     return call_vm(callee, args, args + 3, exception_action);
   }
   llvm::CallInst* call_vm(llvm::Value* callee,
                           llvm::Value* arg1,
                           llvm::Value* arg2,
                           llvm::Value* arg3,
                           int          exception_action) {
     llvm::Value *args[] = {thread(), arg1, arg2, arg3};
     return call_vm(callee, args, args + 4, exception_action);
   }

   // VM call oop return handling
  private:
   llvm::LoadInst* get_vm_result() const {
     llvm::Value *addr = builder()->CreateAddressOfStructEntry(
       thread(), JavaThread::vm_result_offset(),
       llvm::PointerType::getUnqual(SharkType::oop_type()),
       "vm_result_addr");
     llvm::LoadInst *result = builder()->CreateLoad(addr, "vm_result");
     builder()->CreateStore(LLVMValue::null(), addr);
     return result;
   }

   // Synchronization
  private:
   void acquire_lock(llvm::Value* lockee, int exception_action);
   void release_lock(int exception_action);

  public:
   void acquire_method_lock();

   // Bounds checks
  private:
   void check_bounds(SharkValue* array, SharkValue* index);

   // Safepoints
  private:
   void maybe_add_safepoint();
   void maybe_add_backedge_safepoint();

   // Loop safepoint removal
  private:
   bool _can_reach_visited;

   bool can_reach(SharkTopLevelBlock* other);
   bool can_reach_helper(SharkTopLevelBlock* other);

   // Traps
  private:
   llvm::BasicBlock* make_trap(int trap_bci, int trap_request);
   void do_trap(int trap_request);

   // Returns
  private:
   void call_register_finalizer(llvm::Value* receiver);
   void handle_return(BasicType type, llvm::Value* exception);

   // arraylength
  private:
   void do_arraylength();

   // *aload and *astore
  private:
   void do_aload(BasicType basic_type);
   void do_astore(BasicType basic_type);

   // *return and athrow
  private:
   void do_return(BasicType type);
   void do_athrow();

   // goto*
  private:
   void do_goto();

   // jsr* and ret
  private:
   void do_jsr();
   void do_ret();

   // if*
  private:
   void do_if_helper(llvm::ICmpInst::Predicate p,
                     llvm::Value*              b,
                     llvm::Value*              a,
                     SharkState*               if_taken_state,
                     SharkState*               not_taken_state);
   void do_if(llvm::ICmpInst::Predicate p, SharkValue* b, SharkValue* a);

   // tableswitch and lookupswitch
  private:
   void do_switch();

   // invoke*
  private:
   ciMethod* improve_virtual_call(ciMethod*        caller,
                                  ciInstanceKlass* klass,
                                  ciMethod*        dest_method,
                                  ciType*          receiver_type);
   llvm::Value* get_direct_callee(ciMethod* method);
   llvm::Value* get_virtual_callee(SharkValue* receiver, int vtable_index);
   llvm::Value* get_interface_callee(SharkValue* receiver, ciMethod* method);

   void do_call();

   // checkcast and instanceof
  private:
   bool static_subtype_check(ciKlass* check_klass, ciKlass* object_klass);
   void do_full_instance_check(ciKlass* klass);
   void do_trapping_instance_check(ciKlass* klass);

   void do_instance_check();
   bool maybe_do_instanceof_if();

   // new and *newarray
  private:
   void do_new();
   void do_newarray();
   void do_anewarray();
   void do_multianewarray();

   // monitorenter and monitorexit
  private:
   void do_monitorenter();
   void do_monitorexit();
 };

 #endif // SHARE_VM_SHARK_SHARKTOPLEVELBLOCK_HPP
	/*
	* Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright 2008, 2009, 2010 Red Hat, Inc.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*
	*/

	#ifndef SHARE_VM_SHARK_SHARKTOPLEVELBLOCK_HPP
	#define SHARE_VM_SHARK_SHARKTOPLEVELBLOCK_HPP

	#include "ci/ciStreams.hpp"
	#include "ci/ciType.hpp"
	#include "ci/ciTypeFlow.hpp"
	#include "interpreter/bytecodes.hpp"
	#include "memory/allocation.hpp"
	#include "shark/llvmHeaders.hpp"
	#include "shark/sharkBlock.hpp"
	#include "shark/sharkBuilder.hpp"
	#include "shark/sharkFunction.hpp"
	#include "shark/sharkState.hpp"
	#include "shark/sharkValue.hpp"

	class SharkTopLevelBlock : public SharkBlock {
	public:
	SharkTopLevelBlock(SharkFunction* function, ciTypeFlow::Block* ciblock)
	: SharkBlock(function),
	_function(function),
	_ciblock(ciblock),
	_entered(false),
	_has_trap(false),
	_needs_phis(false),
	_entry_state(NULL),
	_entry_block(NULL) {}

	private:
	SharkFunction* _function;
	ciTypeFlow::Block* _ciblock;

	public:
	SharkFunction* function() const {
	return _function;
	}
	ciTypeFlow::Block* ciblock() const {
	return _ciblock;
	}

	// Function properties
	public:
	SharkStack* stack() const {
	return function()->stack();
	}

	// Typeflow properties
	public:
	int index() const {
	return ciblock()->pre_order();
	}
	bool is_backedge_copy() const {
	return ciblock()->is_backedge_copy();
	}
	int stack_depth_at_entry() const {
	return ciblock()->stack_size();
	}
	ciType* local_type_at_entry(int index) const {
	return ciblock()->local_type_at(index);
	}
	ciType* stack_type_at_entry(int slot) const {
	return ciblock()->stack_type_at(slot);
	}
	int start() const {
	return ciblock()->start();
	}
	int limit() const {
	return ciblock()->limit();
	}
	bool falls_through() const {
	return ciblock()->control() == ciBlock::fall_through_bci;
	}
	int num_successors() const {
	return ciblock()->successors()->length();
	}
	SharkTopLevelBlock* successor(int index) const {
	return function()->block(ciblock()->successors()->at(index)->pre_order());
	}
	SharkTopLevelBlock* bci_successor(int bci) const;

	// Exceptions
	private:
	GrowableArray<ciExceptionHandler> _exc_handlers;
	GrowableArray<SharkTopLevelBlock> _exceptions;

	private:
	void compute_exceptions();

	private:
	int num_exceptions() const {
	return _exc_handlers->length();
	}
	ciExceptionHandler* exc_handler(int index) const {
	return _exc_handlers->at(index);
	}
	SharkTopLevelBlock* exception(int index) const {
	return _exceptions->at(index);
	}

	// Traps
	private:
	bool _has_trap;
	int _trap_request;
	int _trap_bci;

	void set_trap(int trap_request, int trap_bci) {
	assert(!has_trap(), "shouldn't have");
	_has_trap = true;
	_trap_request = trap_request;
	_trap_bci = trap_bci;
	}

	private:
	bool has_trap() {
	return _has_trap;
	}
	int trap_request() {
	assert(has_trap(), "should have");
	return _trap_request;
	}
	int trap_bci() {
	assert(has_trap(), "should have");
	return _trap_bci;
	}

	private:
	void scan_for_traps();

	private:
	bool static_field_ok_in_clinit(ciField* field);

	// Entry state
	private:
	bool _entered;
	bool _needs_phis;

	public:
	bool entered() const {
	return _entered;
	}
	bool needs_phis() const {
	return _needs_phis;
	}

	private:
	void enter(SharkTopLevelBlock* predecessor, bool is_exception);

	public:
	void enter() {
	enter(NULL, false);
	}

	private:
	SharkState* _entry_state;

	private:
	SharkState* entry_state();

	private:
	llvm::BasicBlock* _entry_block;

	public:
	llvm::BasicBlock* entry_block() const {
	return _entry_block;
	}

	public:
	void initialize();

	public:
	void add_incoming(SharkState* incoming_state);

	// Method
	public:
	llvm::Value* method() {
	return current_state()->method();
	}

	// Temporary oop storage
	public:
	void set_oop_tmp(llvm::Value* value) {
	assert(value, "value must be non-NULL (will be reset by get_oop_tmp)");
	assert(!current_state()->oop_tmp(), "oop_tmp gets and sets must match");
	current_state()->set_oop_tmp(value);
	}
	llvm::Value* get_oop_tmp() {
	llvm::Value* value = current_state()->oop_tmp();
	assert(value, "oop_tmp gets and sets must match");
	current_state()->set_oop_tmp(NULL);
	return value;
	}

	// Cache and decache
	private:
	void decache_for_Java_call(ciMethod* callee);
	void cache_after_Java_call(ciMethod* callee);
	void decache_for_VM_call();
	void cache_after_VM_call();
	void decache_for_trap();

	// Monitors
	private:
	int num_monitors() {
	return current_state()->num_monitors();
	}
	int set_num_monitors(int num_monitors) {
	current_state()->set_num_monitors(num_monitors);
	}

	// Code generation
	public:
	void emit_IR();

	// Branch helpers
	private:
	void do_branch(int successor_index);

	// Zero checks
	private:
	void do_zero_check(SharkValue* value);
	void zero_check_value(SharkValue* value, llvm::BasicBlock* continue_block);

	public:
	void do_deferred_zero_check(SharkValue* value,
	int bci,
	SharkState* saved_state,
	llvm::BasicBlock* continue_block);
	// Exceptions
	private:
	llvm::Value* pending_exception_address() const {
	return builder()->CreateAddressOfStructEntry(
	thread(), Thread::pending_exception_offset(),
	llvm::PointerType::getUnqual(SharkType::oop_type()),
	"pending_exception_addr");
	}
	llvm::LoadInst* get_pending_exception() const {
	return builder()->CreateLoad(
	pending_exception_address(), "pending_exception");
	}
	void clear_pending_exception() const {
	builder()->CreateStore(LLVMValue::null(), pending_exception_address());
	}
	public:
	enum ExceptionActionMask {
	// The actual bitmasks that things test against
	EAM_CHECK = 1, // whether to check for pending exceptions
	EAM_HANDLE = 2, // whether to attempt to handle pending exceptions
	EAM_MONITOR_FUDGE = 4, // whether the monitor count needs adjusting

	// More convenient values for passing
	EX_CHECK_NONE = 0,
	EX_CHECK_NO_CATCH = EAM_CHECK,
	EX_CHECK_FULL = EAM_CHECK \| EAM_HANDLE
	};
	void check_pending_exception(int action);
	void handle_exception(llvm::Value* exception, int action);
	void marshal_exception_fast(int num_options);
	void marshal_exception_slow(int num_options);
	llvm::BasicBlock* handler_for_exception(int index);

	// VM calls
	private:
	llvm::CallInst* call_vm(llvm::Value* callee,
	llvm::Value** args_start,
	llvm::Value** args_end,
	int exception_action) {
	decache_for_VM_call();
	stack()->CreateSetLastJavaFrame();
	llvm::CallInst *res = builder()->CreateCall(callee, llvm::makeArrayRef(args_start, args_end));
	stack()->CreateResetLastJavaFrame();
	cache_after_VM_call();
	if (exception_action & EAM_CHECK) {
	check_pending_exception(exception_action);
	current_state()->set_has_safepointed(true);
	}
	return res;
	}

	public:
	llvm::CallInst* call_vm(llvm::Value* callee,
	int exception_action) {
	llvm::Value *args[] = {thread()};
	return call_vm(callee, args, args + 1, exception_action);
	}
	llvm::CallInst* call_vm(llvm::Value* callee,
	llvm::Value* arg1,
	int exception_action) {
	llvm::Value *args[] = {thread(), arg1};
	return call_vm(callee, args, args + 2, exception_action);
	}
	llvm::CallInst* call_vm(llvm::Value* callee,
	llvm::Value* arg1,
	llvm::Value* arg2,
	int exception_action) {
	llvm::Value *args[] = {thread(), arg1, arg2};
	return call_vm(callee, args, args + 3, exception_action);
	}
	llvm::CallInst* call_vm(llvm::Value* callee,
	llvm::Value* arg1,
	llvm::Value* arg2,
	llvm::Value* arg3,
	int exception_action) {
	llvm::Value *args[] = {thread(), arg1, arg2, arg3};
	return call_vm(callee, args, args + 4, exception_action);
	}

	// VM call oop return handling
	private:
	llvm::LoadInst* get_vm_result() const {
	llvm::Value *addr = builder()->CreateAddressOfStructEntry(
	thread(), JavaThread::vm_result_offset(),
	llvm::PointerType::getUnqual(SharkType::oop_type()),
	"vm_result_addr");
	llvm::LoadInst *result = builder()->CreateLoad(addr, "vm_result");
	builder()->CreateStore(LLVMValue::null(), addr);
	return result;
	}

	// Synchronization
	private:
	void acquire_lock(llvm::Value* lockee, int exception_action);
	void release_lock(int exception_action);

	public:
	void acquire_method_lock();

	// Bounds checks
	private:
	void check_bounds(SharkValue* array, SharkValue* index);

	// Safepoints
	private:
	void maybe_add_safepoint();
	void maybe_add_backedge_safepoint();

	// Loop safepoint removal
	private:
	bool _can_reach_visited;

	bool can_reach(SharkTopLevelBlock* other);
	bool can_reach_helper(SharkTopLevelBlock* other);

	// Traps
	private:
	llvm::BasicBlock* make_trap(int trap_bci, int trap_request);
	void do_trap(int trap_request);

	// Returns
	private:
	void call_register_finalizer(llvm::Value* receiver);
	void handle_return(BasicType type, llvm::Value* exception);

	// arraylength
	private:
	void do_arraylength();

	// aload and astore
	private:
	void do_aload(BasicType basic_type);
	void do_astore(BasicType basic_type);

	// *return and athrow
	private:
	void do_return(BasicType type);
	void do_athrow();

	// goto*
	private:
	void do_goto();

	// jsr* and ret
	private:
	void do_jsr();
	void do_ret();

	// if*
	private:
	void do_if_helper(llvm::ICmpInst::Predicate p,
	llvm::Value* b,
	llvm::Value* a,
	SharkState* if_taken_state,
	SharkState* not_taken_state);
	void do_if(llvm::ICmpInst::Predicate p, SharkValue* b, SharkValue* a);

	// tableswitch and lookupswitch
	private:
	void do_switch();

	// invoke*
	private:
	ciMethod* improve_virtual_call(ciMethod* caller,
	ciInstanceKlass* klass,
	ciMethod* dest_method,
	ciType* receiver_type);
	llvm::Value* get_direct_callee(ciMethod* method);
	llvm::Value* get_virtual_callee(SharkValue* receiver, int vtable_index);
	llvm::Value* get_interface_callee(SharkValue* receiver, ciMethod* method);

	void do_call();

	// checkcast and instanceof
	private:
	bool static_subtype_check(ciKlass* check_klass, ciKlass* object_klass);
	void do_full_instance_check(ciKlass* klass);
	void do_trapping_instance_check(ciKlass* klass);

	void do_instance_check();
	bool maybe_do_instanceof_if();

	// new and *newarray
	private:
	void do_new();
	void do_newarray();
	void do_anewarray();
	void do_multianewarray();

	// monitorenter and monitorexit
	private:
	void do_monitorenter();
	void do_monitorexit();
	};

	#endif // SHARE_VM_SHARK_SHARKTOPLEVELBLOCK_HPP