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