Mercurial > hg > truffle

annotate src/share/vm/code/debugInfo.hpp @ 7046:b6a8f2d23057

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
author Lukas Stadler <lukas.stadler@jku.at>
date Tue, 27 Nov 2012 13:43:04 +0100
parents da91efe96a93
children b8f261ba79c6
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 1972
diff changeset
2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load
duke
parents:
diff changeset
4 *
a61af66fc99e Initial load
duke
parents:
diff changeset
5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load
duke
parents:
diff changeset
6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load
duke
parents:
diff changeset
7 * published by the Free Software Foundation.
a61af66fc99e Initial load
duke
parents:
diff changeset
8 *
a61af66fc99e Initial load
duke
parents:
diff changeset
9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load
duke
parents:
diff changeset
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load
duke
parents:
diff changeset
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load
duke
parents:
diff changeset
12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load
duke
parents:
diff changeset
13 * accompanied this code).
a61af66fc99e Initial load
duke
parents:
diff changeset
14 *
a61af66fc99e Initial load
duke
parents:
diff changeset
15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load
duke
parents:
diff changeset
16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load
duke
parents:
diff changeset
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load
duke
parents:
diff changeset
18 *
1552
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 931
diff changeset
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 931
diff changeset
20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 931
diff changeset
21 * questions.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
22 *
a61af66fc99e Initial load
duke
parents:
diff changeset
23 */
a61af66fc99e Initial load
duke
parents:
diff changeset
24
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
25 #ifndef SHARE_VM_CODE_DEBUGINFO_HPP
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
26 #define SHARE_VM_CODE_DEBUGINFO_HPP
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
27
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
28 #include "code/compressedStream.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
29 #include "code/location.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
30 #include "code/nmethod.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
31 #include "code/oopRecorder.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
32 #include "runtime/stackValue.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
33 #include "utilities/growableArray.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
34
0
a61af66fc99e Initial load
duke
parents:
diff changeset
35 // Classes used for serializing debugging information.
a61af66fc99e Initial load
duke
parents:
diff changeset
36 // These abstractions are introducted to provide symmetric
a61af66fc99e Initial load
duke
parents:
diff changeset
37 // read and write operations.
a61af66fc99e Initial load
duke
parents:
diff changeset
38
a61af66fc99e Initial load
duke
parents:
diff changeset
39 // ScopeValue describes the value of a variable/expression in a scope
a61af66fc99e Initial load
duke
parents:
diff changeset
40 // - LocationValue describes a value in a given location (in frame or register)
a61af66fc99e Initial load
duke
parents:
diff changeset
41 // - ConstantValue describes a constant
a61af66fc99e Initial load
duke
parents:
diff changeset
42
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 1972
diff changeset
43 class ConstantOopReadValue;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 1972
diff changeset
44
0
a61af66fc99e Initial load
duke
parents:
diff changeset
45 class ScopeValue: public ResourceObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
46 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
47 // Testers
a61af66fc99e Initial load
duke
parents:
diff changeset
48 virtual bool is_location() const { return false; }
a61af66fc99e Initial load
duke
parents:
diff changeset
49 virtual bool is_object() const { return false; }
a61af66fc99e Initial load
duke
parents:
diff changeset
50 virtual bool is_constant_int() const { return false; }
a61af66fc99e Initial load
duke
parents:
diff changeset
51 virtual bool is_constant_double() const { return false; }
a61af66fc99e Initial load
duke
parents:
diff changeset
52 virtual bool is_constant_long() const { return false; }
a61af66fc99e Initial load
duke
parents:
diff changeset
53 virtual bool is_constant_oop() const { return false; }
a61af66fc99e Initial load
duke
parents:
diff changeset
54 virtual bool equals(ScopeValue* other) const { return false; }
a61af66fc99e Initial load
duke
parents:
diff changeset
55
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 1972
diff changeset
56 ConstantOopReadValue* as_ConstantOopReadValue() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 1972
diff changeset
57 assert(is_constant_oop(), "must be");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 1972
diff changeset
58 return (ConstantOopReadValue*) this;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 1972
diff changeset
59 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 1972
diff changeset
60
0
a61af66fc99e Initial load
duke
parents:
diff changeset
61 // Serialization of debugging information
a61af66fc99e Initial load
duke
parents:
diff changeset
62 virtual void write_on(DebugInfoWriteStream* stream) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
63 static ScopeValue* read_from(DebugInfoReadStream* stream);
7046
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
64
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
65 #ifdef GRAAL
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
66 // Printing
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
67 virtual void print_on(outputStream* st) const = 0;
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
68 #endif // GRAAL
0
a61af66fc99e Initial load
duke
parents:
diff changeset
69 };
a61af66fc99e Initial load
duke
parents:
diff changeset
70
a61af66fc99e Initial load
duke
parents:
diff changeset
71
a61af66fc99e Initial load
duke
parents:
diff changeset
72 // A Location value describes a value in a given location; i.e. the corresponding
a61af66fc99e Initial load
duke
parents:
diff changeset
73 // logical entity (e.g., a method temporary) lives in this location.
a61af66fc99e Initial load
duke
parents:
diff changeset
74
a61af66fc99e Initial load
duke
parents:
diff changeset
75 class LocationValue: public ScopeValue {
a61af66fc99e Initial load
duke
parents:
diff changeset
76 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
77 Location _location;
a61af66fc99e Initial load
duke
parents:
diff changeset
78 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
79 LocationValue(Location location) { _location = location; }
a61af66fc99e Initial load
duke
parents:
diff changeset
80 bool is_location() const { return true; }
a61af66fc99e Initial load
duke
parents:
diff changeset
81 Location location() const { return _location; }
a61af66fc99e Initial load
duke
parents:
diff changeset
82
a61af66fc99e Initial load
duke
parents:
diff changeset
83 // Serialization of debugging information
a61af66fc99e Initial load
duke
parents:
diff changeset
84 LocationValue(DebugInfoReadStream* stream);
a61af66fc99e Initial load
duke
parents:
diff changeset
85 void write_on(DebugInfoWriteStream* stream);
a61af66fc99e Initial load
duke
parents:
diff changeset
86
a61af66fc99e Initial load
duke
parents:
diff changeset
87 // Printing
a61af66fc99e Initial load
duke
parents:
diff changeset
88 void print_on(outputStream* st) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
89 };
a61af66fc99e Initial load
duke
parents:
diff changeset
90
7046
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
91 #ifdef GRAAL
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
92
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
93 class DeferredLocationValue: public ScopeValue {
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
94 private:
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
95 ScopeValue* _base;
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
96 ScopeValue* _index;
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
97 jint _scale;
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
98 jlong _disp;
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
99 public:
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
100 DeferredLocationValue(ScopeValue* base, ScopeValue* index, jint scale, jlong disp)
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
101 : _base(base), _index(index), _scale(scale), _disp(disp) { }
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
102
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
103 ScopeValue* base() { return _base; }
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
104 ScopeValue* index() { return _index; }
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
105 jint scale() { return _scale; }
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
106 jlong disp() { return _disp; }
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
107
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
108 // Serialization of debugging information
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
109 DeferredLocationValue(DebugInfoReadStream* stream);
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
110 void write_on(DebugInfoWriteStream* stream);
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
111
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
112 // Printing
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
113 void print_on(outputStream* st) const;
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
114 };
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
115
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
116
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
117 class DeferredReadValue: public DeferredLocationValue {
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
118 public:
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
119 DeferredReadValue(ScopeValue* base, ScopeValue* index, jint scale, jint disp)
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
120 : DeferredLocationValue(base, index, scale, disp) { }
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
121
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
122 // Serialization of debugging information
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
123 DeferredReadValue(DebugInfoReadStream* stream);
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
124 void write_on(DebugInfoWriteStream* stream);
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
125
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
126 // Printing
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
127 void print_on(outputStream* st) const;
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
128 };
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
129
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
130 class DeferredWriteValue: public DeferredLocationValue {
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
131 private:
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
132 ScopeValue* _value;
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
133 public:
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
134 DeferredWriteValue(ScopeValue* base, ScopeValue* index, jint scale, jint disp, ScopeValue* value)
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
135 : DeferredLocationValue(base, index, scale, disp), _value(value) { }
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
136
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
137 ScopeValue* value() { return _value; }
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
138
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
139 // Serialization of debugging information
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
140 DeferredWriteValue(DebugInfoReadStream* stream);
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
141 void write_on(DebugInfoWriteStream* stream);
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
142
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
143 // Printing
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
144 void print_on(outputStream* st) const;
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
145 };
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
146
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
147 #endif // GRAAL
b6a8f2d23057 VM support for deferred reads and writes: ScopeDesc, DebugInfo, DebugInfoRecorder
Lukas Stadler <lukas.stadler@jku.at>
parents: 6725
diff changeset
148
0
a61af66fc99e Initial load
duke
parents:
diff changeset
149
a61af66fc99e Initial load
duke
parents:
diff changeset
150 // An ObjectValue describes an object eliminated by escape analysis.
a61af66fc99e Initial load
duke
parents:
diff changeset
151
a61af66fc99e Initial load
duke
parents:
diff changeset
152 class ObjectValue: public ScopeValue {
a61af66fc99e Initial load
duke
parents:
diff changeset
153 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
154 int _id;
a61af66fc99e Initial load
duke
parents:
diff changeset
155 ScopeValue* _klass;
a61af66fc99e Initial load
duke
parents:
diff changeset
156 GrowableArray<ScopeValue*> _field_values;
a61af66fc99e Initial load
duke
parents:
diff changeset
157 Handle _value;
a61af66fc99e Initial load
duke
parents:
diff changeset
158 bool _visited;
a61af66fc99e Initial load
duke
parents:
diff changeset
159
a61af66fc99e Initial load
duke
parents:
diff changeset
160 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
161 ObjectValue(int id, ScopeValue* klass)
a61af66fc99e Initial load
duke
parents:
diff changeset
162 : _id(id)
a61af66fc99e Initial load
duke
parents:
diff changeset
163 , _klass(klass)
a61af66fc99e Initial load
duke
parents:
diff changeset
164 , _field_values()
a61af66fc99e Initial load
duke
parents:
diff changeset
165 , _value()
a61af66fc99e Initial load
duke
parents:
diff changeset
166 , _visited(false) {
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 1972
diff changeset
167 assert(klass->is_constant_oop(), "should be constant java mirror oop");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
168 }
a61af66fc99e Initial load
duke
parents:
diff changeset
169
a61af66fc99e Initial load
duke
parents:
diff changeset
170 ObjectValue(int id)
a61af66fc99e Initial load
duke
parents:
diff changeset
171 : _id(id)
a61af66fc99e Initial load
duke
parents:
diff changeset
172 , _klass(NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
173 , _field_values()
a61af66fc99e Initial load
duke
parents:
diff changeset
174 , _value()
a61af66fc99e Initial load
duke
parents:
diff changeset
175 , _visited(false) {}
a61af66fc99e Initial load
duke
parents:
diff changeset
176
a61af66fc99e Initial load
duke
parents:
diff changeset
177 // Accessors
a61af66fc99e Initial load
duke
parents:
diff changeset
178 bool is_object() const { return true; }
a61af66fc99e Initial load
duke
parents:
diff changeset
179 int id() const { return _id; }
a61af66fc99e Initial load
duke
parents:
diff changeset
180 ScopeValue* klass() const { return _klass; }
a61af66fc99e Initial load
duke
parents:
diff changeset
181 GrowableArray<ScopeValue*>* field_values() { return &_field_values; }
a61af66fc99e Initial load
duke
parents:
diff changeset
182 ScopeValue* field_at(int i) const { return _field_values.at(i); }
a61af66fc99e Initial load
duke
parents:
diff changeset
183 int field_size() { return _field_values.length(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
184 Handle value() const { return _value; }
a61af66fc99e Initial load
duke
parents:
diff changeset
185 bool is_visited() const { return _visited; }
a61af66fc99e Initial load
duke
parents:
diff changeset
186
a61af66fc99e Initial load
duke
parents:
diff changeset
187 void set_value(oop value) { _value = Handle(value); }
a61af66fc99e Initial load
duke
parents:
diff changeset
188 void set_visited(bool visited) { _visited = false; }
a61af66fc99e Initial load
duke
parents:
diff changeset
189
a61af66fc99e Initial load
duke
parents:
diff changeset
190 // Serialization of debugging information
a61af66fc99e Initial load
duke
parents:
diff changeset
191 void read_object(DebugInfoReadStream* stream);
a61af66fc99e Initial load
duke
parents:
diff changeset
192 void write_on(DebugInfoWriteStream* stream);
a61af66fc99e Initial load
duke
parents:
diff changeset
193
a61af66fc99e Initial load
duke
parents:
diff changeset
194 // Printing
a61af66fc99e Initial load
duke
parents:
diff changeset
195 void print_on(outputStream* st) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
196 void print_fields_on(outputStream* st) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
197 };
a61af66fc99e Initial load
duke
parents:
diff changeset
198
a61af66fc99e Initial load
duke
parents:
diff changeset
199
a61af66fc99e Initial load
duke
parents:
diff changeset
200 // A ConstantIntValue describes a constant int; i.e., the corresponding logical entity
a61af66fc99e Initial load
duke
parents:
diff changeset
201 // is either a source constant or its computation has been constant-folded.
a61af66fc99e Initial load
duke
parents:
diff changeset
202
a61af66fc99e Initial load
duke
parents:
diff changeset
203 class ConstantIntValue: public ScopeValue {
a61af66fc99e Initial load
duke
parents:
diff changeset
204 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
205 jint _value;
a61af66fc99e Initial load
duke
parents:
diff changeset
206 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
207 ConstantIntValue(jint value) { _value = value; }
a61af66fc99e Initial load
duke
parents:
diff changeset
208 jint value() const { return _value; }
a61af66fc99e Initial load
duke
parents:
diff changeset
209 bool is_constant_int() const { return true; }
a61af66fc99e Initial load
duke
parents:
diff changeset
210 bool equals(ScopeValue* other) const { return false; }
a61af66fc99e Initial load
duke
parents:
diff changeset
211
a61af66fc99e Initial load
duke
parents:
diff changeset
212 // Serialization of debugging information
a61af66fc99e Initial load
duke
parents:
diff changeset
213 ConstantIntValue(DebugInfoReadStream* stream);
a61af66fc99e Initial load
duke
parents:
diff changeset
214 void write_on(DebugInfoWriteStream* stream);
a61af66fc99e Initial load
duke
parents:
diff changeset
215
a61af66fc99e Initial load
duke
parents:
diff changeset
216 // Printing
a61af66fc99e Initial load
duke
parents:
diff changeset
217 void print_on(outputStream* st) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
218 };
a61af66fc99e Initial load
duke
parents:
diff changeset
219
a61af66fc99e Initial load
duke
parents:
diff changeset
220 class ConstantLongValue: public ScopeValue {
a61af66fc99e Initial load
duke
parents:
diff changeset
221 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
222 jlong _value;
a61af66fc99e Initial load
duke
parents:
diff changeset
223 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
224 ConstantLongValue(jlong value) { _value = value; }
a61af66fc99e Initial load
duke
parents:
diff changeset
225 jlong value() const { return _value; }
a61af66fc99e Initial load
duke
parents:
diff changeset
226 bool is_constant_long() const { return true; }
a61af66fc99e Initial load
duke
parents:
diff changeset
227 bool equals(ScopeValue* other) const { return false; }
a61af66fc99e Initial load
duke
parents:
diff changeset
228
a61af66fc99e Initial load
duke
parents:
diff changeset
229 // Serialization of debugging information
a61af66fc99e Initial load
duke
parents:
diff changeset
230 ConstantLongValue(DebugInfoReadStream* stream);
a61af66fc99e Initial load
duke
parents:
diff changeset
231 void write_on(DebugInfoWriteStream* stream);
a61af66fc99e Initial load
duke
parents:
diff changeset
232
a61af66fc99e Initial load
duke
parents:
diff changeset
233 // Printing
a61af66fc99e Initial load
duke
parents:
diff changeset
234 void print_on(outputStream* st) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
235 };
a61af66fc99e Initial load
duke
parents:
diff changeset
236
a61af66fc99e Initial load
duke
parents:
diff changeset
237 class ConstantDoubleValue: public ScopeValue {
a61af66fc99e Initial load
duke
parents:
diff changeset
238 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
239 jdouble _value;
a61af66fc99e Initial load
duke
parents:
diff changeset
240 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
241 ConstantDoubleValue(jdouble value) { _value = value; }
a61af66fc99e Initial load
duke
parents:
diff changeset
242 jdouble value() const { return _value; }
a61af66fc99e Initial load
duke
parents:
diff changeset
243 bool is_constant_double() const { return true; }
a61af66fc99e Initial load
duke
parents:
diff changeset
244 bool equals(ScopeValue* other) const { return false; }
a61af66fc99e Initial load
duke
parents:
diff changeset
245
a61af66fc99e Initial load
duke
parents:
diff changeset
246 // Serialization of debugging information
a61af66fc99e Initial load
duke
parents:
diff changeset
247 ConstantDoubleValue(DebugInfoReadStream* stream);
a61af66fc99e Initial load
duke
parents:
diff changeset
248 void write_on(DebugInfoWriteStream* stream);
a61af66fc99e Initial load
duke
parents:
diff changeset
249
a61af66fc99e Initial load
duke
parents:
diff changeset
250 // Printing
a61af66fc99e Initial load
duke
parents:
diff changeset
251 void print_on(outputStream* st) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
252 };
a61af66fc99e Initial load
duke
parents:
diff changeset
253
a61af66fc99e Initial load
duke
parents:
diff changeset
254 // A ConstantOopWriteValue is created by the compiler to
a61af66fc99e Initial load
duke
parents:
diff changeset
255 // be written as debugging information.
a61af66fc99e Initial load
duke
parents:
diff changeset
256
a61af66fc99e Initial load
duke
parents:
diff changeset
257 class ConstantOopWriteValue: public ScopeValue {
a61af66fc99e Initial load
duke
parents:
diff changeset
258 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
259 jobject _value;
a61af66fc99e Initial load
duke
parents:
diff changeset
260 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
261 ConstantOopWriteValue(jobject value) { _value = value; }
a61af66fc99e Initial load
duke
parents:
diff changeset
262 jobject value() const { return _value; }
a61af66fc99e Initial load
duke
parents:
diff changeset
263 bool is_constant_oop() const { return true; }
a61af66fc99e Initial load
duke
parents:
diff changeset
264 bool equals(ScopeValue* other) const { return false; }
a61af66fc99e Initial load
duke
parents:
diff changeset
265
a61af66fc99e Initial load
duke
parents:
diff changeset
266 // Serialization of debugging information
a61af66fc99e Initial load
duke
parents:
diff changeset
267 void write_on(DebugInfoWriteStream* stream);
a61af66fc99e Initial load
duke
parents:
diff changeset
268
a61af66fc99e Initial load
duke
parents:
diff changeset
269 // Printing
a61af66fc99e Initial load
duke
parents:
diff changeset
270 void print_on(outputStream* st) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
271 };
a61af66fc99e Initial load
duke
parents:
diff changeset
272
a61af66fc99e Initial load
duke
parents:
diff changeset
273 // A ConstantOopReadValue is created by the VM when reading
a61af66fc99e Initial load
duke
parents:
diff changeset
274 // debug information
a61af66fc99e Initial load
duke
parents:
diff changeset
275
a61af66fc99e Initial load
duke
parents:
diff changeset
276 class ConstantOopReadValue: public ScopeValue {
a61af66fc99e Initial load
duke
parents:
diff changeset
277 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
278 Handle _value;
a61af66fc99e Initial load
duke
parents:
diff changeset
279 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
280 Handle value() const { return _value; }
a61af66fc99e Initial load
duke
parents:
diff changeset
281 bool is_constant_oop() const { return true; }
a61af66fc99e Initial load
duke
parents:
diff changeset
282 bool equals(ScopeValue* other) const { return false; }
a61af66fc99e Initial load
duke
parents:
diff changeset
283
a61af66fc99e Initial load
duke
parents:
diff changeset
284 // Serialization of debugging information
a61af66fc99e Initial load
duke
parents:
diff changeset
285 ConstantOopReadValue(DebugInfoReadStream* stream);
a61af66fc99e Initial load
duke
parents:
diff changeset
286 void write_on(DebugInfoWriteStream* stream);
a61af66fc99e Initial load
duke
parents:
diff changeset
287
a61af66fc99e Initial load
duke
parents:
diff changeset
288 // Printing
a61af66fc99e Initial load
duke
parents:
diff changeset
289 void print_on(outputStream* st) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
290 };
a61af66fc99e Initial load
duke
parents:
diff changeset
291
a61af66fc99e Initial load
duke
parents:
diff changeset
292 // MonitorValue describes the pair used for monitor_enter and monitor_exit.
a61af66fc99e Initial load
duke
parents:
diff changeset
293
a61af66fc99e Initial load
duke
parents:
diff changeset
294 class MonitorValue: public ResourceObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
295 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
296 ScopeValue* _owner;
a61af66fc99e Initial load
duke
parents:
diff changeset
297 Location _basic_lock;
a61af66fc99e Initial load
duke
parents:
diff changeset
298 bool _eliminated;
a61af66fc99e Initial load
duke
parents:
diff changeset
299 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
300 // Constructor
a61af66fc99e Initial load
duke
parents:
diff changeset
301 MonitorValue(ScopeValue* owner, Location basic_lock, bool eliminated = false);
a61af66fc99e Initial load
duke
parents:
diff changeset
302
a61af66fc99e Initial load
duke
parents:
diff changeset
303 // Accessors
a61af66fc99e Initial load
duke
parents:
diff changeset
304 ScopeValue* owner() const { return _owner; }
a61af66fc99e Initial load
duke
parents:
diff changeset
305 Location basic_lock() const { return _basic_lock; }
a61af66fc99e Initial load
duke
parents:
diff changeset
306 bool eliminated() const { return _eliminated; }
a61af66fc99e Initial load
duke
parents:
diff changeset
307
a61af66fc99e Initial load
duke
parents:
diff changeset
308 // Serialization of debugging information
a61af66fc99e Initial load
duke
parents:
diff changeset
309 MonitorValue(DebugInfoReadStream* stream);
a61af66fc99e Initial load
duke
parents:
diff changeset
310 void write_on(DebugInfoWriteStream* stream);
a61af66fc99e Initial load
duke
parents:
diff changeset
311
a61af66fc99e Initial load
duke
parents:
diff changeset
312 // Printing
a61af66fc99e Initial load
duke
parents:
diff changeset
313 void print_on(outputStream* st) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
314 };
a61af66fc99e Initial load
duke
parents:
diff changeset
315
a61af66fc99e Initial load
duke
parents:
diff changeset
316 // DebugInfoReadStream specializes CompressedReadStream for reading
a61af66fc99e Initial load
duke
parents:
diff changeset
317 // debugging information. Used by ScopeDesc.
a61af66fc99e Initial load
duke
parents:
diff changeset
318
a61af66fc99e Initial load
duke
parents:
diff changeset
319 class DebugInfoReadStream : public CompressedReadStream {
a61af66fc99e Initial load
duke
parents:
diff changeset
320 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
321 const nmethod* _code;
a61af66fc99e Initial load
duke
parents:
diff changeset
322 const nmethod* code() const { return _code; }
a61af66fc99e Initial load
duke
parents:
diff changeset
323 GrowableArray<ScopeValue*>* _obj_pool;
a61af66fc99e Initial load
duke
parents:
diff changeset
324 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
325 DebugInfoReadStream(const nmethod* code, int offset, GrowableArray<ScopeValue*>* obj_pool = NULL) :
a61af66fc99e Initial load
duke
parents:
diff changeset
326 CompressedReadStream(code->scopes_data_begin(), offset) {
a61af66fc99e Initial load
duke
parents:
diff changeset
327 _code = code;
a61af66fc99e Initial load
duke
parents:
diff changeset
328 _obj_pool = obj_pool;
a61af66fc99e Initial load
duke
parents:
diff changeset
329
a61af66fc99e Initial load
duke
parents:
diff changeset
330 } ;
a61af66fc99e Initial load
duke
parents:
diff changeset
331
a61af66fc99e Initial load
duke
parents:
diff changeset
332 oop read_oop() {
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 1972
diff changeset
333 oop o = code()->oop_at(read_int());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 1972
diff changeset
334 assert(o == NULL || o->is_oop(), "oop only");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 1972
diff changeset
335 return o;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 1972
diff changeset
336 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 1972
diff changeset
337 Method* read_method() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 1972
diff changeset
338 Method* o = (Method*)(code()->metadata_at(read_int()));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 1972
diff changeset
339 assert(o == NULL ||
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 1972
diff changeset
340 o->is_metadata(), "meta data only");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 1972
diff changeset
341 return o;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
342 }
a61af66fc99e Initial load
duke
parents:
diff changeset
343 ScopeValue* read_object_value();
a61af66fc99e Initial load
duke
parents:
diff changeset
344 ScopeValue* get_cached_object();
a61af66fc99e Initial load
duke
parents:
diff changeset
345 // BCI encoding is mostly unsigned, but -1 is a distinguished value
931
72088be4b386 6873116: Modify reexecute implementation to use pcDesc to record the reexecute bit
cfang
parents: 900
diff changeset
346 int read_bci() { return read_int() + InvocationEntryBci; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
347 };
a61af66fc99e Initial load
duke
parents:
diff changeset
348
a61af66fc99e Initial load
duke
parents:
diff changeset
349 // DebugInfoWriteStream specializes CompressedWriteStream for
a61af66fc99e Initial load
duke
parents:
diff changeset
350 // writing debugging information. Used by ScopeDescRecorder.
a61af66fc99e Initial load
duke
parents:
diff changeset
351
a61af66fc99e Initial load
duke
parents:
diff changeset
352 class DebugInfoWriteStream : public CompressedWriteStream {
a61af66fc99e Initial load
duke
parents:
diff changeset
353 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
354 DebugInformationRecorder* _recorder;
a61af66fc99e Initial load
duke
parents:
diff changeset
355 DebugInformationRecorder* recorder() const { return _recorder; }
a61af66fc99e Initial load
duke
parents:
diff changeset
356 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
357 DebugInfoWriteStream(DebugInformationRecorder* recorder, int initial_size);
a61af66fc99e Initial load
duke
parents:
diff changeset
358 void write_handle(jobject h);
931
72088be4b386 6873116: Modify reexecute implementation to use pcDesc to record the reexecute bit
cfang
parents: 900
diff changeset
359 void write_bci(int bci) { write_int(bci - InvocationEntryBci); }
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 1972
diff changeset
360
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 1972
diff changeset
361 void write_metadata(Metadata* m);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
362 };
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
363
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
364 #endif // SHARE_VM_CODE_DEBUGINFO_HPP