debugInfo.cpp revision 6412:53a41e7cbe05
1/* 2 * Copyright (c) 1997, 2014, 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/debugInfo.hpp" 27#include "code/debugInfoRec.hpp" 28#include "code/nmethod.hpp" 29#include "runtime/handles.inline.hpp" 30 31PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC 32 33// Constructors 34 35DebugInfoWriteStream::DebugInfoWriteStream(DebugInformationRecorder* recorder, int initial_size) 36: CompressedWriteStream(initial_size) { 37 _recorder = recorder; 38} 39 40// Serializing oops 41 42void DebugInfoWriteStream::write_handle(jobject h) { 43 write_int(recorder()->oop_recorder()->find_index(h)); 44} 45 46void DebugInfoWriteStream::write_metadata(Metadata* h) { 47 write_int(recorder()->oop_recorder()->find_index(h)); 48} 49 50ScopeValue* DebugInfoReadStream::read_object_value() { 51 int id = read_int(); 52#ifdef ASSERT 53 assert(_obj_pool != NULL, "object pool does not exist"); 54 for (int i = _obj_pool->length() - 1; i >= 0; i--) { 55 assert(((ObjectValue*) _obj_pool->at(i))->id() != id, "should not be read twice"); 56 } 57#endif 58 ObjectValue* result = new ObjectValue(id); 59 // Cache the object since an object field could reference it. 60 _obj_pool->push(result); 61 result->read_object(this); 62 return result; 63} 64 65ScopeValue* DebugInfoReadStream::get_cached_object() { 66 int id = read_int(); 67 assert(_obj_pool != NULL, "object pool does not exist"); 68 for (int i = _obj_pool->length() - 1; i >= 0; i--) { 69 ObjectValue* ov = (ObjectValue*) _obj_pool->at(i); 70 if (ov->id() == id) { 71 return ov; 72 } 73 } 74 ShouldNotReachHere(); 75 return NULL; 76} 77 78// Serializing scope values 79 80enum { LOCATION_CODE = 0, CONSTANT_INT_CODE = 1, CONSTANT_OOP_CODE = 2, 81 CONSTANT_LONG_CODE = 3, CONSTANT_DOUBLE_CODE = 4, 82 OBJECT_CODE = 5, OBJECT_ID_CODE = 6 }; 83 84ScopeValue* ScopeValue::read_from(DebugInfoReadStream* stream) { 85 ScopeValue* result = NULL; 86 switch(stream->read_int()) { 87 case LOCATION_CODE: result = new LocationValue(stream); break; 88 case CONSTANT_INT_CODE: result = new ConstantIntValue(stream); break; 89 case CONSTANT_OOP_CODE: result = new ConstantOopReadValue(stream); break; 90 case CONSTANT_LONG_CODE: result = new ConstantLongValue(stream); break; 91 case CONSTANT_DOUBLE_CODE: result = new ConstantDoubleValue(stream); break; 92 case OBJECT_CODE: result = stream->read_object_value(); break; 93 case OBJECT_ID_CODE: result = stream->get_cached_object(); break; 94 default: ShouldNotReachHere(); 95 } 96 return result; 97} 98 99// LocationValue 100 101LocationValue::LocationValue(DebugInfoReadStream* stream) { 102 _location = Location(stream); 103} 104 105void LocationValue::write_on(DebugInfoWriteStream* stream) { 106 stream->write_int(LOCATION_CODE); 107 location().write_on(stream); 108} 109 110void LocationValue::print_on(outputStream* st) const { 111 location().print_on(st); 112} 113 114// ObjectValue 115 116void ObjectValue::read_object(DebugInfoReadStream* stream) { 117 _klass = read_from(stream); 118 assert(_klass->is_constant_oop(), "should be constant java mirror oop"); 119 int length = stream->read_int(); 120 for (int i = 0; i < length; i++) { 121 ScopeValue* val = read_from(stream); 122 _field_values.append(val); 123 } 124} 125 126void ObjectValue::write_on(DebugInfoWriteStream* stream) { 127 if (_visited) { 128 stream->write_int(OBJECT_ID_CODE); 129 stream->write_int(_id); 130 } else { 131 _visited = true; 132 stream->write_int(OBJECT_CODE); 133 stream->write_int(_id); 134 _klass->write_on(stream); 135 int length = _field_values.length(); 136 stream->write_int(length); 137 for (int i = 0; i < length; i++) { 138 _field_values.at(i)->write_on(stream); 139 } 140 } 141} 142 143void ObjectValue::print_on(outputStream* st) const { 144 st->print("obj[%d]", _id); 145} 146 147void ObjectValue::print_fields_on(outputStream* st) const { 148#ifndef PRODUCT 149 if (_field_values.length() > 0) { 150 _field_values.at(0)->print_on(st); 151 } 152 for (int i = 1; i < _field_values.length(); i++) { 153 st->print(", "); 154 _field_values.at(i)->print_on(st); 155 } 156#endif 157} 158 159// ConstantIntValue 160 161ConstantIntValue::ConstantIntValue(DebugInfoReadStream* stream) { 162 _value = stream->read_signed_int(); 163} 164 165void ConstantIntValue::write_on(DebugInfoWriteStream* stream) { 166 stream->write_int(CONSTANT_INT_CODE); 167 stream->write_signed_int(value()); 168} 169 170void ConstantIntValue::print_on(outputStream* st) const { 171 st->print("%d", value()); 172} 173 174// ConstantLongValue 175 176ConstantLongValue::ConstantLongValue(DebugInfoReadStream* stream) { 177 _value = stream->read_long(); 178} 179 180void ConstantLongValue::write_on(DebugInfoWriteStream* stream) { 181 stream->write_int(CONSTANT_LONG_CODE); 182 stream->write_long(value()); 183} 184 185void ConstantLongValue::print_on(outputStream* st) const { 186 st->print(INT64_FORMAT, value()); 187} 188 189// ConstantDoubleValue 190 191ConstantDoubleValue::ConstantDoubleValue(DebugInfoReadStream* stream) { 192 _value = stream->read_double(); 193} 194 195void ConstantDoubleValue::write_on(DebugInfoWriteStream* stream) { 196 stream->write_int(CONSTANT_DOUBLE_CODE); 197 stream->write_double(value()); 198} 199 200void ConstantDoubleValue::print_on(outputStream* st) const { 201 st->print("%f", value()); 202} 203 204// ConstantOopWriteValue 205 206void ConstantOopWriteValue::write_on(DebugInfoWriteStream* stream) { 207 assert(JNIHandles::resolve(value()) == NULL || 208 Universe::heap()->is_in_reserved(JNIHandles::resolve(value())), 209 "Should be in heap"); 210 stream->write_int(CONSTANT_OOP_CODE); 211 stream->write_handle(value()); 212} 213 214void ConstantOopWriteValue::print_on(outputStream* st) const { 215 JNIHandles::resolve(value())->print_value_on(st); 216} 217 218 219// ConstantOopReadValue 220 221ConstantOopReadValue::ConstantOopReadValue(DebugInfoReadStream* stream) { 222 _value = Handle(stream->read_oop()); 223 assert(_value() == NULL || 224 Universe::heap()->is_in_reserved(_value()), "Should be in heap"); 225} 226 227void ConstantOopReadValue::write_on(DebugInfoWriteStream* stream) { 228 ShouldNotReachHere(); 229} 230 231void ConstantOopReadValue::print_on(outputStream* st) const { 232 value()()->print_value_on(st); 233} 234 235 236// MonitorValue 237 238MonitorValue::MonitorValue(ScopeValue* owner, Location basic_lock, bool eliminated) { 239 _owner = owner; 240 _basic_lock = basic_lock; 241 _eliminated = eliminated; 242} 243 244MonitorValue::MonitorValue(DebugInfoReadStream* stream) { 245 _basic_lock = Location(stream); 246 _owner = ScopeValue::read_from(stream); 247 _eliminated = (stream->read_bool() != 0); 248} 249 250void MonitorValue::write_on(DebugInfoWriteStream* stream) { 251 _basic_lock.write_on(stream); 252 _owner->write_on(stream); 253 stream->write_bool(_eliminated); 254} 255 256#ifndef PRODUCT 257void MonitorValue::print_on(outputStream* st) const { 258 st->print("monitor{"); 259 owner()->print_on(st); 260 st->print(","); 261 basic_lock().print_on(st); 262 st->print("}"); 263 if (_eliminated) { 264 st->print(" (eliminated)"); 265 } 266} 267#endif 268