1 /*
2 * Copyright (c) 2005, 2017, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "jvm.h"
27 #include "c1/c1_CFGPrinter.hpp"
28 #include "c1/c1_IR.hpp"
29 #include "c1/c1_InstructionPrinter.hpp"
30 #include "c1/c1_LIR.hpp"
31 #include "c1/c1_LinearScan.hpp"
32 #include "c1/c1_ValueStack.hpp"
33
34 #ifndef PRODUCT
35
36 void CFGPrinter::print_compilation(Compilation* compilation) {
37 CFGPrinterOutput* output = compilation->cfg_printer_output();
38 output->print_compilation();
39 }
40
41 void CFGPrinter::print_cfg(BlockList* blocks, const char* name, bool do_print_HIR, bool do_print_LIR) {
42 CFGPrinterOutput* output = Compilation::current()->cfg_printer_output();
43 output->set_print_flags(do_print_HIR, do_print_LIR);
44 output->print_cfg(blocks, name);
45 }
46
47 void CFGPrinter::print_cfg(IR* blocks, const char* name, bool do_print_HIR, bool do_print_LIR) {
48 CFGPrinterOutput* output = Compilation::current()->cfg_printer_output();
49 output->set_print_flags(do_print_HIR, do_print_LIR);
50 output->print_cfg(blocks, name);
51 }
52
53 void CFGPrinter::print_intervals(IntervalList* intervals, const char* name) {
54 CFGPrinterOutput* output = Compilation::current()->cfg_printer_output();
55 output->print_intervals(intervals, name);
56 }
57
58
59 CFGPrinterOutput::CFGPrinterOutput(Compilation* compilation)
60 : _output(NULL),
61 _compilation(compilation),
62 _do_print_HIR(false),
63 _do_print_LIR(false)
64 {
65 char file_name[O_BUFLEN];
66 jio_snprintf(file_name, sizeof(file_name), "output_tid" UINTX_FORMAT "_pid%u.cfg",
67 os::current_thread_id(), os::current_process_id());
68 _output = new(ResourceObj::C_HEAP, mtCompiler) fileStream(file_name, "at");
69 }
70
71 void CFGPrinterOutput::inc_indent() {
72 output()->inc();
73 output()->inc();
74 }
75
76 void CFGPrinterOutput::dec_indent() {
77 output()->dec();
78 output()->dec();
79 }
80
81 void CFGPrinterOutput::print(const char* format, ...) {
82 output()->indent();
83
84 va_list ap;
85 va_start(ap, format);
86 output()->vprint_cr(format, ap);
87 va_end(ap);
88 }
89
90 void CFGPrinterOutput::print_begin(const char* tag) {
91 output()->indent();
92 output()->print_cr("begin_%s", tag);
93 inc_indent();
94 }
95
96 void CFGPrinterOutput::print_end(const char* tag) {
97 dec_indent();
98 output()->indent();
99 output()->print_cr("end_%s", tag);
100 }
101
102
103 char* CFGPrinterOutput::method_name(ciMethod* method, bool short_name) {
104 stringStream name;
105 if (short_name) {
106 method->print_short_name(&name);
107 } else {
108 method->print_name(&name);
109 }
110 return name.as_string();
111
112 }
113
114
115 void CFGPrinterOutput::print_compilation() {
116 print_begin("compilation");
117
118 print("name \"%s\"", method_name(_compilation->method(), true));
119 print("method \"%s\"", method_name(_compilation->method()));
120 print("date " INT64_FORMAT, (int64_t) os::javaTimeMillis());
121
122 print_end("compilation");
123 }
124
125
126
127
128
129 void CFGPrinterOutput::print_state(BlockBegin* block) {
130 print_begin("states");
131
132 InstructionPrinter ip(true, output());
133
134 ValueStack* state = block->state();
135 int index;
136 Value value;
137
138 for_each_state(state) {
139 print_begin("locals");
140 print("size %d", state->locals_size());
141 print("method \"%s\"", method_name(state->scope()->method()));
142
143 for_each_local_value(state, index, value) {
144 ip.print_phi(index, value, block);
145 print_operand(value);
146 output()->cr();
147 }
148 print_end("locals");
149
150 if (state->stack_size() > 0) {
151 print_begin("stack");
152 print("size %d", state->stack_size());
153 print("method \"%s\"", method_name(state->scope()->method()));
154
155 for_each_stack_value(state, index, value) {
156 ip.print_phi(index, value, block);
157 print_operand(value);
158 output()->cr();
159 }
160
161 print_end("stack");
162 }
163
164 if (state->locks_size() > 0) {
165 print_begin("locks");
166 print("size %d", state->locks_size());
167 print("method \"%s\"", method_name(state->scope()->method()));
168
169 for_each_lock_value(state, index, value) {
170 ip.print_phi(index, value, block);
171 print_operand(value);
172 output()->cr();
173 }
174 print_end("locks");
175 }
176 }
177
178 print_end("states");
179 }
180
181
182 void CFGPrinterOutput::print_operand(Value instr) {
183 if (instr->operand()->is_virtual()) {
184 output()->print(" \"");
185 instr->operand()->print(output());
186 output()->print("\" ");
187 }
188 }
189
190 void CFGPrinterOutput::print_HIR(Value instr) {
191 InstructionPrinter ip(true, output());
192
193 if (instr->is_pinned()) {
194 output()->put('.');
195 }
196
197 output()->print("%d %d ", instr->printable_bci(), instr->use_count());
198
199 print_operand(instr);
200
201 ip.print_temp(instr);
202 output()->print(" ");
203 ip.print_instr(instr);
204
205 output()->print_cr(" <|@");
206 }
207
208 void CFGPrinterOutput::print_HIR(BlockBegin* block) {
209 print_begin("HIR");
210
211 Value cur = block->next();
212 while (cur != NULL) {
213 print_HIR(cur);
214 cur = cur->next();
215 }
216
217 print_end("HIR");
218 }
219
220 void CFGPrinterOutput::print_LIR(BlockBegin* block) {
221 print_begin("LIR");
222
223 for (int i = 0; i < block->lir()->length(); i++) {
224 block->lir()->at(i)->print_on(output());
225 output()->print_cr(" <|@ ");
226 }
227
228 print_end("LIR");
229 }
230
231
232 void CFGPrinterOutput::print_block(BlockBegin* block) {
233 print_begin("block");
234
235 print("name \"B%d\"", block->block_id());
236
237 print("from_bci %d", block->bci());
238 print("to_bci %d", (block->end() == NULL ? -1 : block->end()->printable_bci()));
239
240 output()->indent();
241 output()->print("predecessors ");
242 int i;
243 for (i = 0; i < block->number_of_preds(); i++) {
244 output()->print("\"B%d\" ", block->pred_at(i)->block_id());
245 }
246 output()->cr();
247
248 output()->indent();
249 output()->print("successors ");
250 for (i = 0; i < block->number_of_sux(); i++) {
251 output()->print("\"B%d\" ", block->sux_at(i)->block_id());
252 }
253 output()->cr();
254
255 output()->indent();
256 output()->print("xhandlers");
257 for (i = 0; i < block->number_of_exception_handlers(); i++) {
258 output()->print("\"B%d\" ", block->exception_handler_at(i)->block_id());
259 }
260 output()->cr();
261
262 output()->indent();
263 output()->print("flags ");
264 if (block->is_set(BlockBegin::std_entry_flag)) output()->print("\"std\" ");
265 if (block->is_set(BlockBegin::osr_entry_flag)) output()->print("\"osr\" ");
266 if (block->is_set(BlockBegin::exception_entry_flag)) output()->print("\"ex\" ");
267 if (block->is_set(BlockBegin::subroutine_entry_flag)) output()->print("\"sr\" ");
268 if (block->is_set(BlockBegin::backward_branch_target_flag)) output()->print("\"bb\" ");
269 if (block->is_set(BlockBegin::parser_loop_header_flag)) output()->print("\"plh\" ");
270 if (block->is_set(BlockBegin::critical_edge_split_flag)) output()->print("\"ces\" ");
271 if (block->is_set(BlockBegin::linear_scan_loop_header_flag)) output()->print("\"llh\" ");
272 if (block->is_set(BlockBegin::linear_scan_loop_end_flag)) output()->print("\"lle\" ");
273 output()->cr();
274
275 if (block->dominator() != NULL) {
276 print("dominator \"B%d\"", block->dominator()->block_id());
277 }
278 if (block->loop_index() != -1) {
279 print("loop_index %d", block->loop_index());
280 print("loop_depth %d", block->loop_depth());
281 }
282
283 if (block->first_lir_instruction_id() != -1) {
284 print("first_lir_id %d", block->first_lir_instruction_id());
285 print("last_lir_id %d", block->last_lir_instruction_id());
286 }
287
288 if (_do_print_HIR) {
289 print_state(block);
290 print_HIR(block);
291 }
292
293 if (_do_print_LIR) {
294 print_LIR(block);
295 }
296
297 print_end("block");
298 }
299
300
301
302 void CFGPrinterOutput::print_cfg(BlockList* blocks, const char* name) {
303 print_begin("cfg");
304 print("name \"%s\"", name);
305
306 PrintBlockClosure print_block;
307 blocks->iterate_forward(&print_block);
308
309 print_end("cfg");
310 output()->flush();
311 }
312
313 void CFGPrinterOutput::print_cfg(IR* blocks, const char* name) {
314 print_begin("cfg");
315 print("name \"%s\"", name);
316
317 PrintBlockClosure print_block;
318 blocks->iterate_preorder(&print_block);
319
320 print_end("cfg");
321 output()->flush();
322 }
323
324
325
326
327 void CFGPrinterOutput::print_intervals(IntervalList* intervals, const char* name) {
328 print_begin("intervals");
329 print("name \"%s\"", name);
330
331 for (int i = 0; i < intervals->length(); i++) {
332 if (intervals->at(i) != NULL) {
333 intervals->at(i)->print(output());
334 }
335 }
336
337 print_end("intervals");
338 output()->flush();
339 }
340
341
342 #endif