Mercurial > jdk8-mips64-public > hotspot / file revision

 /*

  * Copyright 1997-2008 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++) {

     // Objects values are pushed to 'result' array during read so that

     // object's fields could reference it (OBJECT_ID_CODE).

     (void)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");

       }

     }

   }

 }