1
|
1 |
/*
|
|
2 |
* Copyright 2007 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 |
#ifndef PRODUCT
|
|
26 |
|
|
27 |
class Compile;
|
|
28 |
class PhaseIFG;
|
|
29 |
class PhaseChaitin;
|
|
30 |
class Matcher;
|
|
31 |
class Node;
|
|
32 |
class InlineTree;
|
|
33 |
class ciMethod;
|
|
34 |
|
|
35 |
class IdealGraphPrinter
|
|
36 |
{
|
|
37 |
private:
|
|
38 |
|
|
39 |
enum State
|
|
40 |
{
|
|
41 |
Invalid,
|
|
42 |
Valid,
|
|
43 |
New
|
|
44 |
};
|
|
45 |
|
|
46 |
private:
|
|
47 |
|
|
48 |
static const char *INDENT;
|
|
49 |
static const char *TOP_ELEMENT;
|
|
50 |
static const char *GROUP_ELEMENT;
|
|
51 |
static const char *GRAPH_ELEMENT;
|
|
52 |
static const char *PROPERTIES_ELEMENT;
|
|
53 |
static const char *EDGES_ELEMENT;
|
|
54 |
static const char *PROPERTY_ELEMENT;
|
|
55 |
static const char *EDGE_ELEMENT;
|
|
56 |
static const char *NODE_ELEMENT;
|
|
57 |
static const char *NODES_ELEMENT;
|
|
58 |
static const char *CONTROL_FLOW_ELEMENT;
|
|
59 |
static const char *REMOVE_EDGE_ELEMENT;
|
|
60 |
static const char *REMOVE_NODE_ELEMENT;
|
|
61 |
static const char *METHOD_NAME_PROPERTY;
|
|
62 |
static const char *BLOCK_NAME_PROPERTY;
|
|
63 |
static const char *BLOCK_DOMINATOR_PROPERTY;
|
|
64 |
static const char *BLOCK_ELEMENT;
|
|
65 |
static const char *SUCCESSORS_ELEMENT;
|
|
66 |
static const char *SUCCESSOR_ELEMENT;
|
|
67 |
static const char *METHOD_IS_PUBLIC_PROPERTY;
|
|
68 |
static const char *METHOD_IS_STATIC_PROPERTY;
|
|
69 |
static const char *TRUE_VALUE;
|
|
70 |
static const char *NODE_NAME_PROPERTY;
|
|
71 |
static const char *EDGE_NAME_PROPERTY;
|
|
72 |
static const char *NODE_ID_PROPERTY;
|
|
73 |
static const char *FROM_PROPERTY;
|
|
74 |
static const char *TO_PROPERTY;
|
|
75 |
static const char *PROPERTY_NAME_PROPERTY;
|
|
76 |
static const char *GRAPH_NAME_PROPERTY;
|
|
77 |
static const char *INDEX_PROPERTY;
|
|
78 |
static const char *METHOD_ELEMENT;
|
|
79 |
static const char *INLINE_ELEMENT;
|
|
80 |
static const char *BYTECODES_ELEMENT;
|
|
81 |
static const char *METHOD_BCI_PROPERTY;
|
|
82 |
static const char *METHOD_SHORT_NAME_PROPERTY;
|
|
83 |
static const char *ASSEMBLY_ELEMENT;
|
|
84 |
|
|
85 |
class Property {
|
|
86 |
|
|
87 |
private:
|
|
88 |
|
|
89 |
const char *_name;
|
|
90 |
const char *_value;
|
|
91 |
|
|
92 |
public:
|
|
93 |
|
|
94 |
Property();
|
|
95 |
Property(const Property* p);
|
|
96 |
~Property();
|
|
97 |
Property(const char *name, const char *value);
|
|
98 |
Property(const char *name, int value);
|
|
99 |
bool equals(Property* p);
|
|
100 |
void print(IdealGraphPrinter *printer);
|
|
101 |
void print_as_attribute(IdealGraphPrinter *printer);
|
|
102 |
bool is_null();
|
|
103 |
void clean();
|
|
104 |
const char *name();
|
|
105 |
|
|
106 |
static const char* dup(const char *str) {
|
|
107 |
char * copy = new char[strlen(str)+1];
|
|
108 |
strcpy(copy, str);
|
|
109 |
return copy;
|
|
110 |
}
|
|
111 |
|
|
112 |
};
|
|
113 |
|
|
114 |
class Properties {
|
|
115 |
|
|
116 |
private:
|
|
117 |
|
|
118 |
GrowableArray<Property *> *list;
|
|
119 |
|
|
120 |
public:
|
|
121 |
|
|
122 |
Properties();
|
|
123 |
~Properties();
|
|
124 |
void add(Property *p);
|
|
125 |
void remove(const char *name);
|
|
126 |
bool equals(Properties* p);
|
|
127 |
void print(IdealGraphPrinter *printer);
|
|
128 |
void print_as_attributes(IdealGraphPrinter *printer);
|
|
129 |
void clean();
|
|
130 |
|
|
131 |
};
|
|
132 |
|
|
133 |
|
|
134 |
class Description {
|
|
135 |
|
|
136 |
private:
|
|
137 |
|
|
138 |
State _state;
|
|
139 |
|
|
140 |
public:
|
|
141 |
|
|
142 |
Description();
|
|
143 |
|
|
144 |
State state();
|
|
145 |
void set_state(State s);
|
|
146 |
void print(IdealGraphPrinter *printer);
|
|
147 |
virtual void print_changed(IdealGraphPrinter *printer) = 0;
|
|
148 |
virtual void print_removed(IdealGraphPrinter *printer) = 0;
|
|
149 |
|
|
150 |
};
|
|
151 |
|
|
152 |
class NodeDescription : public Description{
|
|
153 |
|
|
154 |
public:
|
|
155 |
|
|
156 |
static int count;
|
|
157 |
|
|
158 |
private:
|
|
159 |
|
|
160 |
GrowableArray<NodeDescription *> _succs;
|
|
161 |
int _block_index;
|
|
162 |
uintptr_t _id;
|
|
163 |
Properties _properties;
|
|
164 |
Node* _node;
|
|
165 |
|
|
166 |
public:
|
|
167 |
|
|
168 |
NodeDescription(Node* node);
|
|
169 |
~NodeDescription();
|
|
170 |
Node* node();
|
|
171 |
|
|
172 |
// void set_node(Node* node);
|
|
173 |
GrowableArray<NodeDescription *>* succs();
|
|
174 |
void init_succs();
|
|
175 |
void clear_succs();
|
|
176 |
void add_succ(NodeDescription *desc);
|
|
177 |
int block_index();
|
|
178 |
void set_block_index(int i);
|
|
179 |
Properties* properties();
|
|
180 |
virtual void print_changed(IdealGraphPrinter *printer);
|
|
181 |
virtual void print_removed(IdealGraphPrinter *printer);
|
|
182 |
bool equals(NodeDescription *desc);
|
|
183 |
uint id();
|
|
184 |
|
|
185 |
};
|
|
186 |
|
|
187 |
class Block {
|
|
188 |
|
|
189 |
private:
|
|
190 |
|
|
191 |
NodeDescription *_start;
|
|
192 |
NodeDescription *_proj;
|
|
193 |
GrowableArray<int> _succs;
|
|
194 |
GrowableArray<NodeDescription *> _nodes;
|
|
195 |
GrowableArray<int> _dominates;
|
|
196 |
GrowableArray<int> _children;
|
|
197 |
int _semi;
|
|
198 |
int _parent;
|
|
199 |
GrowableArray<int> _pred;
|
|
200 |
GrowableArray<int> _bucket;
|
|
201 |
int _index;
|
|
202 |
int _dominator;
|
|
203 |
int _ancestor;
|
|
204 |
int _label;
|
|
205 |
|
|
206 |
public:
|
|
207 |
|
|
208 |
Block();
|
|
209 |
Block(int index);
|
|
210 |
|
|
211 |
void add_node(NodeDescription *n);
|
|
212 |
GrowableArray<NodeDescription *>* nodes();
|
|
213 |
GrowableArray<int>* children();
|
|
214 |
void add_child(int i);
|
|
215 |
void add_succ(int index);
|
|
216 |
GrowableArray<int>* succs();
|
|
217 |
GrowableArray<int>* dominates();
|
|
218 |
void add_dominates(int i);
|
|
219 |
NodeDescription *start();
|
|
220 |
NodeDescription *proj();
|
|
221 |
void set_start(NodeDescription *n);
|
|
222 |
void set_proj(NodeDescription *n);
|
|
223 |
|
|
224 |
int label();
|
|
225 |
void set_label(int i);
|
|
226 |
int ancestor();
|
|
227 |
void set_ancestor(int i);
|
|
228 |
int index();
|
|
229 |
int dominator();
|
|
230 |
void set_dominator(int i);
|
|
231 |
int parent();
|
|
232 |
void set_parent(int i);
|
|
233 |
int semi();
|
|
234 |
GrowableArray<int>* bucket();
|
|
235 |
void add_to_bucket(int i);
|
|
236 |
void clear_bucket();
|
|
237 |
GrowableArray<int>* pred();
|
|
238 |
void set_semi(int i);
|
|
239 |
void add_pred(int i);
|
|
240 |
|
|
241 |
};
|
|
242 |
|
|
243 |
class EdgeDescription : public Description {
|
|
244 |
|
|
245 |
private:
|
|
246 |
|
|
247 |
int _from;
|
|
248 |
int _to;
|
|
249 |
int _index;
|
|
250 |
public:
|
|
251 |
|
|
252 |
EdgeDescription(int from, int to, int index);
|
|
253 |
~EdgeDescription();
|
|
254 |
|
|
255 |
virtual void print_changed(IdealGraphPrinter *printer);
|
|
256 |
virtual void print_removed(IdealGraphPrinter *printer);
|
|
257 |
bool equals(EdgeDescription *desc);
|
|
258 |
int from();
|
|
259 |
int to();
|
|
260 |
};
|
|
261 |
|
|
262 |
|
|
263 |
static int _file_count;
|
|
264 |
networkStream *_stream;
|
|
265 |
outputStream *_output;
|
|
266 |
ciMethod *_current_method;
|
|
267 |
GrowableArray<NodeDescription *> _nodes;
|
|
268 |
GrowableArray<EdgeDescription *> _edges;
|
|
269 |
int _depth;
|
|
270 |
Arena *_arena;
|
|
271 |
char buffer[128];
|
|
272 |
bool _should_send_method;
|
|
273 |
PhaseChaitin* _chaitin;
|
|
274 |
bool _clear_nodes;
|
|
275 |
Matcher* _matcher;
|
|
276 |
bool _traverse_outs;
|
|
277 |
|
|
278 |
void start_element_helper(const char *name, Properties *properties, bool endElement, bool print_indent = false, bool print_return = true);
|
|
279 |
NodeDescription *create_node_description(Node* node);
|
|
280 |
|
|
281 |
static void pre_node(Node* node, void *env);
|
|
282 |
static void post_node(Node* node, void *env);
|
|
283 |
|
|
284 |
void schedule_latest(int **common_dominator, GrowableArray<Block>* blocks);
|
|
285 |
void build_common_dominator(int **common_dominator, int index, GrowableArray<Block>* blocks);
|
|
286 |
void compress(int index, GrowableArray<Block>* blocks);
|
|
287 |
int eval(int index, GrowableArray<Block>* blocks);
|
|
288 |
void link(int index1, int index2, GrowableArray<Block>* blocks);
|
|
289 |
void build_dominators(GrowableArray<Block>* blocks);
|
|
290 |
void build_blocks(Node *node);
|
|
291 |
void walk(Node *n);
|
|
292 |
void start_element(const char *name, Properties *properties = NULL, bool print_indent = false, bool print_return = true);
|
|
293 |
void simple_element(const char *name, Properties *properties = NULL, bool print_indent = false);
|
|
294 |
void end_element(const char *name, bool print_indent = false, bool print_return = true);
|
|
295 |
void print_edge(int from, int to, int index);
|
|
296 |
void print_indent();
|
|
297 |
void print_method(ciMethod *method, int bci, InlineTree *tree);
|
|
298 |
void print_inline_tree(InlineTree *tree);
|
|
299 |
void clear_nodes();
|
|
300 |
|
|
301 |
IdealGraphPrinter();
|
|
302 |
~IdealGraphPrinter();
|
|
303 |
|
|
304 |
public:
|
|
305 |
|
|
306 |
static void clean_up();
|
|
307 |
static IdealGraphPrinter *printer();
|
|
308 |
|
|
309 |
bool traverse_outs();
|
|
310 |
void set_traverse_outs(bool b);
|
|
311 |
void print_ifg(PhaseIFG* ifg);
|
|
312 |
outputStream *output();
|
|
313 |
void print_inlining(Compile* compile);
|
|
314 |
void begin_method(Compile* compile);
|
|
315 |
void end_method();
|
|
316 |
void print_method(Compile* compile, const char *name, int level=1, bool clear_nodes = false);
|
|
317 |
void print(Compile* compile, const char *name, Node *root, int level=1, bool clear_nodes = false);
|
|
318 |
void print_xml(const char *name);
|
|
319 |
|
|
320 |
|
|
321 |
};
|
|
322 |
|
|
323 |
#endif
|