1 /* 2 * Copyright (c) 1997, 2018, 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 "code/codeCache.hpp" 27 #include "interpreter/interpreter.hpp" 28 #include "oops/method.inline.hpp" 29 #include "oops/oop.inline.hpp" 30 #include "oops/symbol.hpp" 31 #include "runtime/frame.inline.hpp" 32 #include "runtime/rframe.hpp" 33 #include "runtime/vframe.hpp" 34 #include "runtime/vframe_hp.hpp" 35 36 37 static RFrame*const noCaller = (RFrame*) 0x1; // no caller (i.e., initial frame) 38 static RFrame*const noCallerYet = (RFrame*) 0x0; // caller not yet computed 39 40 RFrame::RFrame(frame fr, JavaThread* thread, RFrame*const callee) : 41 _fr(fr), _thread(thread), _callee(callee), _num(callee ? callee->num() + 1 : 0) { 42 _caller = (RFrame*)noCallerYet; 43 _invocations = 0; 44 _distance = 0; 45 } 46 47 void RFrame::set_distance(int d) { 48 assert(is_compiled() || d >= 0, "should be positive"); 49 _distance = d; 50 } 51 52 InterpretedRFrame::InterpretedRFrame(frame fr, JavaThread* thread, RFrame*const callee) 53 : RFrame(fr, thread, callee) { 54 RegisterMap map(thread, false); 55 _vf = javaVFrame::cast(vframe::new_vframe(&_fr, &map, thread)); 56 _method = _vf->method(); 57 assert( _vf->is_interpreted_frame(), "must be interpreted"); 58 init(); 59 } 60 61 InterpretedRFrame::InterpretedRFrame(frame fr, JavaThread* thread, Method* m) 62 : RFrame(fr, thread, NULL) { 63 RegisterMap map(thread, false); 64 _vf = javaVFrame::cast(vframe::new_vframe(&_fr, &map, thread)); 65 _method = m; 66 67 assert( _vf->is_interpreted_frame(), "must be interpreted"); 68 init(); 69 } 70 71 CompiledRFrame::CompiledRFrame(frame fr, JavaThread* thread, RFrame*const callee) 72 : RFrame(fr, thread, callee) { 73 init(); 74 } 75 76 CompiledRFrame::CompiledRFrame(frame fr, JavaThread* thread) 77 : RFrame(fr, thread, NULL) { 78 init(); 79 } 80 81 DeoptimizedRFrame::DeoptimizedRFrame(frame fr, JavaThread* thread, RFrame*const callee) 82 : InterpretedRFrame(fr, thread, callee) {} 83 84 RFrame* RFrame::new_RFrame(frame fr, JavaThread* thread, RFrame*const callee) { 85 RFrame* rf = NULL; 86 int dist = callee ? callee->distance() : -1; 87 if (fr.is_interpreted_frame()) { 88 rf = new InterpretedRFrame(fr, thread, callee); 89 dist++; 90 } else if (fr.is_compiled_frame()) { 91 // Even deopted frames look compiled because the deopt 92 // is invisible until it happens. 93 rf = new CompiledRFrame(fr, thread, callee); 94 } else { 95 assert(false, "Unhandled frame type"); 96 } 97 if (rf != NULL) { 98 rf->set_distance(dist); 99 rf->init(); 100 } 101 return rf; 102 } 103 104 RFrame* RFrame::caller() { 105 if (_caller != noCallerYet) return (_caller == noCaller) ? NULL : _caller; // already computed caller 106 107 // caller not yet computed; do it now 108 if (_fr.is_first_java_frame()) { 109 _caller = (RFrame*)noCaller; 110 return NULL; 111 } 112 113 RegisterMap map(_thread, false); 114 frame sender = _fr.real_sender(&map); 115 if (sender.is_java_frame()) { 116 _caller = new_RFrame(sender, thread(), this); 117 return _caller; 118 } 119 120 // Real caller is not java related 121 _caller = (RFrame*)noCaller; 122 return NULL; 123 } 124 125 int InterpretedRFrame::cost() const { 126 return _method->code_size(); // fix this 127 //return _method->estimated_inline_cost(_receiverKlass); 128 } 129 130 int CompiledRFrame::cost() const { 131 CompiledMethod* nm = top_method()->code(); 132 if (nm != NULL) { 133 return nm->insts_size(); 134 } else { 135 return top_method()->code_size(); 136 } 137 } 138 139 void CompiledRFrame::init() { 140 RegisterMap map(thread(), false); 141 vframe* vf = vframe::new_vframe(&_fr, &map, thread()); 142 assert(vf->is_compiled_frame(), "must be compiled"); 143 _nm = compiledVFrame::cast(vf)->code()->as_nmethod(); 144 vf = vf->top(); 145 _vf = javaVFrame::cast(vf); 146 _method = CodeCache::find_nmethod(_fr.pc())->method(); 147 assert(_method, "should have found a method"); 148 #ifndef PRODUCT 149 _invocations = _method->compiled_invocation_count(); 150 #endif 151 } 152 153 void InterpretedRFrame::init() { 154 _invocations = _method->invocation_count() + _method->backedge_count(); 155 } 156 157 void RFrame::print(const char* kind) { 158 #ifndef PRODUCT 159 #if COMPILER2_OR_JVMCI 160 int cnt = top_method()->interpreter_invocation_count(); 161 #else 162 int cnt = top_method()->invocation_count(); 163 #endif 164 tty->print("%3d %s ", _num, is_interpreted() ? "I" : "C"); 165 top_method()->print_short_name(tty); 166 tty->print_cr(": inv=%5d(%d) cst=%4d", _invocations, cnt, cost()); 167 #endif 168 } 169 170 void CompiledRFrame::print() { 171 RFrame::print("comp"); 172 } 173 174 void InterpretedRFrame::print() { 175 RFrame::print("int."); 176 } 177 178 void DeoptimizedRFrame::print() { 179 RFrame::print("deopt."); 180 }