Mercurial > hg > graal-compiler

comparison src/share/vm/code/debugInfo.cpp @ 0:a61af66fc99e jdk7-b24

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial load
author duke
date Sat, 01 Dec 2007 00:00:00 +0000
parents
children 52fed2ec0afb
comparison
equal deleted inserted replaced
-1:000000000000 0:a61af66fc99e
1 /*
2 * Copyright 1997-2006 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
20 * CA 95054 USA or visit www.sun.com if you need additional information or
21 * have any questions.
22 *
23 */
24
25 # include "incls/_precompiled.incl"
26 # include "incls/_debugInfo.cpp.incl"
27
28 // Comstructors
29
30 DebugInfoWriteStream::DebugInfoWriteStream(DebugInformationRecorder* recorder, int initial_size)
31 : CompressedWriteStream(initial_size) {
32 _recorder = recorder;
33 }
34
35 // Serializing oops
36
37 void DebugInfoWriteStream::write_handle(jobject h) {
38 write_int(recorder()->oop_recorder()->find_index(h));
39 }
40
41 ScopeValue* DebugInfoReadStream::read_object_value() {
42 int id = read_int();
43 #ifdef ASSERT
44 assert(_obj_pool != NULL, "object pool does not exist");
45 for (int i = _obj_pool->length() - 1; i >= 0; i--) {
46 assert(((ObjectValue*) _obj_pool->at(i))->id() != id, "should not be read twice");
47 }
48 #endif
49 ObjectValue* result = new ObjectValue(id);
50 _obj_pool->append(result);
51 result->read_object(this);
52 return result;
53 }
54
55 ScopeValue* DebugInfoReadStream::get_cached_object() {
56 int id = read_int();
57 assert(_obj_pool != NULL, "object pool does not exist");
58 for (int i = _obj_pool->length() - 1; i >= 0; i--) {
59 ObjectValue* sv = (ObjectValue*) _obj_pool->at(i);
60 if (sv->id() == id) {
61 return sv;
62 }
63 }
64 ShouldNotReachHere();
65 return NULL;
66 }
67
68 // Serializing scope values
69
70 enum { LOCATION_CODE = 0, CONSTANT_INT_CODE = 1, CONSTANT_OOP_CODE = 2,
71 CONSTANT_LONG_CODE = 3, CONSTANT_DOUBLE_CODE = 4,
72 OBJECT_CODE = 5, OBJECT_ID_CODE = 6 };
73
74 ScopeValue* ScopeValue::read_from(DebugInfoReadStream* stream) {
75 ScopeValue* result = NULL;
76 switch(stream->read_int()) {
77 case LOCATION_CODE: result = new LocationValue(stream); break;
78 case CONSTANT_INT_CODE: result = new ConstantIntValue(stream); break;
79 case CONSTANT_OOP_CODE: result = new ConstantOopReadValue(stream); break;
80 case CONSTANT_LONG_CODE: result = new ConstantLongValue(stream); break;
81 case CONSTANT_DOUBLE_CODE: result = new ConstantDoubleValue(stream); break;
82 case OBJECT_CODE: result = stream->read_object_value(); break;
83 case OBJECT_ID_CODE: result = stream->get_cached_object(); break;
84 default: ShouldNotReachHere();
85 }
86 return result;
87 }
88
89 // LocationValue
90
91 LocationValue::LocationValue(DebugInfoReadStream* stream) {
92 _location = Location(stream);
93 }
94
95 void LocationValue::write_on(DebugInfoWriteStream* stream) {
96 stream->write_int(LOCATION_CODE);
97 location().write_on(stream);
98 }
99
100 void LocationValue::print_on(outputStream* st) const {
101 location().print_on(st);
102 }
103
104 // ObjectValue
105
106 void ObjectValue::read_object(DebugInfoReadStream* stream) {
107 _klass = read_from(stream);
108 assert(_klass->is_constant_oop(), "should be constant klass oop");
109 int length = stream->read_int();
110 for (int i = 0; i < length; i++) {
111 ScopeValue* val = read_from(stream);
112 _field_values.append(val);
113 }
114 }
115
116 void ObjectValue::write_on(DebugInfoWriteStream* stream) {
117 if (_visited) {
118 stream->write_int(OBJECT_ID_CODE);
119 stream->write_int(_id);
120 } else {
121 _visited = true;
122 stream->write_int(OBJECT_CODE);
123 stream->write_int(_id);
124 _klass->write_on(stream);
125 int length = _field_values.length();
126 stream->write_int(length);
127 for (int i = 0; i < length; i++) {
128 _field_values.at(i)->write_on(stream);
129 }
130 }
131 }
132
133 void ObjectValue::print_on(outputStream* st) const {
134 st->print("obj[%d]", _id);
135 }
136
137 void ObjectValue::print_fields_on(outputStream* st) const {
138 #ifndef PRODUCT
139 if (_field_values.length() > 0) {
140 _field_values.at(0)->print_on(st);
141 }
142 for (int i = 1; i < _field_values.length(); i++) {
143 st->print(", ");
144 _field_values.at(i)->print_on(st);
145 }
146 #endif
147 }
148
149 // ConstantIntValue
150
151 ConstantIntValue::ConstantIntValue(DebugInfoReadStream* stream) {
152 _value = stream->read_signed_int();
153 }
154
155 void ConstantIntValue::write_on(DebugInfoWriteStream* stream) {
156 stream->write_int(CONSTANT_INT_CODE);
157 stream->write_signed_int(value());
158 }
159
160 void ConstantIntValue::print_on(outputStream* st) const {
161 st->print("%d", value());
162 }
163
164 // ConstantLongValue
165
166 ConstantLongValue::ConstantLongValue(DebugInfoReadStream* stream) {
167 _value = stream->read_long();
168 }
169
170 void ConstantLongValue::write_on(DebugInfoWriteStream* stream) {
171 stream->write_int(CONSTANT_LONG_CODE);
172 stream->write_long(value());
173 }
174
175 void ConstantLongValue::print_on(outputStream* st) const {
176 st->print(INT64_FORMAT, value());
177 }
178
179 // ConstantDoubleValue
180
181 ConstantDoubleValue::ConstantDoubleValue(DebugInfoReadStream* stream) {
182 _value = stream->read_double();
183 }
184
185 void ConstantDoubleValue::write_on(DebugInfoWriteStream* stream) {
186 stream->write_int(CONSTANT_DOUBLE_CODE);
187 stream->write_double(value());
188 }
189
190 void ConstantDoubleValue::print_on(outputStream* st) const {
191 st->print("%f", value());
192 }
193
194 // ConstantOopWriteValue
195
196 void ConstantOopWriteValue::write_on(DebugInfoWriteStream* stream) {
197 stream->write_int(CONSTANT_OOP_CODE);
198 stream->write_handle(value());
199 }
200
201 void ConstantOopWriteValue::print_on(outputStream* st) const {
202 JNIHandles::resolve(value())->print_value_on(st);
203 }
204
205
206 // ConstantOopReadValue
207
208 ConstantOopReadValue::ConstantOopReadValue(DebugInfoReadStream* stream) {
209 _value = Handle(stream->read_oop());
210 }
211
212 void ConstantOopReadValue::write_on(DebugInfoWriteStream* stream) {
213 ShouldNotReachHere();
214 }
215
216 void ConstantOopReadValue::print_on(outputStream* st) const {
217 value()()->print_value_on(st);
218 }
219
220
221 // MonitorValue
222
223 MonitorValue::MonitorValue(ScopeValue* owner, Location basic_lock, bool eliminated) {
224 _owner = owner;
225 _basic_lock = basic_lock;
226 _eliminated = eliminated;
227 }
228
229 MonitorValue::MonitorValue(DebugInfoReadStream* stream) {
230 _basic_lock = Location(stream);
231 _owner = ScopeValue::read_from(stream);
232 _eliminated = (stream->read_bool() != 0);
233 }
234
235 void MonitorValue::write_on(DebugInfoWriteStream* stream) {
236 _basic_lock.write_on(stream);
237 _owner->write_on(stream);
238 stream->write_bool(_eliminated);
239 }
240
241 #ifndef PRODUCT
242 void MonitorValue::print_on(outputStream* st) const {
243 st->print("monitor{");
244 owner()->print_on(st);
245 st->print(",");
246 basic_lock().print_on(st);
247 st->print("}");
248 if (_eliminated) {
249 st->print(" (eliminated)");
250 }
251 }
252 #endif