1/* 2 * Copyright (c) 1997, 2016, 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 36static RFrame*const noCaller = (RFrame*) 0x1; // no caller (i.e., initial frame) 37static RFrame*const noCallerYet = (RFrame*) 0x0; // caller not yet computed 38 39RFrame::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 46void RFrame::set_distance(int d) { 47 assert(is_compiled() || d >= 0, "should be positive"); 48 _distance = d; 49} 50 51InterpretedRFrame::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 60InterpretedRFrame::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 70CompiledRFrame::CompiledRFrame(frame fr, JavaThread* thread, RFrame*const callee) 71: RFrame(fr, thread, callee) { 72 init(); 73} 74 75CompiledRFrame::CompiledRFrame(frame fr, JavaThread* thread) 76: RFrame(fr, thread, NULL) { 77 init(); 78} 79 80DeoptimizedRFrame::DeoptimizedRFrame(frame fr, JavaThread* thread, RFrame*const callee) 81: InterpretedRFrame(fr, thread, callee) {} 82 83RFrame* 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 103RFrame* 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 124int InterpretedRFrame::cost() const { 125 return _method->code_size(); // fix this 126 //return _method->estimated_inline_cost(_receiverKlass); 127} 128 129int CompiledRFrame::cost() const { 130 CompiledMethod* nm = top_method()->code(); 131 if (nm != NULL) { 132 return nm->insts_size(); 133 } else { 134 return top_method()->code_size(); 135 } 136} 137 138void 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()->as_nmethod(); 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 152void InterpretedRFrame::init() { 153 _invocations = _method->invocation_count() + _method->backedge_count(); 154} 155 156void RFrame::print(const char* kind) { 157#ifndef PRODUCT 158#if defined(COMPILER2) || INCLUDE_JVMCI 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 169void CompiledRFrame::print() { 170 RFrame::print("comp"); 171} 172 173void InterpretedRFrame::print() { 174 RFrame::print("int."); 175} 176 177void DeoptimizedRFrame::print() { 178 RFrame::print("deopt."); 179} 180