1 /*
2 * Copyright (c) 1999, 2013, 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 "c1/c1_InstructionPrinter.hpp"
27 #include "c1/c1_ValueStack.hpp"
28 #include "ci/ciArray.hpp"
29 #include "ci/ciInstance.hpp"
30 #include "ci/ciObject.hpp"
31
32
33 #ifndef PRODUCT
34
35 const char* InstructionPrinter::basic_type_name(BasicType type) {
36 switch (type) {
37 case T_BOOLEAN: return "boolean";
38 case T_BYTE : return "byte";
39 case T_CHAR : return "char";
40 case T_SHORT : return "short";
41 case T_INT : return "int";
42 case T_LONG : return "long";
43 case T_FLOAT : return "float";
44 case T_DOUBLE : return "double";
45 case T_ARRAY : return "array";
46 case T_OBJECT : return "object";
47 default : return "???";
48 }
49 }
50
51
52 const char* InstructionPrinter::cond_name(If::Condition cond) {
53 switch (cond) {
54 case If::eql: return "==";
55 case If::neq: return "!=";
56 case If::lss: return "<";
57 case If::leq: return "<=";
58 case If::gtr: return ">";
59 case If::geq: return ">=";
60 }
61 ShouldNotReachHere();
62 return NULL;
63 }
64
65
66 const char* InstructionPrinter::op_name(Bytecodes::Code op) {
67 switch (op) {
68 // arithmetic ops
69 case Bytecodes::_iadd : // fall through
70 case Bytecodes::_ladd : // fall through
71 case Bytecodes::_fadd : // fall through
72 case Bytecodes::_dadd : return "+";
73 case Bytecodes::_isub : // fall through
74 case Bytecodes::_lsub : // fall through
75 case Bytecodes::_fsub : // fall through
76 case Bytecodes::_dsub : return "-";
77 case Bytecodes::_imul : // fall through
78 case Bytecodes::_lmul : // fall through
79 case Bytecodes::_fmul : // fall through
80 case Bytecodes::_dmul : return "*";
81 case Bytecodes::_idiv : // fall through
82 case Bytecodes::_ldiv : // fall through
83 case Bytecodes::_fdiv : // fall through
84 case Bytecodes::_ddiv : return "/";
85 case Bytecodes::_irem : // fall through
86 case Bytecodes::_lrem : // fall through
87 case Bytecodes::_frem : // fall through
88 case Bytecodes::_drem : return "%";
89 // shift ops
90 case Bytecodes::_ishl : // fall through
91 case Bytecodes::_lshl : return "<<";
92 case Bytecodes::_ishr : // fall through
93 case Bytecodes::_lshr : return ">>";
94 case Bytecodes::_iushr: // fall through
95 case Bytecodes::_lushr: return ">>>";
96 // logic ops
97 case Bytecodes::_iand : // fall through
98 case Bytecodes::_land : return "&";
99 case Bytecodes::_ior : // fall through
100 case Bytecodes::_lor : return "|";
101 case Bytecodes::_ixor : // fall through
102 case Bytecodes::_lxor : return "^";
103 }
104 return Bytecodes::name(op);
105 }
106
107
108 bool InstructionPrinter::is_illegal_phi(Value v) {
109 Phi* phi = v ? v->as_Phi() : NULL;
110 if (phi && phi->is_illegal()) {
111 return true;
112 }
113 return false;
114 }
115
116
117 bool InstructionPrinter::is_phi_of_block(Value v, BlockBegin* b) {
118 Phi* phi = v ? v->as_Phi() : NULL;
119 return phi && phi->block() == b;
120 }
121
122
123 void InstructionPrinter::print_klass(ciKlass* klass) {
124 klass->name()->print_symbol_on(output());
125 }
126
127
128 void InstructionPrinter::print_object(Value obj) {
129 ValueType* type = obj->type();
130 if (type->as_ObjectConstant() != NULL) {
131 ciObject* value = type->as_ObjectConstant()->value();
132 if (value->is_null_object()) {
133 output()->print("null");
134 } else if (!value->is_loaded()) {
135 output()->print("<unloaded object " PTR_FORMAT ">", value);
136 } else {
137 output()->print("<object " PTR_FORMAT " klass=", value->constant_encoding());
138 print_klass(value->klass());
139 output()->print(">");
140 }
141 } else if (type->as_InstanceConstant() != NULL) {
142 ciInstance* value = type->as_InstanceConstant()->value();
143 if (value->is_loaded()) {
144 output()->print("<instance " PTR_FORMAT " klass=", value->constant_encoding());
145 print_klass(value->klass());
146 output()->print(">");
147 } else {
148 output()->print("<unloaded instance " PTR_FORMAT ">", value);
149 }
150 } else if (type->as_ArrayConstant() != NULL) {
151 output()->print("<array " PTR_FORMAT ">", type->as_ArrayConstant()->value()->constant_encoding());
152 } else if (type->as_ClassConstant() != NULL) {
153 ciInstanceKlass* klass = type->as_ClassConstant()->value();
154 if (!klass->is_loaded()) {
155 output()->print("<unloaded> ");
156 }
157 output()->print("class ");
158 print_klass(klass);
159 } else if (type->as_MethodConstant() != NULL) {
160 ciMethod* m = type->as_MethodConstant()->value();
161 output()->print("<method %s.%s>", m->holder()->name()->as_utf8(), m->name()->as_utf8());
162 } else {
163 output()->print("???");
164 }
165 }
166
167
168 void InstructionPrinter::print_temp(Value value) {
169 output()->print("%c%d", value->type()->tchar(), value->id());
170 }
171
172
173 void InstructionPrinter::print_field(AccessField* field) {
174 print_value(field->obj());
175 output()->print("._%d", field->offset());
176 }
177
178
179 void InstructionPrinter::print_indexed(AccessIndexed* indexed) {
180 print_value(indexed->array());
181 output()->put('[');
182 print_value(indexed->index());
183 output()->put(']');
184 }
185
186
187 void InstructionPrinter::print_monitor(AccessMonitor* monitor) {
188 output()->print("monitor[%d](", monitor->monitor_no());
189 print_value(monitor->obj());
190 output()->put(')');
191 }
192
193
194 void InstructionPrinter::print_op2(Op2* instr) {
195 print_value(instr->x());
196 output()->print(" %s ", op_name(instr->op()));
197 print_value(instr->y());
198 }
199
200
201 void InstructionPrinter::print_value(Value value) {
202 if (value == NULL) {
203 output()->print("NULL");
204 } else {
205 print_temp(value);
206 }
207 }
208
209
210 void InstructionPrinter::print_instr(Instruction* instr) {
211 instr->visit(this);
212 }
213
214
215 void InstructionPrinter::print_stack(ValueStack* stack) {
216 int start_position = output()->position();
217 if (stack->stack_is_empty()) {
218 output()->print("empty stack");
219 } else {
220 output()->print("stack [");
221 for (int i = 0; i < stack->stack_size();) {
222 if (i > 0) output()->print(", ");
223 output()->print("%d:", i);
224 Value value = stack->stack_at_inc(i);
225 print_value(value);
226 Phi* phi = value->as_Phi();
227 if (phi != NULL) {
228 if (phi->operand()->is_valid()) {
229 output()->print(" ");
230 phi->operand()->print(output());
231 }
232 }
233 }
234 output()->put(']');
235 }
236 if (!stack->no_active_locks()) {
237 // print out the lines on the line below this
238 // one at the same indentation level.
239 output()->cr();
240 fill_to(start_position, ' ');
241 output()->print("locks [");
242 for (int i = i = 0; i < stack->locks_size(); i++) {
243 Value t = stack->lock_at(i);
244 if (i > 0) output()->print(", ");
245 output()->print("%d:", i);
246 if (t == NULL) {
247 // synchronized methods push null on the lock stack
248 output()->print("this");
249 } else {
250 print_value(t);
251 }
252 }
253 output()->print("]");
254 }
255 }
256
257
258 void InstructionPrinter::print_inline_level(BlockBegin* block) {
259 output()->print_cr("inlining depth %d", block->scope()->level());
260 }
261
262
263 void InstructionPrinter::print_unsafe_op(UnsafeOp* op, const char* name) {
264 output()->print(name);
265 output()->print(".(");
266 }
267
268 void InstructionPrinter::print_unsafe_raw_op(UnsafeRawOp* op, const char* name) {
269 print_unsafe_op(op, name);
270 output()->print("base ");
271 print_value(op->base());
272 if (op->has_index()) {
273 output()->print(", index "); print_value(op->index());
274 output()->print(", log2_scale %d", op->log2_scale());
275 }
276 }
277
278
279 void InstructionPrinter::print_unsafe_object_op(UnsafeObjectOp* op, const char* name) {
280 print_unsafe_op(op, name);
281 print_value(op->object());
282 output()->print(", ");
283 print_value(op->offset());
284 }
285
286
287 void InstructionPrinter::print_phi(int i, Value v, BlockBegin* b) {
288 Phi* phi = v->as_Phi();
289 output()->print("%2d ", i);
290 print_value(v);
291 // print phi operands
292 if (phi && phi->block() == b) {
293 output()->print(" [");
294 for (int j = 0; j < phi->operand_count(); j ++) {
295 output()->print(" ");
296 Value opd = phi->operand_at(j);
297 if (opd) print_value(opd);
298 else output()->print("NULL");
299 }
300 output()->print("] ");
301 }
302 print_alias(v);
303 }
304
305
306 void InstructionPrinter::print_alias(Value v) {
307 if (v != v->subst()) {
308 output()->print("alias "); print_value(v->subst());
309 }
310 }
311
312
313 void InstructionPrinter::fill_to(int pos, char filler) {
314 while (output()->position() < pos) output()->put(filler);
315 }
316
317
318 void InstructionPrinter::print_head() {
319 const char filler = '_';
320 fill_to(bci_pos , filler); output()->print("bci" );
321 fill_to(use_pos , filler); output()->print("use" );
322 fill_to(temp_pos , filler); output()->print("tid" );
323 fill_to(instr_pos, filler); output()->print("instr");
324 fill_to(end_pos , filler);
325 output()->cr();
326 }
327
328
329 void InstructionPrinter::print_line(Instruction* instr) {
330 // print instruction data on one line
331 if (instr->is_pinned()) output()->put('.');
332 fill_to(bci_pos ); output()->print("%d", instr->printable_bci());
333 fill_to(use_pos ); output()->print("%d", instr->use_count());
334 fill_to(temp_pos ); print_temp(instr);
335 fill_to(instr_pos); print_instr(instr);
336 output()->cr();
337 // add a line for StateSplit instructions w/ non-empty stacks
338 // (make it robust so we can print incomplete instructions)
339 StateSplit* split = instr->as_StateSplit();
340 if (split != NULL && split->state() != NULL && !split->state()->stack_is_empty()) {
341 fill_to(instr_pos); print_stack(split->state());
342 output()->cr();
343 }
344 }
345
346
347 void InstructionPrinter::do_Phi(Phi* x) {
348 output()->print("phi function"); // make that more detailed later
349 if (x->is_illegal())
350 output()->print(" (illegal)");
351 }
352
353
354 void InstructionPrinter::do_Local(Local* x) {
355 output()->print("local[index %d]", x->java_index());
356 }
357
358
359 void InstructionPrinter::do_Constant(Constant* x) {
360 ValueType* t = x->type();
361 switch (t->tag()) {
362 case intTag : output()->print("%d" , t->as_IntConstant ()->value()); break;
363 case longTag : output()->print(JLONG_FORMAT, t->as_LongConstant()->value()); output()->print("L"); break;
364 case floatTag : output()->print("%g" , t->as_FloatConstant ()->value()); break;
365 case doubleTag : output()->print("%gD" , t->as_DoubleConstant()->value()); break;
366 case objectTag : print_object(x); break;
367 case addressTag: output()->print("bci:%d", t->as_AddressConstant()->value()); break;
368 default : output()->print("???"); break;
369 }
370 }
371
372
373 void InstructionPrinter::do_LoadField(LoadField* x) {
374 print_field(x);
375 output()->print(" (%c)", type2char(x->field()->type()->basic_type()));
376 }
377
378
379 void InstructionPrinter::do_StoreField(StoreField* x) {
380 print_field(x);
381 output()->print(" := ");
382 print_value(x->value());
383 output()->print(" (%c)", type2char(x->field()->type()->basic_type()));
384 }
385
386
387 void InstructionPrinter::do_ArrayLength(ArrayLength* x) {
388 print_value(x->array());
389 output()->print(".length");
390 }
391
392
393 void InstructionPrinter::do_LoadIndexed(LoadIndexed* x) {
394 print_indexed(x);
395 output()->print(" (%c)", type2char(x->elt_type()));
396 }
397
398
399 void InstructionPrinter::do_StoreIndexed(StoreIndexed* x) {
400 print_indexed(x);
401 output()->print(" := ");
402 print_value(x->value());
403 output()->print(" (%c)", type2char(x->elt_type()));
404 }
405
406 void InstructionPrinter::do_NegateOp(NegateOp* x) {
407 output()->put('-');
408 print_value(x->x());
409 }
410
411
412 void InstructionPrinter::do_ArithmeticOp(ArithmeticOp* x) {
413 print_op2(x);
414 }
415
416
417 void InstructionPrinter::do_ShiftOp(ShiftOp* x) {
418 print_op2(x);
419 }
420
421
422 void InstructionPrinter::do_LogicOp(LogicOp* x) {
423 print_op2(x);
424 }
425
426
427 void InstructionPrinter::do_CompareOp(CompareOp* x) {
428 print_op2(x);
429 }
430
431
432 void InstructionPrinter::do_IfOp(IfOp* x) {
433 print_value(x->x());
434 output()->print(" %s ", cond_name(x->cond()));
435 print_value(x->y());
436 output()->print(" ? ");
437 print_value(x->tval());
438 output()->print(" : ");
439 print_value(x->fval());
440 }
441
442
443 void InstructionPrinter::do_Convert(Convert* x) {
444 output()->print("%s(", Bytecodes::name(x->op()));
445 print_value(x->value());
446 output()->put(')');
447 }
448
449
450 void InstructionPrinter::do_NullCheck(NullCheck* x) {
451 output()->print("null_check(");
452 print_value(x->obj());
453 output()->put(')');
454 if (!x->can_trap()) {
455 output()->print(" (eliminated)");
456 }
457 }
458
459
460 void InstructionPrinter::do_TypeCast(TypeCast* x) {
461 output()->print("type_cast(");
462 print_value(x->obj());
463 output()->print(") ");
464 if (x->declared_type()->is_klass())
465 print_klass(x->declared_type()->as_klass());
466 else
467 output()->print(type2name(x->declared_type()->basic_type()));
468 }
469
470
471 void InstructionPrinter::do_Invoke(Invoke* x) {
472 if (x->receiver() != NULL) {
473 print_value(x->receiver());
474 output()->print(".");
475 }
476
477 output()->print("%s(", Bytecodes::name(x->code()));
478 for (int i = 0; i < x->number_of_arguments(); i++) {
479 if (i > 0) output()->print(", ");
480 print_value(x->argument_at(i));
481 }
482 output()->print_cr(")");
483 fill_to(instr_pos);
484 output()->print("%s.%s%s",
485 x->target()->holder()->name()->as_utf8(),
486 x->target()->name()->as_utf8(),
487 x->target()->signature()->as_symbol()->as_utf8());
488 }
489
490
491 void InstructionPrinter::do_NewInstance(NewInstance* x) {
492 output()->print("new instance ");
493 print_klass(x->klass());
494 }
495
496
497 void InstructionPrinter::do_NewTypeArray(NewTypeArray* x) {
498 output()->print("new %s array [", basic_type_name(x->elt_type()));
499 print_value(x->length());
500 output()->put(']');
501 }
502
503
504 void InstructionPrinter::do_NewObjectArray(NewObjectArray* x) {
505 output()->print("new object array [");
506 print_value(x->length());
507 output()->print("] ");
508 print_klass(x->klass());
509 }
510
511
512 void InstructionPrinter::do_NewMultiArray(NewMultiArray* x) {
513 output()->print("new multi array [");
514 Values* dims = x->dims();
515 for (int i = 0; i < dims->length(); i++) {
516 if (i > 0) output()->print(", ");
517 print_value(dims->at(i));
518 }
519 output()->print("] ");
520 print_klass(x->klass());
521 }
522
523
524 void InstructionPrinter::do_MonitorEnter(MonitorEnter* x) {
525 output()->print("enter ");
526 print_monitor(x);
527 }
528
529
530 void InstructionPrinter::do_MonitorExit(MonitorExit* x) {
531 output()->print("exit ");
532 print_monitor(x);
533 }
534
535
536 void InstructionPrinter::do_Intrinsic(Intrinsic* x) {
537 const char* name = vmIntrinsics::name_at(x->id());
538 if (name[0] == '_') name++; // strip leading bug from _hashCode, etc.
539 const char* kname = vmSymbols::name_for(vmIntrinsics::class_for(x->id()));
540 if (strchr(name, '_') == NULL) {
541 kname = NULL;
542 } else {
543 const char* kptr = strrchr(kname, '/');
544 if (kptr != NULL) kname = kptr + 1;
545 }
546 if (kname == NULL)
547 output()->print("%s(", name);
548 else
549 output()->print("%s.%s(", kname, name);
550 for (int i = 0; i < x->number_of_arguments(); i++) {
551 if (i > 0) output()->print(", ");
552 print_value(x->argument_at(i));
553 }
554 output()->put(')');
555 }
556
557
558 void InstructionPrinter::do_BlockBegin(BlockBegin* x) {
559 // print block id
560 BlockEnd* end = x->end();
561 output()->print("B%d ", x->block_id());
562
563 // print flags
564 bool printed_flag = false;
565 if (x->is_set(BlockBegin::std_entry_flag)) {
566 if (!printed_flag) output()->print("(");
567 output()->print("S"); printed_flag = true;
568 }
569 if (x->is_set(BlockBegin::osr_entry_flag)) {
570 if (!printed_flag) output()->print("(");
571 output()->print("O"); printed_flag = true;
572 }
573 if (x->is_set(BlockBegin::exception_entry_flag)) {
574 if (!printed_flag) output()->print("(");
575 output()->print("E"); printed_flag = true;
576 }
577 if (x->is_set(BlockBegin::subroutine_entry_flag)) {
578 if (!printed_flag) output()->print("(");
579 output()->print("s"); printed_flag = true;
580 }
581 if (x->is_set(BlockBegin::parser_loop_header_flag)) {
582 if (!printed_flag) output()->print("(");
583 output()->print("LH"); printed_flag = true;
584 }
585 if (x->is_set(BlockBegin::backward_branch_target_flag)) {
586 if (!printed_flag) output()->print("(");
587 output()->print("b"); printed_flag = true;
588 }
589 if (x->is_set(BlockBegin::was_visited_flag)) {
590 if (!printed_flag) output()->print("(");
591 output()->print("V"); printed_flag = true;
592 }
593 if (printed_flag) output()->print(") ");
594
595 // print block bci range
596 output()->print("[%d, %d]", x->bci(), (end == NULL ? -1 : end->printable_bci()));
597
598 // print block successors
599 if (end != NULL && end->number_of_sux() > 0) {
600 output()->print(" ->");
601 for (int i = 0; i < end->number_of_sux(); i++) {
602 output()->print(" B%d", end->sux_at(i)->block_id());
603 }
604 }
605 // print exception handlers
606 if (x->number_of_exception_handlers() > 0) {
607 output()->print(" (xhandlers ");
608 for (int i = 0; i < x->number_of_exception_handlers(); i++) {
609 if (i > 0) output()->print(" ");
610 output()->print("B%d", x->exception_handler_at(i)->block_id());
611 }
612 output()->put(')');
613 }
614
615 // print dominator block
616 if (x->dominator() != NULL) {
617 output()->print(" dom B%d", x->dominator()->block_id());
618 }
619
620 // print predecessors and successors
621 if (x->successors()->length() > 0) {
622 output()->print(" sux:");
623 for (int i = 0; i < x->successors()->length(); i ++) {
624 output()->print(" B%d", x->successors()->at(i)->block_id());
625 }
626 }
627
628 if (x->number_of_preds() > 0) {
629 output()->print(" pred:");
630 for (int i = 0; i < x->number_of_preds(); i ++) {
631 output()->print(" B%d", x->pred_at(i)->block_id());
632 }
633 }
634
635 if (!_print_phis) {
636 return;
637 }
638
639 // print phi functions
640 bool has_phis_in_locals = false;
641 bool has_phis_on_stack = false;
642
643 if (x->end() && x->end()->state()) {
644 ValueStack* state = x->state();
645
646 int i = 0;
647 while (!has_phis_on_stack && i < state->stack_size()) {
648 Value v = state->stack_at_inc(i);
649 has_phis_on_stack = is_phi_of_block(v, x);
650 }
651
652 do {
653 for (i = 0; !has_phis_in_locals && i < state->locals_size();) {
654 Value v = state->local_at(i);
655 has_phis_in_locals = is_phi_of_block(v, x);
656 // also ignore illegal HiWords
657 if (v && !v->type()->is_illegal()) i += v->type()->size(); else i ++;
658 }
659 state = state->caller_state();
660 } while (state != NULL);
661
662 }
663
664 // print values in locals
665 if (has_phis_in_locals) {
666 output()->cr(); output()->print_cr("Locals:");
667
668 ValueStack* state = x->state();
669 do {
670 for (int i = 0; i < state->locals_size();) {
671 Value v = state->local_at(i);
672 if (v) {
673 print_phi(i, v, x); output()->cr();
674 // also ignore illegal HiWords
675 i += (v->type()->is_illegal() ? 1 : v->type()->size());
676 } else {
677 i ++;
678 }
679 }
680 output()->cr();
681 state = state->caller_state();
682 } while (state != NULL);
683 }
684
685 // print values on stack
686 if (has_phis_on_stack) {
687 output()->print_cr("Stack:");
688 int i = 0;
689 while (i < x->state()->stack_size()) {
690 int o = i;
691 Value v = x->state()->stack_at_inc(i);
692 if (v) {
693 print_phi(o, v, x); output()->cr();
694 }
695 }
696 }
697 }
698
699
700 void InstructionPrinter::do_CheckCast(CheckCast* x) {
701 output()->print("checkcast(");
702 print_value(x->obj());
703 output()->print(") ");
704 print_klass(x->klass());
705 }
706
707
708 void InstructionPrinter::do_InstanceOf(InstanceOf* x) {
709 output()->print("instanceof(");
710 print_value(x->obj());
711 output()->print(") ");
712 print_klass(x->klass());
713 }
714
715
716 void InstructionPrinter::do_Goto(Goto* x) {
717 output()->print("goto B%d", x->default_sux()->block_id());
718 if (x->is_safepoint()) output()->print(" (safepoint)");
719 }
720
721
722 void InstructionPrinter::do_If(If* x) {
723 output()->print("if ");
724 print_value(x->x());
725 output()->print(" %s ", cond_name(x->cond()));
726 print_value(x->y());
727 output()->print(" then B%d else B%d", x->sux_at(0)->block_id(), x->sux_at(1)->block_id());
728 if (x->is_safepoint()) output()->print(" (safepoint)");
729 }
730
731
732 void InstructionPrinter::do_IfInstanceOf(IfInstanceOf* x) {
733 output()->print("<IfInstanceOf>");
734 }
735
736
737 void InstructionPrinter::do_TableSwitch(TableSwitch* x) {
738 output()->print("tableswitch ");
739 if (x->is_safepoint()) output()->print("(safepoint) ");
740 print_value(x->tag());
741 output()->cr();
742 int l = x->length();
743 for (int i = 0; i < l; i++) {
744 fill_to(instr_pos);
745 output()->print_cr("case %5d: B%d", x->lo_key() + i, x->sux_at(i)->block_id());
746 }
747 fill_to(instr_pos);
748 output()->print("default : B%d", x->default_sux()->block_id());
749 }
750
751
752 void InstructionPrinter::do_LookupSwitch(LookupSwitch* x) {
753 output()->print("lookupswitch ");
754 if (x->is_safepoint()) output()->print("(safepoint) ");
755 print_value(x->tag());
756 output()->cr();
757 int l = x->length();
758 for (int i = 0; i < l; i++) {
759 fill_to(instr_pos);
760 output()->print_cr("case %5d: B%d", x->key_at(i), x->sux_at(i)->block_id());
761 }
762 fill_to(instr_pos);
763 output()->print("default : B%d", x->default_sux()->block_id());
764 }
765
766
767 void InstructionPrinter::do_Return(Return* x) {
768 if (x->result() == NULL) {
769 output()->print("return");
770 } else {
771 output()->print("%creturn ", x->type()->tchar());
772 print_value(x->result());
773 }
774 }
775
776
777 void InstructionPrinter::do_Throw(Throw* x) {
778 output()->print("throw ");
779 print_value(x->exception());
780 }
781
782
783 void InstructionPrinter::do_Base(Base* x) {
784 output()->print("std entry B%d", x->std_entry()->block_id());
785 if (x->number_of_sux() > 1) {
786 output()->print(" osr entry B%d", x->osr_entry()->block_id());
787 }
788 }
789
790
791 void InstructionPrinter::do_OsrEntry(OsrEntry* x) {
792 output()->print("osr entry");
793 }
794
795
796 void InstructionPrinter::do_ExceptionObject(ExceptionObject* x) {
797 output()->print("incoming exception");
798 }
799
800
801 void InstructionPrinter::do_RoundFP(RoundFP* x) {
802 output()->print("round_fp ");
803 print_value(x->input());
804 }
805
806
807 void InstructionPrinter::do_UnsafeGetRaw(UnsafeGetRaw* x) {
808 print_unsafe_raw_op(x, "UnsafeGetRaw");
809 output()->put(')');
810 }
811
812
813 void InstructionPrinter::do_UnsafePutRaw(UnsafePutRaw* x) {
814 print_unsafe_raw_op(x, "UnsafePutRaw");
815 output()->print(", value ");
816 print_value(x->value());
817 output()->put(')');
818 }
819
820
821 void InstructionPrinter::do_UnsafeGetObject(UnsafeGetObject* x) {
822 print_unsafe_object_op(x, "UnsafeGetObject");
823 output()->put(')');
824 }
825
826
827 void InstructionPrinter::do_UnsafePutObject(UnsafePutObject* x) {
828 print_unsafe_object_op(x, "UnsafePutObject");
829 output()->print(", value ");
830 print_value(x->value());
831 output()->put(')');
832 }
833
834 void InstructionPrinter::do_UnsafeGetAndSetObject(UnsafeGetAndSetObject* x) {
835 print_unsafe_object_op(x, x->is_add()?"UnsafeGetAndSetObject (add)":"UnsafeGetAndSetObject");
836 output()->print(", value ");
837 print_value(x->value());
838 output()->put(')');
839 }
840
841 void InstructionPrinter::do_UnsafePrefetchRead(UnsafePrefetchRead* x) {
842 print_unsafe_object_op(x, "UnsafePrefetchRead");
843 output()->put(')');
844 }
845
846
847 void InstructionPrinter::do_UnsafePrefetchWrite(UnsafePrefetchWrite* x) {
848 print_unsafe_object_op(x, "UnsafePrefetchWrite");
849 output()->put(')');
850 }
851
852 void InstructionPrinter::do_ProfileCall(ProfileCall* x) {
853 output()->print("profile ");
854 print_value(x->recv());
855 output()->print(" %s.%s", x->method()->holder()->name()->as_utf8(), x->method()->name()->as_utf8());
856 if (x->known_holder() != NULL) {
857 output()->print(", ");
858 print_klass(x->known_holder());
859 }
860 output()->put(')');
861 }
862
863 void InstructionPrinter::do_ProfileInvoke(ProfileInvoke* x) {
864 output()->print("profile_invoke ");
865 output()->print(" %s.%s", x->inlinee()->holder()->name()->as_utf8(), x->inlinee()->name()->as_utf8());
866 output()->put(')');
867
868 }
869
870 void InstructionPrinter::do_RuntimeCall(RuntimeCall* x) {
871 output()->print("call_rt %s(", x->entry_name());
872 for (int i = 0; i < x->number_of_arguments(); i++) {
873 if (i > 0) output()->print(", ");
874 print_value(x->argument_at(i));
875 }
876 output()->put(')');
877 }
878
879 void InstructionPrinter::do_MemBar(MemBar* x) {
880 if (os::is_MP()) {
881 LIR_Code code = x->code();
882 switch (code) {
883 case lir_membar_acquire : output()->print("membar_acquire"); break;
884 case lir_membar_release : output()->print("membar_release"); break;
885 case lir_membar : output()->print("membar"); break;
886 case lir_membar_loadload : output()->print("membar_loadload"); break;
887 case lir_membar_storestore: output()->print("membar_storestore"); break;
888 case lir_membar_loadstore : output()->print("membar_loadstore"); break;
889 case lir_membar_storeload : output()->print("membar_storeload"); break;
890 default : ShouldNotReachHere(); break;
891 }
892 }
893 }
894
895 #endif // PRODUCT