1 /* 2 * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "precompiled.hpp" 26 #include "interpreter/bytecodeInterpreter.hpp" 27 #include "interpreter/cppInterpreterGenerator.hpp" 28 #include "interpreter/interpreter.hpp" 29 #include "interpreter/interpreterRuntime.hpp" 30 31 #ifdef CC_INTERP 32 33 CppInterpreterGenerator::CppInterpreterGenerator(StubQueue* _code): AbstractInterpreterGenerator(_code) { 34 generate_all(); 35 } 36 37 void CppInterpreterGenerator::generate_all() { 38 { CodeletMark cm(_masm, "slow signature handler"); 39 AbstractInterpreter::_slow_signature_handler = generate_slow_signature_handler(); 40 } 41 42 #define method_entry(kind) Interpreter::_entry_table[Interpreter::kind] = generate_method_entry(Interpreter::kind) 43 44 { CodeletMark cm(_masm, "(kind = frame_manager)"); 45 // all non-native method kinds 46 method_entry(zerolocals); 47 method_entry(zerolocals_synchronized); 48 method_entry(empty); 49 method_entry(accessor); 50 method_entry(abstract); 51 method_entry(java_lang_math_sin ); 52 method_entry(java_lang_math_cos ); 53 method_entry(java_lang_math_tan ); 54 method_entry(java_lang_math_abs ); 55 method_entry(java_lang_math_sqrt ); 56 method_entry(java_lang_math_log ); 57 method_entry(java_lang_math_log10 ); 58 method_entry(java_lang_math_pow ); 59 method_entry(java_lang_math_exp ); 60 method_entry(java_lang_math_fmaD ); 61 method_entry(java_lang_math_fmaF ); 62 method_entry(java_lang_ref_reference_get); 63 64 AbstractInterpreter::initialize_method_handle_entries(); 65 66 Interpreter::_native_entry_begin = Interpreter::code()->code_end(); 67 method_entry(native); 68 method_entry(native_synchronized); 69 Interpreter::_native_entry_end = Interpreter::code()->code_end(); 70 } 71 72 #undef method_entry 73 } 74 75 // Generate method entries 76 address CppInterpreterGenerator::generate_method_entry( 77 AbstractInterpreter::MethodKind kind) { 78 // determine code generation flags 79 bool native = false; 80 bool synchronized = false; 81 address entry_point = NULL; 82 83 switch (kind) { 84 case Interpreter::zerolocals : break; 85 case Interpreter::zerolocals_synchronized: synchronized = true; break; 86 case Interpreter::native : native = true; break; 87 case Interpreter::native_synchronized : native = true; synchronized = true; break; 88 case Interpreter::empty : entry_point = generate_empty_entry(); break; 89 case Interpreter::accessor : entry_point = generate_accessor_entry(); break; 90 case Interpreter::abstract : entry_point = generate_abstract_entry(); break; 91 92 case Interpreter::java_lang_math_sin : // fall thru 93 case Interpreter::java_lang_math_cos : // fall thru 94 case Interpreter::java_lang_math_tan : // fall thru 95 case Interpreter::java_lang_math_abs : // fall thru 96 case Interpreter::java_lang_math_log : // fall thru 97 case Interpreter::java_lang_math_log10 : // fall thru 98 case Interpreter::java_lang_math_sqrt : // fall thru 99 case Interpreter::java_lang_math_pow : // fall thru 100 case Interpreter::java_lang_math_exp : // fall thru 101 case Interpreter::java_lang_math_fmaD : // fall thru 102 case Interpreter::java_lang_math_fmaF : entry_point = generate_math_entry(kind); break; 103 case Interpreter::java_lang_ref_reference_get 104 : entry_point = generate_Reference_get_entry(); break; 105 default: 106 fatal("unexpected method kind: %d", kind); 107 break; 108 } 109 110 if (entry_point) { 111 return entry_point; 112 } 113 114 // We expect the normal and native entry points to be generated first so we can reuse them. 115 if (native) { 116 entry_point = Interpreter::entry_for_kind(synchronized ? Interpreter::native_synchronized : Interpreter::native); 117 if (entry_point == NULL) { 118 entry_point = generate_native_entry(synchronized); 119 } 120 } else { 121 entry_point = Interpreter::entry_for_kind(synchronized ? Interpreter::zerolocals_synchronized : Interpreter::zerolocals); 122 if (entry_point == NULL) { 123 entry_point = generate_normal_entry(synchronized); 124 } 125 } 126 127 return entry_point; 128 } 129 #endif // CC_INTERP