src/share/vm/interpreter/templateTable.hpp - platform/external/jetbrains/jdk8u_hotspot - Git at Google

 /*
  * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
  * 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_INTERPRETER_TEMPLATETABLE_HPP
 #define SHARE_VM_INTERPRETER_TEMPLATETABLE_HPP

 #include "interpreter/bytecodes.hpp"
 #include "memory/allocation.hpp"
 #include "runtime/frame.hpp"
 #if defined INTERP_MASM_MD_HPP
 # include INTERP_MASM_MD_HPP
 #elif defined TARGET_ARCH_x86
 # include "interp_masm_x86.hpp"
 #elif defined TARGET_ARCH_MODEL_sparc
 # include "interp_masm_sparc.hpp"
 #elif defined TARGET_ARCH_MODEL_zero
 # include "interp_masm_zero.hpp"
 #elif defined TARGET_ARCH_MODEL_ppc_64
 # include "interp_masm_ppc_64.hpp"
 #endif

 #ifndef CC_INTERP
 // All the necessary definitions used for (bytecode) template generation. Instead of
 // spreading the implementation functionality for each bytecode in the interpreter
 // and the snippet generator, a template is assigned to each bytecode which can be
 // used to generate the bytecode's implementation if needed.


 // A Template describes the properties of a code template for a given bytecode
 // and provides a generator to generate the code template.

 class Template VALUE_OBJ_CLASS_SPEC {
  private:
   enum Flags {
     uses_bcp_bit,                                // set if template needs the bcp pointing to bytecode
     does_dispatch_bit,                           // set if template dispatches on its own
     calls_vm_bit,                                // set if template calls the vm
     wide_bit                                     // set if template belongs to a wide instruction
   };

   typedef void (*generator)(int arg);

   int       _flags;                              // describes interpreter template properties (bcp unknown)
   TosState  _tos_in;                             // tos cache state before template execution
   TosState  _tos_out;                            // tos cache state after  template execution
   generator _gen;                                // template code generator
   int       _arg;                                // argument for template code generator

   void      initialize(int flags, TosState tos_in, TosState tos_out, generator gen, int arg);

   friend class TemplateTable;

  public:
   Bytecodes::Code bytecode() const;
   bool      is_valid() const                     { return _gen != NULL; }
   bool      uses_bcp() const                     { return (_flags & (1 << uses_bcp_bit     )) != 0; }
   bool      does_dispatch() const                { return (_flags & (1 << does_dispatch_bit)) != 0; }
   bool      calls_vm() const                     { return (_flags & (1 << calls_vm_bit     )) != 0; }
   bool      is_wide() const                      { return (_flags & (1 << wide_bit         )) != 0; }
   TosState  tos_in() const                       { return _tos_in; }
   TosState  tos_out() const                      { return _tos_out; }
   void      generate(InterpreterMacroAssembler* masm);
 };


 // The TemplateTable defines all Templates and provides accessor functions
 // to get the template for a given bytecode.

 class TemplateTable: AllStatic {
  public:
   enum Operation { add, sub, mul, div, rem, _and, _or, _xor, shl, shr, ushr };
   enum Condition { equal, not_equal, less, less_equal, greater, greater_equal };
   enum CacheByte { f1_byte = 1, f2_byte = 2 };  // byte_no codes

  private:
   static bool            _is_initialized;        // true if TemplateTable has been initialized
   static Template        _template_table     [Bytecodes::number_of_codes];
   static Template        _template_table_wide[Bytecodes::number_of_codes];

   static Template*       _desc;                  // the current template to be generated
   static Bytecodes::Code bytecode()              { return _desc->bytecode(); }

   static BarrierSet*     _bs;                    // Cache the barrier set.
  public:
   //%note templates_1
   static InterpreterMacroAssembler* _masm;       // the assembler used when generating templates

  private:

   // special registers
   static inline Address at_bcp(int offset);

   // helpers
   static void unimplemented_bc();
   static void patch_bytecode(Bytecodes::Code bc, Register bc_reg,
                              Register temp_reg, bool load_bc_into_bc_reg = true, int byte_no = -1);

   // C calls
   static void call_VM(Register oop_result, address entry_point);
   static void call_VM(Register oop_result, address entry_point, Register arg_1);
   static void call_VM(Register oop_result, address entry_point, Register arg_1, Register arg_2);
   static void call_VM(Register oop_result, address entry_point, Register arg_1, Register arg_2, Register arg_3);

   // these overloadings are not presently used on SPARC:
   static void call_VM(Register oop_result, Register last_java_sp, address entry_point);
   static void call_VM(Register oop_result, Register last_java_sp, address entry_point, Register arg_1);
   static void call_VM(Register oop_result, Register last_java_sp, address entry_point, Register arg_1, Register arg_2);
   static void call_VM(Register oop_result, Register last_java_sp, address entry_point, Register arg_1, Register arg_2, Register arg_3);

   // bytecodes
   static void nop();

   static void aconst_null();
   static void iconst(int value);
   static void lconst(int value);
   static void fconst(int value);
   static void dconst(int value);

   static void bipush();
   static void sipush();
   static void ldc(bool wide);
   static void ldc2_w();
   static void fast_aldc(bool wide);

   static void locals_index(Register reg, int offset = 1);
   static void iload();
   static void fast_iload();
   static void fast_iload2();
   static void fast_icaload();
   static void lload();
   static void fload();
   static void dload();
   static void aload();

   static void locals_index_wide(Register reg);
   static void wide_iload();
   static void wide_lload();
   static void wide_fload();
   static void wide_dload();
   static void wide_aload();

   static void iaload();
   static void laload();
   static void faload();
   static void daload();
   static void aaload();
   static void baload();
   static void caload();
   static void saload();

   static void iload(int n);
   static void lload(int n);
   static void fload(int n);
   static void dload(int n);
   static void aload(int n);
   static void aload_0();

   static void istore();
   static void lstore();
   static void fstore();
   static void dstore();
   static void astore();

   static void wide_istore();
   static void wide_lstore();
   static void wide_fstore();
   static void wide_dstore();
   static void wide_astore();

   static void iastore();
   static void lastore();
   static void fastore();
   static void dastore();
   static void aastore();
   static void bastore();
   static void castore();
   static void sastore();

   static void istore(int n);
   static void lstore(int n);
   static void fstore(int n);
   static void dstore(int n);
   static void astore(int n);

   static void pop();
   static void pop2();
   static void dup();
   static void dup_x1();
   static void dup_x2();
   static void dup2();
   static void dup2_x1();
   static void dup2_x2();
   static void swap();

   static void iop2(Operation op);
   static void lop2(Operation op);
   static void fop2(Operation op);
   static void dop2(Operation op);

   static void idiv();
   static void irem();

   static void lmul();
   static void ldiv();
   static void lrem();
   static void lshl();
   static void lshr();
   static void lushr();

   static void ineg();
   static void lneg();
   static void fneg();
   static void dneg();

   static void iinc();
   static void wide_iinc();
   static void convert();
   static void lcmp();

   static void float_cmp (bool is_float, int unordered_result);
   static void float_cmp (int unordered_result);
   static void double_cmp(int unordered_result);

   static void count_calls(Register method, Register temp);
   static void branch(bool is_jsr, bool is_wide);
   static void if_0cmp   (Condition cc);
   static void if_icmp   (Condition cc);
   static void if_nullcmp(Condition cc);
   static void if_acmp   (Condition cc);

   static void _goto();
   static void jsr();
   static void ret();
   static void wide_ret();

   static void goto_w();
   static void jsr_w();

   static void tableswitch();
   static void lookupswitch();
   static void fast_linearswitch();
   static void fast_binaryswitch();

   static void _return(TosState state);

   static void resolve_cache_and_index(int byte_no,       // one of 1,2,11
                                       Register cache,    // output for CP cache
                                       Register index,    // output for CP index
                                       size_t index_size); // one of 1,2,4
   static void load_invoke_cp_cache_entry(int byte_no,
                                          Register method,
                                          Register itable_index,
                                          Register flags,
                                          bool is_invokevirtual,
                                          bool is_virtual_final,
                                          bool is_invokedynamic);
   static void load_field_cp_cache_entry(Register obj,
                                         Register cache,
                                         Register index,
                                         Register offset,
                                         Register flags,
                                         bool is_static);
   static void invokevirtual(int byte_no);
   static void invokespecial(int byte_no);
   static void invokestatic(int byte_no);
   static void invokeinterface(int byte_no);
   static void invokedynamic(int byte_no);
   static void invokehandle(int byte_no);
   static void fast_invokevfinal(int byte_no);

   static void getfield_or_static(int byte_no, bool is_static);
   static void putfield_or_static(int byte_no, bool is_static);
   static void getfield(int byte_no);
   static void putfield(int byte_no);
   static void getstatic(int byte_no);
   static void putstatic(int byte_no);
   static void pop_and_check_object(Register obj);

   static void _new();
   static void newarray();
   static void anewarray();
   static void arraylength();
   static void checkcast();
   static void instanceof();

   static void athrow();

   static void monitorenter();
   static void monitorexit();

   static void wide();
   static void multianewarray();

   static void fast_xaccess(TosState state);
   static void fast_accessfield(TosState state);
   static void fast_storefield(TosState state);

   static void _breakpoint();

   static void shouldnotreachhere();

   // jvmti support
   static void jvmti_post_field_access(Register cache, Register index, bool is_static, bool has_tos);
   static void jvmti_post_field_mod(Register cache, Register index, bool is_static);
   static void jvmti_post_fast_field_mod();

   // debugging of TemplateGenerator
   static void transition(TosState tos_in, TosState tos_out);// checks if in/out states expected by template generator correspond to table entries

   // initialization helpers
   static void def(Bytecodes::Code code, int flags, TosState in, TosState out, void (*gen)(            ), char filler );
   static void def(Bytecodes::Code code, int flags, TosState in, TosState out, void (*gen)(int arg     ), int arg     );
  static void def(Bytecodes::Code code, int flags, TosState in, TosState out, void (*gen)(bool arg    ), bool arg    );
   static void def(Bytecodes::Code code, int flags, TosState in, TosState out, void (*gen)(TosState tos), TosState tos);
   static void def(Bytecodes::Code code, int flags, TosState in, TosState out, void (*gen)(Operation op), Operation op);
   static void def(Bytecodes::Code code, int flags, TosState in, TosState out, void (*gen)(Condition cc), Condition cc);

   friend class Template;

   // InterpreterMacroAssembler::is_a(), etc., need TemplateTable::call_VM().
   friend class InterpreterMacroAssembler;

  public:
   // Initialization
   static void initialize();
   static void pd_initialize();

   // Templates
   static Template* template_for     (Bytecodes::Code code)  { Bytecodes::check     (code); return &_template_table     [code]; }
   static Template* template_for_wide(Bytecodes::Code code)  { Bytecodes::wide_check(code); return &_template_table_wide[code]; }

   // Platform specifics
 #if defined TEMPLATETABLE_MD_HPP
 # include TEMPLATETABLE_MD_HPP
 #elif defined TARGET_ARCH_MODEL_x86_32
 # include "templateTable_x86_32.hpp"
 #elif defined TARGET_ARCH_MODEL_x86_64
 # include "templateTable_x86_64.hpp"
 #elif defined TARGET_ARCH_MODEL_sparc
 # include "templateTable_sparc.hpp"
 #elif defined TARGET_ARCH_MODEL_zero
 # include "templateTable_zero.hpp"
 #elif defined TARGET_ARCH_MODEL_ppc_64
 # include "templateTable_ppc_64.hpp"
 #endif

 };
 #endif /* !CC_INTERP */

 #endif // SHARE_VM_INTERPRETER_TEMPLATETABLE_HPP
	/*
	* Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
	* 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_INTERPRETER_TEMPLATETABLE_HPP
	#define SHARE_VM_INTERPRETER_TEMPLATETABLE_HPP

	#include "interpreter/bytecodes.hpp"
	#include "memory/allocation.hpp"
	#include "runtime/frame.hpp"
	#if defined INTERP_MASM_MD_HPP
	# include INTERP_MASM_MD_HPP
	#elif defined TARGET_ARCH_x86
	# include "interp_masm_x86.hpp"
	#elif defined TARGET_ARCH_MODEL_sparc
	# include "interp_masm_sparc.hpp"
	#elif defined TARGET_ARCH_MODEL_zero
	# include "interp_masm_zero.hpp"
	#elif defined TARGET_ARCH_MODEL_ppc_64
	# include "interp_masm_ppc_64.hpp"
	#endif

	#ifndef CC_INTERP
	// All the necessary definitions used for (bytecode) template generation. Instead of
	// spreading the implementation functionality for each bytecode in the interpreter
	// and the snippet generator, a template is assigned to each bytecode which can be
	// used to generate the bytecode's implementation if needed.


	// A Template describes the properties of a code template for a given bytecode
	// and provides a generator to generate the code template.

	class Template VALUE_OBJ_CLASS_SPEC {
	private:
	enum Flags {
	uses_bcp_bit, // set if template needs the bcp pointing to bytecode
	does_dispatch_bit, // set if template dispatches on its own
	calls_vm_bit, // set if template calls the vm
	wide_bit // set if template belongs to a wide instruction
	};

	typedef void (*generator)(int arg);

	int _flags; // describes interpreter template properties (bcp unknown)
	TosState _tos_in; // tos cache state before template execution
	TosState _tos_out; // tos cache state after template execution
	generator _gen; // template code generator
	int _arg; // argument for template code generator

	void initialize(int flags, TosState tos_in, TosState tos_out, generator gen, int arg);

	friend class TemplateTable;

	public:
	Bytecodes::Code bytecode() const;
	bool is_valid() const { return _gen != NULL; }
	bool uses_bcp() const { return (_flags & (1 << uses_bcp_bit )) != 0; }
	bool does_dispatch() const { return (_flags & (1 << does_dispatch_bit)) != 0; }
	bool calls_vm() const { return (_flags & (1 << calls_vm_bit )) != 0; }
	bool is_wide() const { return (_flags & (1 << wide_bit )) != 0; }
	TosState tos_in() const { return _tos_in; }
	TosState tos_out() const { return _tos_out; }
	void generate(InterpreterMacroAssembler* masm);
	};


	// The TemplateTable defines all Templates and provides accessor functions
	// to get the template for a given bytecode.

	class TemplateTable: AllStatic {
	public:
	enum Operation { add, sub, mul, div, rem, _and, _or, _xor, shl, shr, ushr };
	enum Condition { equal, not_equal, less, less_equal, greater, greater_equal };
	enum CacheByte { f1_byte = 1, f2_byte = 2 }; // byte_no codes

	private:
	static bool _is_initialized; // true if TemplateTable has been initialized
	static Template _template_table [Bytecodes::number_of_codes];
	static Template _template_table_wide[Bytecodes::number_of_codes];

	static Template* _desc; // the current template to be generated
	static Bytecodes::Code bytecode() { return _desc->bytecode(); }

	static BarrierSet* _bs; // Cache the barrier set.
	public:
	//%note templates_1
	static InterpreterMacroAssembler* _masm; // the assembler used when generating templates

	private:

	// special registers
	static inline Address at_bcp(int offset);

	// helpers
	static void unimplemented_bc();
	static void patch_bytecode(Bytecodes::Code bc, Register bc_reg,
	Register temp_reg, bool load_bc_into_bc_reg = true, int byte_no = -1);

	// C calls
	static void call_VM(Register oop_result, address entry_point);
	static void call_VM(Register oop_result, address entry_point, Register arg_1);
	static void call_VM(Register oop_result, address entry_point, Register arg_1, Register arg_2);
	static void call_VM(Register oop_result, address entry_point, Register arg_1, Register arg_2, Register arg_3);

	// these overloadings are not presently used on SPARC:
	static void call_VM(Register oop_result, Register last_java_sp, address entry_point);
	static void call_VM(Register oop_result, Register last_java_sp, address entry_point, Register arg_1);
	static void call_VM(Register oop_result, Register last_java_sp, address entry_point, Register arg_1, Register arg_2);
	static void call_VM(Register oop_result, Register last_java_sp, address entry_point, Register arg_1, Register arg_2, Register arg_3);

	// bytecodes
	static void nop();

	static void aconst_null();
	static void iconst(int value);
	static void lconst(int value);
	static void fconst(int value);
	static void dconst(int value);

	static void bipush();
	static void sipush();
	static void ldc(bool wide);
	static void ldc2_w();
	static void fast_aldc(bool wide);

	static void locals_index(Register reg, int offset = 1);
	static void iload();
	static void fast_iload();
	static void fast_iload2();
	static void fast_icaload();
	static void lload();
	static void fload();
	static void dload();
	static void aload();

	static void locals_index_wide(Register reg);
	static void wide_iload();
	static void wide_lload();
	static void wide_fload();
	static void wide_dload();
	static void wide_aload();

	static void iaload();
	static void laload();
	static void faload();
	static void daload();
	static void aaload();
	static void baload();
	static void caload();
	static void saload();

	static void iload(int n);
	static void lload(int n);
	static void fload(int n);
	static void dload(int n);
	static void aload(int n);
	static void aload_0();

	static void istore();
	static void lstore();
	static void fstore();
	static void dstore();
	static void astore();

	static void wide_istore();
	static void wide_lstore();
	static void wide_fstore();
	static void wide_dstore();
	static void wide_astore();

	static void iastore();
	static void lastore();
	static void fastore();
	static void dastore();
	static void aastore();
	static void bastore();
	static void castore();
	static void sastore();

	static void istore(int n);
	static void lstore(int n);
	static void fstore(int n);
	static void dstore(int n);
	static void astore(int n);

	static void pop();
	static void pop2();
	static void dup();
	static void dup_x1();
	static void dup_x2();
	static void dup2();
	static void dup2_x1();
	static void dup2_x2();
	static void swap();

	static void iop2(Operation op);
	static void lop2(Operation op);
	static void fop2(Operation op);
	static void dop2(Operation op);

	static void idiv();
	static void irem();

	static void lmul();
	static void ldiv();
	static void lrem();
	static void lshl();
	static void lshr();
	static void lushr();

	static void ineg();
	static void lneg();
	static void fneg();
	static void dneg();

	static void iinc();
	static void wide_iinc();
	static void convert();
	static void lcmp();

	static void float_cmp (bool is_float, int unordered_result);
	static void float_cmp (int unordered_result);
	static void double_cmp(int unordered_result);

	static void count_calls(Register method, Register temp);
	static void branch(bool is_jsr, bool is_wide);
	static void if_0cmp (Condition cc);
	static void if_icmp (Condition cc);
	static void if_nullcmp(Condition cc);
	static void if_acmp (Condition cc);

	static void _goto();
	static void jsr();
	static void ret();
	static void wide_ret();

	static void goto_w();
	static void jsr_w();

	static void tableswitch();
	static void lookupswitch();
	static void fast_linearswitch();
	static void fast_binaryswitch();

	static void _return(TosState state);

	static void resolve_cache_and_index(int byte_no, // one of 1,2,11
	Register cache, // output for CP cache
	Register index, // output for CP index
	size_t index_size); // one of 1,2,4
	static void load_invoke_cp_cache_entry(int byte_no,
	Register method,
	Register itable_index,
	Register flags,
	bool is_invokevirtual,
	bool is_virtual_final,
	bool is_invokedynamic);
	static void load_field_cp_cache_entry(Register obj,
	Register cache,
	Register index,
	Register offset,
	Register flags,
	bool is_static);
	static void invokevirtual(int byte_no);
	static void invokespecial(int byte_no);
	static void invokestatic(int byte_no);
	static void invokeinterface(int byte_no);
	static void invokedynamic(int byte_no);
	static void invokehandle(int byte_no);
	static void fast_invokevfinal(int byte_no);

	static void getfield_or_static(int byte_no, bool is_static);
	static void putfield_or_static(int byte_no, bool is_static);
	static void getfield(int byte_no);
	static void putfield(int byte_no);
	static void getstatic(int byte_no);
	static void putstatic(int byte_no);
	static void pop_and_check_object(Register obj);

	static void _new();
	static void newarray();
	static void anewarray();
	static void arraylength();
	static void checkcast();
	static void instanceof();

	static void athrow();

	static void monitorenter();
	static void monitorexit();

	static void wide();
	static void multianewarray();

	static void fast_xaccess(TosState state);
	static void fast_accessfield(TosState state);
	static void fast_storefield(TosState state);

	static void _breakpoint();

	static void shouldnotreachhere();

	// jvmti support
	static void jvmti_post_field_access(Register cache, Register index, bool is_static, bool has_tos);
	static void jvmti_post_field_mod(Register cache, Register index, bool is_static);
	static void jvmti_post_fast_field_mod();

	// debugging of TemplateGenerator
	static void transition(TosState tos_in, TosState tos_out);// checks if in/out states expected by template generator correspond to table entries

	// initialization helpers
	static void def(Bytecodes::Code code, int flags, TosState in, TosState out, void (*gen)( ), char filler );
	static void def(Bytecodes::Code code, int flags, TosState in, TosState out, void (*gen)(int arg ), int arg );
	static void def(Bytecodes::Code code, int flags, TosState in, TosState out, void (*gen)(bool arg ), bool arg );
	static void def(Bytecodes::Code code, int flags, TosState in, TosState out, void (*gen)(TosState tos), TosState tos);
	static void def(Bytecodes::Code code, int flags, TosState in, TosState out, void (*gen)(Operation op), Operation op);
	static void def(Bytecodes::Code code, int flags, TosState in, TosState out, void (*gen)(Condition cc), Condition cc);

	friend class Template;

	// InterpreterMacroAssembler::is_a(), etc., need TemplateTable::call_VM().
	friend class InterpreterMacroAssembler;

	public:
	// Initialization
	static void initialize();
	static void pd_initialize();

	// Templates
	static Template* template_for (Bytecodes::Code code) { Bytecodes::check (code); return &_template_table [code]; }
	static Template* template_for_wide(Bytecodes::Code code) { Bytecodes::wide_check(code); return &_template_table_wide[code]; }

	// Platform specifics
	#if defined TEMPLATETABLE_MD_HPP
	# include TEMPLATETABLE_MD_HPP
	#elif defined TARGET_ARCH_MODEL_x86_32
	# include "templateTable_x86_32.hpp"
	#elif defined TARGET_ARCH_MODEL_x86_64
	# include "templateTable_x86_64.hpp"
	#elif defined TARGET_ARCH_MODEL_sparc
	# include "templateTable_sparc.hpp"
	#elif defined TARGET_ARCH_MODEL_zero
	# include "templateTable_zero.hpp"
	#elif defined TARGET_ARCH_MODEL_ppc_64
	# include "templateTable_ppc_64.hpp"
	#endif

	};
	#endif /* !CC_INTERP */

	#endif // SHARE_VM_INTERPRETER_TEMPLATETABLE_HPP