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