1 /* 2 * Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved. 3 * Copyright 2007, 2008, 2009, 2010, 2011 Red Hat, Inc. 4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 5 * 6 * This code is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License version 2 only, as 8 * published by the Free Software Foundation. 9 * 10 * This code is distributed in the hope that it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 13 * version 2 for more details (a copy is included in the LICENSE file that 14 * accompanied this code). 15 * 16 * You should have received a copy of the GNU General Public License version 17 * 2 along with this work; if not, write to the Free Software Foundation, 18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 19 * 20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 21 * or visit www.oracle.com if you need additional information or have any 22 * questions. 23 * 24 */ 25 26 #include "precompiled.hpp" 27 #include "interpreter/bytecodeInterpreter.hpp" 28 #include "interpreter/cppInterpreter.hpp" 29 #include "runtime/frame.inline.hpp" 30 #include "utilities/globalDefinitions.hpp" 31 32 bool AbstractInterpreter::can_be_compiled(methodHandle m) { 33 return true; 34 } 35 36 int AbstractInterpreter::BasicType_as_index(BasicType type) { 37 int i = 0; 38 switch (type) { 39 case T_BOOLEAN: i = 0; break; 40 case T_CHAR : i = 1; break; 41 case T_BYTE : i = 2; break; 42 case T_SHORT : i = 3; break; 43 case T_INT : i = 4; break; 44 case T_LONG : i = 5; break; 45 case T_VOID : i = 6; break; 46 case T_FLOAT : i = 7; break; 47 case T_DOUBLE : i = 8; break; 48 case T_OBJECT : i = 9; break; 49 case T_ARRAY : i = 9; break; 50 default : ShouldNotReachHere(); 51 } 52 assert(0 <= i && i < AbstractInterpreter::number_of_result_handlers, 53 "index out of bounds"); 54 return i; 55 } 56 57 // Deoptimization helpers 58 59 int AbstractInterpreter::size_activation(int max_stack, 60 int tempcount, 61 int extra_args, 62 int moncount, 63 int callee_param_count, 64 int callee_locals, 65 bool is_top_frame) { 66 int header_words = InterpreterFrame::header_words; 67 int monitor_words = moncount * frame::interpreter_frame_monitor_size(); 68 int stack_words = is_top_frame ? max_stack : tempcount; 69 int callee_extra_locals = callee_locals - callee_param_count; 70 71 return header_words + monitor_words + stack_words + callee_extra_locals; 72 } 73 74 void AbstractInterpreter::layout_activation(Method* method, 75 int tempcount, 76 int popframe_extra_args, 77 int moncount, 78 int caller_actual_parameters, 79 int callee_param_count, 80 int callee_locals, 81 frame* caller, 82 frame* interpreter_frame, 83 bool is_top_frame, 84 bool is_bottom_frame) { 85 assert(popframe_extra_args == 0, "what to do?"); 86 assert(!is_top_frame || (!callee_locals && !callee_param_count), 87 "top frame should have no caller"); 88 89 // This code must exactly match what InterpreterFrame::build 90 // does (the full InterpreterFrame::build, that is, not the 91 // one that creates empty frames for the deoptimizer). 92 // 93 // interpreter_frame will be filled in. It's size is determined by 94 // a previous call to the size_activation() method, 95 // 96 // Note that tempcount is the current size of the expression 97 // stack. For top most frames we will allocate a full sized 98 // expression stack and not the trimmed version that non-top 99 // frames have. 100 101 int monitor_words = moncount * frame::interpreter_frame_monitor_size(); 102 intptr_t *locals = interpreter_frame->fp() + method->max_locals(); 103 interpreterState istate = interpreter_frame->get_interpreterState(); 104 intptr_t *monitor_base = (intptr_t*) istate; 105 intptr_t *stack_base = monitor_base - monitor_words; 106 intptr_t *stack = stack_base - tempcount - 1; 107 108 BytecodeInterpreter::layout_interpreterState(istate, 109 caller, 110 NULL, 111 method, 112 locals, 113 stack, 114 stack_base, 115 monitor_base, 116 NULL, 117 is_top_frame); 118 } 119 120 // Helper for (runtime) stack overflow checks 121 122 int AbstractInterpreter::size_top_interpreter_activation(Method* method) { 123 return 0; 124 }