Mercurial > hg > graal-compiler
diff src/share/vm/code/scopeDesc.cpp @ 0:a61af66fc99e jdk7-b24
Initial load
author | duke |
---|---|
date | Sat, 01 Dec 2007 00:00:00 +0000 |
parents | |
children | 52fed2ec0afb |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/vm/code/scopeDesc.cpp Sat Dec 01 00:00:00 2007 +0000 @@ -0,0 +1,237 @@ +/* + * Copyright 1997-2006 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/_scopeDesc.cpp.incl" + + +ScopeDesc::ScopeDesc(const nmethod* code, int decode_offset, int obj_decode_offset) { + _code = code; + _decode_offset = decode_offset; + _objects = decode_object_values(obj_decode_offset); + decode_body(); +} + +ScopeDesc::ScopeDesc(const nmethod* code, int decode_offset) { + _code = code; + _decode_offset = decode_offset; + _objects = decode_object_values(DebugInformationRecorder::serialized_null); + decode_body(); +} + + +ScopeDesc::ScopeDesc(const ScopeDesc* parent) { + _code = parent->_code; + _decode_offset = parent->_sender_decode_offset; + _objects = parent->_objects; + decode_body(); +} + + +void ScopeDesc::decode_body() { + if (decode_offset() == DebugInformationRecorder::serialized_null) { + // This is a sentinel record, which is only relevant to + // approximate queries. Decode a reasonable frame. + _sender_decode_offset = DebugInformationRecorder::serialized_null; + _method = methodHandle(_code->method()); + _bci = InvocationEntryBci; + _locals_decode_offset = DebugInformationRecorder::serialized_null; + _expressions_decode_offset = DebugInformationRecorder::serialized_null; + _monitors_decode_offset = DebugInformationRecorder::serialized_null; + } else { + // decode header + DebugInfoReadStream* stream = stream_at(decode_offset()); + + _sender_decode_offset = stream->read_int(); + _method = methodHandle((methodOop) stream->read_oop()); + _bci = stream->read_bci(); + // decode offsets for body and sender + _locals_decode_offset = stream->read_int(); + _expressions_decode_offset = stream->read_int(); + _monitors_decode_offset = stream->read_int(); + } +} + + +GrowableArray<ScopeValue*>* ScopeDesc::decode_scope_values(int decode_offset) { + if (decode_offset == DebugInformationRecorder::serialized_null) return NULL; + DebugInfoReadStream* stream = stream_at(decode_offset); + int length = stream->read_int(); + GrowableArray<ScopeValue*>* result = new GrowableArray<ScopeValue*> (length); + for (int index = 0; index < length; index++) { + result->push(ScopeValue::read_from(stream)); + } + return result; +} + +GrowableArray<ScopeValue*>* ScopeDesc::decode_object_values(int decode_offset) { + if (decode_offset == DebugInformationRecorder::serialized_null) return NULL; + GrowableArray<ScopeValue*>* result = new GrowableArray<ScopeValue*>(); + DebugInfoReadStream* stream = new DebugInfoReadStream(_code, decode_offset, result); + int length = stream->read_int(); + for (int index = 0; index < length; index++) { + result->push(ScopeValue::read_from(stream)); + } + assert(result->length() == length, "inconsistent debug information"); + return result; +} + + +GrowableArray<MonitorValue*>* ScopeDesc::decode_monitor_values(int decode_offset) { + if (decode_offset == DebugInformationRecorder::serialized_null) return NULL; + DebugInfoReadStream* stream = stream_at(decode_offset); + int length = stream->read_int(); + GrowableArray<MonitorValue*>* result = new GrowableArray<MonitorValue*> (length); + for (int index = 0; index < length; index++) { + result->push(new MonitorValue(stream)); + } + return result; +} + +DebugInfoReadStream* ScopeDesc::stream_at(int decode_offset) const { + return new DebugInfoReadStream(_code, decode_offset, _objects); +} + +GrowableArray<ScopeValue*>* ScopeDesc::locals() { + return decode_scope_values(_locals_decode_offset); +} + +GrowableArray<ScopeValue*>* ScopeDesc::expressions() { + return decode_scope_values(_expressions_decode_offset); +} + +GrowableArray<MonitorValue*>* ScopeDesc::monitors() { + return decode_monitor_values(_monitors_decode_offset); +} + +GrowableArray<ScopeValue*>* ScopeDesc::objects() { + return _objects; +} + +bool ScopeDesc::is_top() const { + return _sender_decode_offset == DebugInformationRecorder::serialized_null; +} + +ScopeDesc* ScopeDesc::sender() const { + if (is_top()) return NULL; + return new ScopeDesc(this); +} + + +#ifndef PRODUCT + +void ScopeDesc::print_value_on(outputStream* st) const { + tty->print(" "); + method()()->print_short_name(st); + int lineno = method()->line_number_from_bci(bci()); + if (lineno != -1) { + st->print_cr("@%d (line %d)", bci(), lineno); + } else { + st->print_cr("@%d", bci()); + } +} + +void ScopeDesc::print_on(outputStream* st) const { + print_on(st, NULL); +} + +void ScopeDesc::print_on(outputStream* st, PcDesc* pd) const { + // header + if (pd != NULL) { + tty->print_cr("ScopeDesc(pc=" PTR_FORMAT " offset=%x):", pd->real_pc(_code), pd->pc_offset()); + } + + print_value_on(st); + // decode offsets + if (WizardMode) { + st->print("ScopeDesc[%d]@" PTR_FORMAT " ", _decode_offset, _code->instructions_begin()); + st->print_cr(" offset: %d", _decode_offset); + st->print_cr(" bci: %d", bci()); + st->print_cr(" locals: %d", _locals_decode_offset); + st->print_cr(" stack: %d", _expressions_decode_offset); + st->print_cr(" monitor: %d", _monitors_decode_offset); + st->print_cr(" sender: %d", _sender_decode_offset); + } + // locals + { GrowableArray<ScopeValue*>* l = ((ScopeDesc*) this)->locals(); + if (l != NULL) { + tty->print_cr(" Locals"); + for (int index = 0; index < l->length(); index++) { + st->print(" - l%d: ", index); + l->at(index)->print_on(st); + st->cr(); + } + } + } + // expressions + { GrowableArray<ScopeValue*>* l = ((ScopeDesc*) this)->expressions(); + if (l != NULL) { + st->print_cr(" Expression stack"); + for (int index = 0; index < l->length(); index++) { + st->print(" - @%d: ", index); + l->at(index)->print_on(st); + st->cr(); + } + } + } + // monitors + { GrowableArray<MonitorValue*>* l = ((ScopeDesc*) this)->monitors(); + if (l != NULL) { + st->print_cr(" Monitor stack"); + for (int index = 0; index < l->length(); index++) { + st->print(" - @%d: ", index); + l->at(index)->print_on(st); + st->cr(); + } + } + } + +#ifdef COMPILER2 + if (DoEscapeAnalysis && is_top() && _objects != NULL) { + tty->print_cr("Objects"); + for (int i = 0; i < _objects->length(); i++) { + ObjectValue* sv = (ObjectValue*) _objects->at(i); + tty->print(" - %d: ", sv->id()); + sv->print_fields_on(tty); + tty->cr(); + } + } +#endif // COMPILER2 +} + +#endif + +void ScopeDesc::verify() { + ResourceMark rm; + guarantee(method()->is_method(), "type check"); + + // check if we have any illegal elements on the expression stack + { GrowableArray<ScopeValue*>* l = expressions(); + if (l != NULL) { + for (int index = 0; index < l->length(); index++) { + //guarantee(!l->at(index)->is_illegal(), "expression element cannot be illegal"); + } + } + } +}