Mercurial > hg > truffle

comparison src/share/vm/opto/idealGraphPrinter.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 2a1a77d3458f
comparison
equal deleted inserted replaced
-1:000000000000 0:a61af66fc99e
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