--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/src/share/vm/interpreter/templateTable.hpp Sat Dec 01 00:00:00 2007 +0000
@@ -0,0 +1,329 @@
+/*
+ * Copyright 1997-2005 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+#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 };
+
+ 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(); }
+
+ 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 scratch1,
+ Register scratch2, bool load_bc_in_scratch = true);
+
+ // 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 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, Register cache, Register index);
+ static void load_invoke_cp_cache_entry(int byte_no,
+ Register method,
+ Register itable_index,
+ Register flags,
+ bool is_invokevirtual = false,
+ bool is_virtual_final = false);
+ 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 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
+ #include "incls/_templateTable_pd.hpp.incl"
+};
+#endif /* !CC_INTERP */