Mercurial > hg > truffle

comparison src/share/vm/code/debugInfo.hpp @ 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 9987d9d5eb0e
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 // Classes used for serializing debugging information.
26 // These abstractions are introducted to provide symmetric
27 // read and write operations.
28
29 // ScopeValue describes the value of a variable/expression in a scope
30 // - LocationValue describes a value in a given location (in frame or register)
31 // - ConstantValue describes a constant
32
33 class ScopeValue: public ResourceObj {
34 public:
35 // Testers
36 virtual bool is_location() const { return false; }
37 virtual bool is_object() const { return false; }
38 virtual bool is_constant_int() const { return false; }
39 virtual bool is_constant_double() const { return false; }
40 virtual bool is_constant_long() const { return false; }
41 virtual bool is_constant_oop() const { return false; }
42 virtual bool equals(ScopeValue* other) const { return false; }
43
44 // Serialization of debugging information
45 virtual void write_on(DebugInfoWriteStream* stream) = 0;
46 static ScopeValue* read_from(DebugInfoReadStream* stream);
47 };
48
49
50 // A Location value describes a value in a given location; i.e. the corresponding
51 // logical entity (e.g., a method temporary) lives in this location.
52
53 class LocationValue: public ScopeValue {
54 private:
55 Location _location;
56 public:
57 LocationValue(Location location) { _location = location; }
58 bool is_location() const { return true; }
59 Location location() const { return _location; }
60
61 // Serialization of debugging information
62 LocationValue(DebugInfoReadStream* stream);
63 void write_on(DebugInfoWriteStream* stream);
64
65 // Printing
66 void print_on(outputStream* st) const;
67 };
68
69
70 // An ObjectValue describes an object eliminated by escape analysis.
71
72 class ObjectValue: public ScopeValue {
73 private:
74 int _id;
75 ScopeValue* _klass;
76 GrowableArray<ScopeValue*> _field_values;
77 Handle _value;
78 bool _visited;
79
80 public:
81 ObjectValue(int id, ScopeValue* klass)
82 : _id(id)
83 , _klass(klass)
84 , _field_values()
85 , _value()
86 , _visited(false) {
87 assert(klass->is_constant_oop(), "should be constant klass oop");
88 }
89
90 ObjectValue(int id)
91 : _id(id)
92 , _klass(NULL)
93 , _field_values()
94 , _value()
95 , _visited(false) {}
96
97 // Accessors
98 bool is_object() const { return true; }
99 int id() const { return _id; }
100 ScopeValue* klass() const { return _klass; }
101 GrowableArray<ScopeValue*>* field_values() { return &_field_values; }
102 ScopeValue* field_at(int i) const { return _field_values.at(i); }
103 int field_size() { return _field_values.length(); }
104 Handle value() const { return _value; }
105 bool is_visited() const { return _visited; }
106
107 void set_value(oop value) { _value = Handle(value); }
108 void set_visited(bool visited) { _visited = false; }
109
110 // Serialization of debugging information
111 void read_object(DebugInfoReadStream* stream);
112 void write_on(DebugInfoWriteStream* stream);
113
114 // Printing
115 void print_on(outputStream* st) const;
116 void print_fields_on(outputStream* st) const;
117 };
118
119
120 // A ConstantIntValue describes a constant int; i.e., the corresponding logical entity
121 // is either a source constant or its computation has been constant-folded.
122
123 class ConstantIntValue: public ScopeValue {
124 private:
125 jint _value;
126 public:
127 ConstantIntValue(jint value) { _value = value; }
128 jint value() const { return _value; }
129 bool is_constant_int() const { return true; }
130 bool equals(ScopeValue* other) const { return false; }
131
132 // Serialization of debugging information
133 ConstantIntValue(DebugInfoReadStream* stream);
134 void write_on(DebugInfoWriteStream* stream);
135
136 // Printing
137 void print_on(outputStream* st) const;
138 };
139
140 class ConstantLongValue: public ScopeValue {
141 private:
142 jlong _value;
143 public:
144 ConstantLongValue(jlong value) { _value = value; }
145 jlong value() const { return _value; }
146 bool is_constant_long() const { return true; }
147 bool equals(ScopeValue* other) const { return false; }
148
149 // Serialization of debugging information
150 ConstantLongValue(DebugInfoReadStream* stream);
151 void write_on(DebugInfoWriteStream* stream);
152
153 // Printing
154 void print_on(outputStream* st) const;
155 };
156
157 class ConstantDoubleValue: public ScopeValue {
158 private:
159 jdouble _value;
160 public:
161 ConstantDoubleValue(jdouble value) { _value = value; }
162 jdouble value() const { return _value; }
163 bool is_constant_double() const { return true; }
164 bool equals(ScopeValue* other) const { return false; }
165
166 // Serialization of debugging information
167 ConstantDoubleValue(DebugInfoReadStream* stream);
168 void write_on(DebugInfoWriteStream* stream);
169
170 // Printing
171 void print_on(outputStream* st) const;
172 };
173
174 // A ConstantOopWriteValue is created by the compiler to
175 // be written as debugging information.
176
177 class ConstantOopWriteValue: public ScopeValue {
178 private:
179 jobject _value;
180 public:
181 ConstantOopWriteValue(jobject value) { _value = value; }
182 jobject value() const { return _value; }
183 bool is_constant_oop() const { return true; }
184 bool equals(ScopeValue* other) const { return false; }
185
186 // Serialization of debugging information
187 void write_on(DebugInfoWriteStream* stream);
188
189 // Printing
190 void print_on(outputStream* st) const;
191 };
192
193 // A ConstantOopReadValue is created by the VM when reading
194 // debug information
195
196 class ConstantOopReadValue: public ScopeValue {
197 private:
198 Handle _value;
199 public:
200 Handle value() const { return _value; }
201 bool is_constant_oop() const { return true; }
202 bool equals(ScopeValue* other) const { return false; }
203
204 // Serialization of debugging information
205 ConstantOopReadValue(DebugInfoReadStream* stream);
206 void write_on(DebugInfoWriteStream* stream);
207
208 // Printing
209 void print_on(outputStream* st) const;
210 };
211
212 // MonitorValue describes the pair used for monitor_enter and monitor_exit.
213
214 class MonitorValue: public ResourceObj {
215 private:
216 ScopeValue* _owner;
217 Location _basic_lock;
218 bool _eliminated;
219 public:
220 // Constructor
221 MonitorValue(ScopeValue* owner, Location basic_lock, bool eliminated = false);
222
223 // Accessors
224 ScopeValue* owner() const { return _owner; }
225 Location basic_lock() const { return _basic_lock; }
226 bool eliminated() const { return _eliminated; }
227
228 // Serialization of debugging information
229 MonitorValue(DebugInfoReadStream* stream);
230 void write_on(DebugInfoWriteStream* stream);
231
232 // Printing
233 void print_on(outputStream* st) const;
234 };
235
236 // DebugInfoReadStream specializes CompressedReadStream for reading
237 // debugging information. Used by ScopeDesc.
238
239 class DebugInfoReadStream : public CompressedReadStream {
240 private:
241 const nmethod* _code;
242 const nmethod* code() const { return _code; }
243 GrowableArray<ScopeValue*>* _obj_pool;
244 public:
245 DebugInfoReadStream(const nmethod* code, int offset, GrowableArray<ScopeValue*>* obj_pool = NULL) :
246 CompressedReadStream(code->scopes_data_begin(), offset) {
247 _code = code;
248 _obj_pool = obj_pool;
249
250 } ;
251
252 oop read_oop() {
253 return code()->oop_at(read_int());
254 }
255 ScopeValue* read_object_value();
256 ScopeValue* get_cached_object();
257 // BCI encoding is mostly unsigned, but -1 is a distinguished value
258 int read_bci() { return read_int() + InvocationEntryBci; }
259 };
260
261 // DebugInfoWriteStream specializes CompressedWriteStream for
262 // writing debugging information. Used by ScopeDescRecorder.
263
264 class DebugInfoWriteStream : public CompressedWriteStream {
265 private:
266 DebugInformationRecorder* _recorder;
267 DebugInformationRecorder* recorder() const { return _recorder; }
268 public:
269 DebugInfoWriteStream(DebugInformationRecorder* recorder, int initial_size);
270 void write_handle(jobject h);
271 void write_bci(int bci) { write_int(bci - InvocationEntryBci); }
272 };