|
0
|
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
|
