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