Mercurial > hg > graal-compiler
diff src/share/vm/runtime/rframe.cpp @ 0:a61af66fc99e jdk7-b24
Initial load
author | duke |
---|---|
date | Sat, 01 Dec 2007 00:00:00 +0000 |
parents | |
children | c18cbe5936b8 |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/vm/runtime/rframe.cpp Sat Dec 01 00:00:00 2007 +0000 @@ -0,0 +1,170 @@ +/* + * Copyright 1997-2007 Sun Microsystems, Inc. All Rights Reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + */ + +# include "incls/_precompiled.incl" + +#include "incls/_rframe.cpp.incl" + +static RFrame*const noCaller = (RFrame*) 0x1; // no caller (i.e., initial frame) +static RFrame*const noCallerYet = (RFrame*) 0x0; // caller not yet computed + +RFrame::RFrame(frame fr, JavaThread* thread, RFrame*const callee) : + _fr(fr), _thread(thread), _callee(callee), _num(callee ? callee->num() + 1 : 0) { + _caller = (RFrame*)noCallerYet; + _invocations = 0; + _distance = 0; +} + +void RFrame::set_distance(int d) { + assert(is_compiled() || d >= 0, "should be positive"); + _distance = d; +} + +InterpretedRFrame::InterpretedRFrame(frame fr, JavaThread* thread, RFrame*const callee) +: RFrame(fr, thread, callee) { + RegisterMap map(thread, false); + _vf = javaVFrame::cast(vframe::new_vframe(&_fr, &map, thread)); + _method = methodHandle(thread, _vf->method()); + assert( _vf->is_interpreted_frame(), "must be interpreted"); + init(); +} + +InterpretedRFrame::InterpretedRFrame(frame fr, JavaThread* thread, methodHandle m) +: RFrame(fr, thread, NULL) { + RegisterMap map(thread, false); + _vf = javaVFrame::cast(vframe::new_vframe(&_fr, &map, thread)); + _method = m; + + assert( _vf->is_interpreted_frame(), "must be interpreted"); + init(); +} + +CompiledRFrame::CompiledRFrame(frame fr, JavaThread* thread, RFrame*const callee) +: RFrame(fr, thread, callee) { + init(); +} + +CompiledRFrame::CompiledRFrame(frame fr, JavaThread* thread) +: RFrame(fr, thread, NULL) { + init(); +} + +DeoptimizedRFrame::DeoptimizedRFrame(frame fr, JavaThread* thread, RFrame*const callee) +: InterpretedRFrame(fr, thread, callee) {} + +RFrame* RFrame::new_RFrame(frame fr, JavaThread* thread, RFrame*const callee) { + RFrame* rf; + int dist = callee ? callee->distance() : -1; + if (fr.is_interpreted_frame()) { + rf = new InterpretedRFrame(fr, thread, callee); + dist++; + } else if (fr.is_compiled_frame()) { + // Even deopted frames look compiled because the deopt + // is invisible until it happens. + rf = new CompiledRFrame(fr, thread, callee); + } else { + assert(false, "Unhandled frame type"); + } + rf->set_distance(dist); + rf->init(); + return rf; +} + +RFrame* RFrame::caller() { + if (_caller != noCallerYet) return (_caller == noCaller) ? NULL : _caller; // already computed caller + + // caller not yet computed; do it now + if (_fr.is_first_java_frame()) { + _caller = (RFrame*)noCaller; + return NULL; + } + + RegisterMap map(_thread, false); + frame sender = _fr.real_sender(&map); + if (sender.is_java_frame()) { + _caller = new_RFrame(sender, thread(), this); + return _caller; + } + + // Real caller is not java related + _caller = (RFrame*)noCaller; + return NULL; +} + +int InterpretedRFrame::cost() const { + return _method->code_size(); // fix this + //return _method->estimated_inline_cost(_receiverKlass); +} + +int CompiledRFrame::cost() const { + nmethod* nm = top_method()->code(); + if (nm != NULL) { + return nm->code_size(); + } else { + return top_method()->code_size(); + } +} + +void CompiledRFrame::init() { + RegisterMap map(thread(), false); + vframe* vf = vframe::new_vframe(&_fr, &map, thread()); + assert(vf->is_compiled_frame(), "must be compiled"); + _nm = compiledVFrame::cast(vf)->code(); + vf = vf->top(); + _vf = javaVFrame::cast(vf); + _method = methodHandle(thread(), CodeCache::find_nmethod(_fr.pc())->method()); + assert(_method(), "should have found a method"); +#ifndef PRODUCT + _invocations = _method->compiled_invocation_count(); +#endif +} + +void InterpretedRFrame::init() { + _invocations = _method->invocation_count() + _method->backedge_count(); +} + +void RFrame::print(const char* kind) { +#ifndef PRODUCT +#ifdef COMPILER2 + int cnt = top_method()->interpreter_invocation_count(); +#else + int cnt = top_method()->invocation_count(); +#endif + tty->print("%3d %s ", _num, is_interpreted() ? "I" : "C"); + top_method()->print_short_name(tty); + tty->print_cr(": inv=%5d(%d) cst=%4d", _invocations, cnt, cost()); +#endif +} + +void CompiledRFrame::print() { + RFrame::print("comp"); +} + +void InterpretedRFrame::print() { + RFrame::print("int."); +} + +void DeoptimizedRFrame::print() { + RFrame::print("deopt."); +}