1 /*
   2  * Copyright (c) 2000, 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 "ci/ciConstant.hpp"
  26 #include "ci/ciField.hpp"
  27 #include "ci/ciInlineKlass.hpp"
  28 #include "ci/ciMethod.hpp"
  29 #include "ci/ciMethodData.hpp"
  30 #include "ci/ciObjArrayKlass.hpp"
  31 #include "ci/ciStreams.hpp"
  32 #include "ci/ciTypeArrayKlass.hpp"
  33 #include "ci/ciTypeFlow.hpp"
  34 #include "compiler/compileLog.hpp"
  35 #include "interpreter/bytecode.hpp"
  36 #include "interpreter/bytecodes.hpp"
  37 #include "memory/allocation.inline.hpp"
  38 #include "memory/resourceArea.hpp"
  39 #include "oops/oop.inline.hpp"
  40 #include "opto/compile.hpp"
  41 #include "runtime/deoptimization.hpp"
  42 #include "utilities/growableArray.hpp"
  43 
  44 // ciTypeFlow::JsrSet
  45 //
  46 // A JsrSet represents some set of JsrRecords.  This class
  47 // is used to record a set of all jsr routines which we permit
  48 // execution to return (ret) from.
  49 //
  50 // During abstract interpretation, JsrSets are used to determine
  51 // whether two paths which reach a given block are unique, and
  52 // should be cloned apart, or are compatible, and should merge
  53 // together.
  54 
  55 // ------------------------------------------------------------------
  56 // ciTypeFlow::JsrSet::JsrSet
  57 
  58 // Allocate growable array storage in Arena.
  59 ciTypeFlow::JsrSet::JsrSet(Arena* arena, int default_len) : _set(arena, default_len, 0, nullptr) {
  60   assert(arena != nullptr, "invariant");
  61 }
  62 
  63 // Allocate growable array storage in current ResourceArea.
  64 ciTypeFlow::JsrSet::JsrSet(int default_len) : _set(default_len, 0, nullptr) {}
  65 
  66 // ------------------------------------------------------------------
  67 // ciTypeFlow::JsrSet::copy_into
  68 void ciTypeFlow::JsrSet::copy_into(JsrSet* jsrs) {
  69   int len = size();
  70   jsrs->_set.clear();
  71   for (int i = 0; i < len; i++) {
  72     jsrs->_set.append(_set.at(i));
  73   }
  74 }
  75 
  76 // ------------------------------------------------------------------
  77 // ciTypeFlow::JsrSet::is_compatible_with
  78 //
  79 // !!!! MISGIVINGS ABOUT THIS... disregard
  80 //
  81 // Is this JsrSet compatible with some other JsrSet?
  82 //
  83 // In set-theoretic terms, a JsrSet can be viewed as a partial function
  84 // from entry addresses to return addresses.  Two JsrSets A and B are
  85 // compatible iff
  86 //
  87 //   For any x,
  88 //   A(x) defined and B(x) defined implies A(x) == B(x)
  89 //
  90 // Less formally, two JsrSets are compatible when they have identical
  91 // return addresses for any entry addresses they share in common.
  92 bool ciTypeFlow::JsrSet::is_compatible_with(JsrSet* other) {
  93   // Walk through both sets in parallel.  If the same entry address
  94   // appears in both sets, then the return address must match for
  95   // the sets to be compatible.
  96   int size1 = size();
  97   int size2 = other->size();
  98 
  99   // Special case.  If nothing is on the jsr stack, then there can
 100   // be no ret.
 101   if (size2 == 0) {
 102     return true;
 103   } else if (size1 != size2) {
 104     return false;
 105   } else {
 106     for (int i = 0; i < size1; i++) {
 107       JsrRecord* record1 = record_at(i);
 108       JsrRecord* record2 = other->record_at(i);
 109       if (record1->entry_address() != record2->entry_address() ||
 110           record1->return_address() != record2->return_address()) {
 111         return false;
 112       }
 113     }
 114     return true;
 115   }
 116 
 117 #if 0
 118   int pos1 = 0;
 119   int pos2 = 0;
 120   int size1 = size();
 121   int size2 = other->size();
 122   while (pos1 < size1 && pos2 < size2) {
 123     JsrRecord* record1 = record_at(pos1);
 124     JsrRecord* record2 = other->record_at(pos2);
 125     int entry1 = record1->entry_address();
 126     int entry2 = record2->entry_address();
 127     if (entry1 < entry2) {
 128       pos1++;
 129     } else if (entry1 > entry2) {
 130       pos2++;
 131     } else {
 132       if (record1->return_address() == record2->return_address()) {
 133         pos1++;
 134         pos2++;
 135       } else {
 136         // These two JsrSets are incompatible.
 137         return false;
 138       }
 139     }
 140   }
 141   // The two JsrSets agree.
 142   return true;
 143 #endif
 144 }
 145 
 146 // ------------------------------------------------------------------
 147 // ciTypeFlow::JsrSet::insert_jsr_record
 148 //
 149 // Insert the given JsrRecord into the JsrSet, maintaining the order
 150 // of the set and replacing any element with the same entry address.
 151 void ciTypeFlow::JsrSet::insert_jsr_record(JsrRecord* record) {
 152   int len = size();
 153   int entry = record->entry_address();
 154   int pos = 0;
 155   for ( ; pos < len; pos++) {
 156     JsrRecord* current = record_at(pos);
 157     if (entry == current->entry_address()) {
 158       // Stomp over this entry.
 159       _set.at_put(pos, record);
 160       assert(size() == len, "must be same size");
 161       return;
 162     } else if (entry < current->entry_address()) {
 163       break;
 164     }
 165   }
 166 
 167   // Insert the record into the list.
 168   JsrRecord* swap = record;
 169   JsrRecord* temp = nullptr;
 170   for ( ; pos < len; pos++) {
 171     temp = _set.at(pos);
 172     _set.at_put(pos, swap);
 173     swap = temp;
 174   }
 175   _set.append(swap);
 176   assert(size() == len+1, "must be larger");
 177 }
 178 
 179 // ------------------------------------------------------------------
 180 // ciTypeFlow::JsrSet::remove_jsr_record
 181 //
 182 // Remove the JsrRecord with the given return address from the JsrSet.
 183 void ciTypeFlow::JsrSet::remove_jsr_record(int return_address) {
 184   int len = size();
 185   for (int i = 0; i < len; i++) {
 186     if (record_at(i)->return_address() == return_address) {
 187       // We have found the proper entry.  Remove it from the
 188       // JsrSet and exit.
 189       for (int j = i + 1; j < len ; j++) {
 190         _set.at_put(j - 1, _set.at(j));
 191       }
 192       _set.trunc_to(len - 1);
 193       assert(size() == len-1, "must be smaller");
 194       return;
 195     }
 196   }
 197   assert(false, "verify: returning from invalid subroutine");
 198 }
 199 
 200 // ------------------------------------------------------------------
 201 // ciTypeFlow::JsrSet::apply_control
 202 //
 203 // Apply the effect of a control-flow bytecode on the JsrSet.  The
 204 // only bytecodes that modify the JsrSet are jsr and ret.
 205 void ciTypeFlow::JsrSet::apply_control(ciTypeFlow* analyzer,
 206                                        ciBytecodeStream* str,
 207                                        ciTypeFlow::StateVector* state) {
 208   Bytecodes::Code code = str->cur_bc();
 209   if (code == Bytecodes::_jsr) {
 210     JsrRecord* record =
 211       analyzer->make_jsr_record(str->get_dest(), str->next_bci());
 212     insert_jsr_record(record);
 213   } else if (code == Bytecodes::_jsr_w) {
 214     JsrRecord* record =
 215       analyzer->make_jsr_record(str->get_far_dest(), str->next_bci());
 216     insert_jsr_record(record);
 217   } else if (code == Bytecodes::_ret) {
 218     Cell local = state->local(str->get_index());
 219     ciType* return_address = state->type_at(local);
 220     assert(return_address->is_return_address(), "verify: wrong type");
 221     if (size() == 0) {
 222       // Ret-state underflow:  Hit a ret w/o any previous jsrs.  Bail out.
 223       // This can happen when a loop is inside a finally clause (4614060).
 224       analyzer->record_failure("OSR in finally clause");
 225       return;
 226     }
 227     remove_jsr_record(return_address->as_return_address()->bci());
 228   }
 229 }
 230 
 231 #ifndef PRODUCT
 232 // ------------------------------------------------------------------
 233 // ciTypeFlow::JsrSet::print_on
 234 void ciTypeFlow::JsrSet::print_on(outputStream* st) const {
 235   st->print("{ ");
 236   int num_elements = size();
 237   if (num_elements > 0) {
 238     int i = 0;
 239     for( ; i < num_elements - 1; i++) {
 240       _set.at(i)->print_on(st);
 241       st->print(", ");
 242     }
 243     _set.at(i)->print_on(st);
 244     st->print(" ");
 245   }
 246   st->print("}");
 247 }
 248 #endif
 249 
 250 // ciTypeFlow::StateVector
 251 //
 252 // A StateVector summarizes the type information at some point in
 253 // the program.
 254 
 255 // ------------------------------------------------------------------
 256 // ciTypeFlow::StateVector::type_meet
 257 //
 258 // Meet two types.
 259 //
 260 // The semi-lattice of types use by this analysis are modeled on those
 261 // of the verifier.  The lattice is as follows:
 262 //
 263 //        top_type() >= all non-extremal types >= bottom_type
 264 //                             and
 265 //   Every primitive type is comparable only with itself.  The meet of
 266 //   reference types is determined by their kind: instance class,
 267 //   interface, or array class.  The meet of two types of the same
 268 //   kind is their least common ancestor.  The meet of two types of
 269 //   different kinds is always java.lang.Object.
 270 ciType* ciTypeFlow::StateVector::type_meet_internal(ciType* t1, ciType* t2, ciTypeFlow* analyzer) {
 271   assert(t1 != t2, "checked in caller");
 272   if (t1->equals(top_type())) {
 273     return t2;
 274   } else if (t2->equals(top_type())) {
 275     return t1;
 276   }
 277   // Unwrap after saving nullness information and handling top meets
 278   assert(t1->is_early_larval() == t2->is_early_larval(), "States should be compatible.");
 279   bool is_early_larval = t1->is_early_larval();
 280   bool null_free1 = t1->is_null_free();
 281   bool null_free2 = t2->is_null_free();
 282   if (t1->unwrap() == t2->unwrap() && null_free1 == null_free2) {
 283     return t1;
 284   }
 285   t1 = t1->unwrap();
 286   t2 = t2->unwrap();
 287 
 288   if (t1->is_primitive_type() || t2->is_primitive_type()) {
 289     // Special case null_type.  null_type meet any reference type T
 290     // is T. null_type meet null_type is null_type.
 291     if (t1->equals(null_type())) {
 292       if (!t2->is_primitive_type() || t2->equals(null_type())) {
 293         return t2;
 294       }
 295     } else if (t2->equals(null_type())) {
 296       if (!t1->is_primitive_type()) {
 297         return t1;
 298       }
 299     }
 300 
 301     // At least one of the two types is a non-top primitive type.
 302     // The other type is not equal to it.  Fall to bottom.
 303     return bottom_type();
 304   }
 305 
 306   // Both types are non-top non-primitive types.  That is,
 307   // both types are either instanceKlasses or arrayKlasses.
 308   ciKlass* object_klass = analyzer->env()->Object_klass();
 309   ciKlass* k1 = t1->as_klass();
 310   ciKlass* k2 = t2->as_klass();
 311   if (k1->equals(object_klass) || k2->equals(object_klass)) {
 312     return object_klass;
 313   } else if (!k1->is_loaded() || !k2->is_loaded()) {
 314     // Unloaded classes fall to java.lang.Object at a merge.
 315     return object_klass;
 316   } else if (k1->is_interface() != k2->is_interface()) {
 317     // When an interface meets a non-interface, we get Object;
 318     // This is what the verifier does.
 319     return object_klass;
 320   } else if (k1->is_array_klass() || k2->is_array_klass()) {
 321     // When an array meets a non-array, we get Object.
 322     // When objArray meets typeArray, we also get Object.
 323     // And when typeArray meets different typeArray, we again get Object.
 324     // But when objArray meets objArray, we look carefully at element types.
 325     if (k1->is_obj_array_klass() && k2->is_obj_array_klass()) {
 326       ciType* elem1 = k1->as_array_klass()->element_klass();
 327       ciType* elem2 = k2->as_array_klass()->element_klass();
 328       ciType* elem = elem1;
 329       if (elem1 != elem2) {
 330         elem = type_meet_internal(elem1, elem2, analyzer)->as_klass();
 331       }
 332       // Do an easy shortcut if one type is a super of the other.
 333       if (elem == elem1 && !elem->is_inlinetype()) {
 334         assert(k1 == ciArrayKlass::make(elem), "shortcut is OK");
 335         return k1;
 336       } else if (elem == elem2 && !elem->is_inlinetype()) {
 337         assert(k2 == ciArrayKlass::make(elem), "shortcut is OK");
 338         return k2;
 339       } else {
 340         return ciArrayKlass::make(elem);
 341       }
 342     } else {
 343       return object_klass;
 344     }
 345   } else {
 346     // Must be two plain old instance klasses.
 347     assert(k1->is_instance_klass(), "previous cases handle non-instances");
 348     assert(k2->is_instance_klass(), "previous cases handle non-instances");
 349     ciType* result = k1->least_common_ancestor(k2);
 350     if (null_free1 && null_free2 && result->is_inlinetype()) {
 351       result = analyzer->mark_as_null_free(result);
 352     }
 353     if (is_early_larval) {
 354       result = analyzer->mark_as_early_larval(result);
 355     }
 356     return result;
 357   }
 358 }
 359 
 360 
 361 // ------------------------------------------------------------------
 362 // ciTypeFlow::StateVector::StateVector
 363 //
 364 // Build a new state vector
 365 ciTypeFlow::StateVector::StateVector(ciTypeFlow* analyzer) {
 366   _outer = analyzer;
 367   _stack_size = -1;
 368   _monitor_count = -1;
 369   // Allocate the _types array
 370   int max_cells = analyzer->max_cells();
 371   _types = (ciType**)analyzer->arena()->Amalloc(sizeof(ciType*) * max_cells);
 372   for (int i=0; i<max_cells; i++) {
 373     _types[i] = top_type();
 374   }
 375   _trap_bci = -1;
 376   _trap_index = 0;
 377   _def_locals.clear();
 378 }
 379 
 380 
 381 // ------------------------------------------------------------------
 382 // ciTypeFlow::get_start_state
 383 //
 384 // Set this vector to the method entry state.
 385 const ciTypeFlow::StateVector* ciTypeFlow::get_start_state() {
 386   StateVector* state = new StateVector(this);
 387   if (is_osr_flow()) {
 388     ciTypeFlow* non_osr_flow = method()->get_flow_analysis();
 389     if (non_osr_flow->failing()) {
 390       record_failure(non_osr_flow->failure_reason());
 391       return nullptr;
 392     }
 393     JsrSet* jsrs = new JsrSet(4);
 394     Block* non_osr_block = non_osr_flow->existing_block_at(start_bci(), jsrs);
 395     if (non_osr_block == nullptr) {
 396       record_failure("cannot reach OSR point");
 397       return nullptr;
 398     }
 399     // load up the non-OSR state at this point
 400     non_osr_block->copy_state_into(state);
 401     int non_osr_start = non_osr_block->start();
 402     if (non_osr_start != start_bci()) {
 403       // must flow forward from it
 404       if (CITraceTypeFlow) {
 405         tty->print_cr(">> Interpreting pre-OSR block %d:", non_osr_start);
 406       }
 407       Block* block = block_at(non_osr_start, jsrs);
 408       assert(block->limit() == start_bci(), "must flow forward to start");
 409       flow_block(block, state, jsrs);
 410     }
 411     return state;
 412     // Note:  The code below would be an incorrect for an OSR flow,
 413     // even if it were possible for an OSR entry point to be at bci zero.
 414   }
 415   // "Push" the method signature into the first few locals.
 416   state->set_stack_size(-max_locals());
 417   if (!method()->is_static()) {
 418     ciType* holder = method()->holder();
 419     if (method()->is_object_constructor()) {
 420       if (holder->is_inlinetype() || (holder->is_instance_klass() && !holder->as_instance_klass()->flags().is_identity())) {
 421         // The receiver is early larval (so also null-free)
 422         holder = mark_as_early_larval(holder);
 423       }
 424     } else {
 425       if (holder->is_inlinetype()) {
 426         // The receiver is null-free
 427         holder = mark_as_null_free(holder);
 428       }
 429     }
 430     state->push(holder);
 431     assert(state->tos() == state->local(0), "");
 432   }
 433   for (ciSignatureStream str(method()->signature());
 434        !str.at_return_type();
 435        str.next()) {
 436     state->push_translate(str.type());
 437   }
 438   // Set the rest of the locals to bottom.
 439   assert(state->stack_size() <= 0, "stack size should not be strictly positive");
 440   while (state->stack_size() < 0) {
 441     state->push(state->bottom_type());
 442   }
 443   // Lock an object, if necessary.
 444   state->set_monitor_count(method()->is_synchronized() ? 1 : 0);
 445   return state;
 446 }
 447 
 448 // ------------------------------------------------------------------
 449 // ciTypeFlow::StateVector::copy_into
 450 //
 451 // Copy our value into some other StateVector
 452 void ciTypeFlow::StateVector::copy_into(ciTypeFlow::StateVector* copy)
 453 const {
 454   copy->set_stack_size(stack_size());
 455   copy->set_monitor_count(monitor_count());
 456   Cell limit = limit_cell();
 457   for (Cell c = start_cell(); c < limit; c = next_cell(c)) {
 458     copy->set_type_at(c, type_at(c));
 459   }
 460 }
 461 
 462 // ------------------------------------------------------------------
 463 // ciTypeFlow::StateVector::meet
 464 //
 465 // Meets this StateVector with another, destructively modifying this
 466 // one.  Returns true if any modification takes place.
 467 bool ciTypeFlow::StateVector::meet(const ciTypeFlow::StateVector* incoming) {
 468   if (monitor_count() == -1) {
 469     set_monitor_count(incoming->monitor_count());
 470   }
 471   assert(monitor_count() == incoming->monitor_count(), "monitors must match");
 472 
 473   if (stack_size() == -1) {
 474     set_stack_size(incoming->stack_size());
 475     Cell limit = limit_cell();
 476     #ifdef ASSERT
 477     { for (Cell c = start_cell(); c < limit; c = next_cell(c)) {
 478         assert(type_at(c) == top_type(), "");
 479     } }
 480     #endif
 481     // Make a simple copy of the incoming state.
 482     for (Cell c = start_cell(); c < limit; c = next_cell(c)) {
 483       set_type_at(c, incoming->type_at(c));
 484     }
 485     return true;  // it is always different the first time
 486   }
 487 #ifdef ASSERT
 488   if (stack_size() != incoming->stack_size()) {
 489     _outer->method()->print_codes();
 490     tty->print_cr("!!!! Stack size conflict");
 491     tty->print_cr("Current state:");
 492     print_on(tty);
 493     tty->print_cr("Incoming state:");
 494     ((StateVector*)incoming)->print_on(tty);
 495   }
 496 #endif
 497   assert(stack_size() == incoming->stack_size(), "sanity");
 498 
 499   bool different = false;
 500   Cell limit = limit_cell();
 501   for (Cell c = start_cell(); c < limit; c = next_cell(c)) {
 502     ciType* t1 = type_at(c);
 503     ciType* t2 = incoming->type_at(c);
 504     if (!t1->equals(t2)) {
 505       ciType* new_type = type_meet(t1, t2);
 506       if (!t1->equals(new_type)) {
 507         set_type_at(c, new_type);
 508         different = true;
 509       }
 510     }
 511   }
 512   return different;
 513 }
 514 
 515 // ------------------------------------------------------------------
 516 // ciTypeFlow::StateVector::meet_exception
 517 //
 518 // Meets this StateVector with another, destructively modifying this
 519 // one.  The incoming state is coming via an exception.  Returns true
 520 // if any modification takes place.
 521 bool ciTypeFlow::StateVector::meet_exception(ciInstanceKlass* exc,
 522                                      const ciTypeFlow::StateVector* incoming) {
 523   if (monitor_count() == -1) {
 524     set_monitor_count(incoming->monitor_count());
 525   }
 526   assert(monitor_count() == incoming->monitor_count(), "monitors must match");
 527 
 528   if (stack_size() == -1) {
 529     set_stack_size(1);
 530   }
 531 
 532   assert(stack_size() ==  1, "must have one-element stack");
 533 
 534   bool different = false;
 535 
 536   // Meet locals from incoming array.
 537   Cell limit = local_limit_cell();
 538   for (Cell c = start_cell(); c < limit; c = next_cell(c)) {
 539     ciType* t1 = type_at(c);
 540     ciType* t2 = incoming->type_at(c);
 541     if (!t1->equals(t2)) {
 542       ciType* new_type = type_meet(t1, t2);
 543       if (!t1->equals(new_type)) {
 544         set_type_at(c, new_type);
 545         different = true;
 546       }
 547     }
 548   }
 549 
 550   // Handle stack separately.  When an exception occurs, the
 551   // only stack entry is the exception instance.
 552   ciType* tos_type = type_at_tos();
 553   if (!tos_type->equals(exc)) {
 554     ciType* new_type = type_meet(tos_type, exc);
 555     if (!tos_type->equals(new_type)) {
 556       set_type_at_tos(new_type);
 557       different = true;
 558     }
 559   }
 560 
 561   return different;
 562 }
 563 
 564 // ------------------------------------------------------------------
 565 // ciTypeFlow::StateVector::push_translate
 566 void ciTypeFlow::StateVector::push_translate(ciType* type) {
 567   BasicType basic_type = type->basic_type();
 568   if (basic_type == T_BOOLEAN || basic_type == T_CHAR ||
 569       basic_type == T_BYTE    || basic_type == T_SHORT) {
 570     push_int();
 571   } else {
 572     push(type);
 573     if (type->is_two_word()) {
 574       push(half_type(type));
 575     }
 576   }
 577 }
 578 
 579 // ------------------------------------------------------------------
 580 // ciTypeFlow::StateVector::do_aload
 581 void ciTypeFlow::StateVector::do_aload(ciBytecodeStream* str) {
 582   pop_int();
 583   ciArrayKlass* array_klass = pop_objOrFlatArray();
 584   if (array_klass == nullptr) {
 585     // Did aload on a null reference; push a null and ignore the exception.
 586     // This instruction will never continue normally.  All we have to do
 587     // is report a value that will meet correctly with any downstream
 588     // reference types on paths that will truly be executed.  This null type
 589     // meets with any reference type to yield that same reference type.
 590     // (The compiler will generate an unconditional exception here.)
 591     push(null_type());
 592     return;
 593   }
 594   if (!array_klass->is_loaded()) {
 595     // Only fails for some -Xcomp runs
 596     trap(str, array_klass,
 597          Deoptimization::make_trap_request
 598          (Deoptimization::Reason_unloaded,
 599           Deoptimization::Action_reinterpret));
 600     return;
 601   }
 602   ciKlass* element_klass = array_klass->element_klass();
 603   // TODO 8350865 Can we check that array_klass is null_free and use mark_as_null_free on the result here?
 604   if (!element_klass->is_loaded() && element_klass->is_instance_klass()) {
 605     Untested("unloaded array element class in ciTypeFlow");
 606     trap(str, element_klass,
 607          Deoptimization::make_trap_request
 608          (Deoptimization::Reason_unloaded,
 609           Deoptimization::Action_reinterpret));
 610   } else {
 611     push_object(element_klass);
 612   }
 613 }
 614 
 615 
 616 // ------------------------------------------------------------------
 617 // ciTypeFlow::StateVector::do_checkcast
 618 void ciTypeFlow::StateVector::do_checkcast(ciBytecodeStream* str) {
 619   bool will_link;
 620   ciKlass* klass = str->get_klass(will_link);
 621   if (!will_link) {
 622     // VM's interpreter will not load 'klass' if object is nullptr.
 623     // Type flow after this block may still be needed in two situations:
 624     // 1) C2 uses do_null_assert() and continues compilation for later blocks
 625     // 2) C2 does an OSR compile in a later block (see bug 4778368).
 626     pop_object();
 627     do_null_assert(klass);
 628   } else {
 629     ciType* type = pop_value();
 630     type = type->unwrap();
 631     if (type->is_loaded() && klass->is_loaded() &&
 632         type != klass && type->is_subtype_of(klass)) {
 633       // Useless cast, propagate more precise type of object
 634       klass = type->as_klass();
 635     }
 636     push_object(klass);
 637   }
 638 }
 639 
 640 // ------------------------------------------------------------------
 641 // ciTypeFlow::StateVector::do_getfield
 642 void ciTypeFlow::StateVector::do_getfield(ciBytecodeStream* str) {
 643   // could add assert here for type of object.
 644   pop_object();
 645   do_getstatic(str);
 646 }
 647 
 648 // ------------------------------------------------------------------
 649 // ciTypeFlow::StateVector::do_getstatic
 650 void ciTypeFlow::StateVector::do_getstatic(ciBytecodeStream* str) {
 651   bool will_link;
 652   ciField* field = str->get_field(will_link);
 653   if (!will_link) {
 654     trap(str, field->holder(), str->get_field_holder_index());
 655   } else {
 656     ciType* field_type = field->type();
 657     if (field->is_static() && field->is_null_free() &&
 658         !field_type->as_instance_klass()->is_initialized()) {
 659       // Deoptimize if we load from a static field with an uninitialized inline type
 660       // because we need to throw an exception if initialization of the type failed.
 661       trap(str, field_type->as_klass(),
 662            Deoptimization::make_trap_request
 663            (Deoptimization::Reason_unloaded,
 664             Deoptimization::Action_reinterpret));
 665       return;
 666     } else if (!field_type->is_loaded()) {
 667       // Normally, we need the field's type to be loaded if we are to
 668       // do anything interesting with its value.
 669       // We used to do this:  trap(str, str->get_field_signature_index());
 670       //
 671       // There is one good reason not to trap here.  Execution can
 672       // get past this "getfield" or "getstatic" if the value of
 673       // the field is null.  As long as the value is null, the class
 674       // does not need to be loaded!  The compiler must assume that
 675       // the value of the unloaded class reference is null; if the code
 676       // ever sees a non-null value, loading has occurred.
 677       //
 678       // This actually happens often enough to be annoying.  If the
 679       // compiler throws an uncommon trap at this bytecode, you can
 680       // get an endless loop of recompilations, when all the code
 681       // needs to do is load a series of null values.  Also, a trap
 682       // here can make an OSR entry point unreachable, triggering the
 683       // assert on non_osr_block in ciTypeFlow::get_start_state.
 684       // (See bug 4379915.)
 685       do_null_assert(field_type->as_klass());
 686     } else {
 687       if (field->is_null_free()) {
 688         field_type = outer()->mark_as_null_free(field_type);
 689       }
 690       push_translate(field_type);
 691     }
 692   }
 693 }
 694 
 695 // ------------------------------------------------------------------
 696 // ciTypeFlow::StateVector::do_invoke
 697 void ciTypeFlow::StateVector::do_invoke(ciBytecodeStream* str,
 698                                         bool has_receiver) {
 699   bool will_link;
 700   ciSignature* declared_signature = nullptr;
 701   ciMethod* callee = str->get_method(will_link, &declared_signature);
 702   assert(declared_signature != nullptr, "cannot be null");
 703   if (!will_link) {
 704     // We weren't able to find the method.
 705     if (str->cur_bc() == Bytecodes::_invokedynamic) {
 706       trap(str, nullptr,
 707            Deoptimization::make_trap_request
 708            (Deoptimization::Reason_uninitialized,
 709             Deoptimization::Action_reinterpret));
 710     } else {
 711       ciKlass* unloaded_holder = callee->holder();
 712       trap(str, unloaded_holder, str->get_method_holder_index());
 713     }
 714   } else {
 715     // We are using the declared signature here because it might be
 716     // different from the callee signature (Cf. invokedynamic and
 717     // invokehandle).
 718     ciSignatureStream sigstr(declared_signature);
 719     const int arg_size = declared_signature->size();
 720     const int stack_base = stack_size() - arg_size;
 721     int i = 0;
 722     for( ; !sigstr.at_return_type(); sigstr.next()) {
 723       ciType* type = sigstr.type();
 724       ciType* stack_type = type_at(stack(stack_base + i++));
 725       // Do I want to check this type?
 726       // assert(stack_type->is_subtype_of(type), "bad type for field value");
 727       if (type->is_two_word()) {
 728         ciType* stack_type2 = type_at(stack(stack_base + i++));
 729         assert(stack_type2->equals(half_type(type)), "must be 2nd half");
 730       }
 731     }
 732     assert(arg_size == i, "must match");
 733     for (int j = 0; j < arg_size; j++) {
 734       pop();
 735     }
 736     if (has_receiver) {
 737       if (type_at_tos()->is_early_larval()) {
 738         // Call with larval receiver accepted by verifier
 739         // => this is <init> and the receiver is no longer larval after that.
 740         Cell limit = limit_cell();
 741         for (Cell c = start_cell(); c < limit; c = next_cell(c)) {
 742           if (type_at(c)->ident() == type_at_tos()->ident()) {
 743             assert(type_at(c) == type_at_tos(), "Sin! Abomination!");
 744             set_type_at(c, type_at_tos()->unwrap());
 745           }
 746         }
 747       }
 748       pop_object();
 749     }
 750     assert(!sigstr.is_done(), "must have return type");
 751     ciType* return_type = sigstr.type();
 752     if (!return_type->is_void()) {
 753       if (!return_type->is_loaded()) {
 754         // As in do_getstatic(), generally speaking, we need the return type to
 755         // be loaded if we are to do anything interesting with its value.
 756         // We used to do this:  trap(str, str->get_method_signature_index());
 757         //
 758         // We do not trap here since execution can get past this invoke if
 759         // the return value is null.  As long as the value is null, the class
 760         // does not need to be loaded!  The compiler must assume that
 761         // the value of the unloaded class reference is null; if the code
 762         // ever sees a non-null value, loading has occurred.
 763         //
 764         // See do_getstatic() for similar explanation, as well as bug 4684993.
 765         do_null_assert(return_type->as_klass());
 766       } else {
 767         push_translate(return_type);
 768       }
 769     }
 770   }
 771 }
 772 
 773 // ------------------------------------------------------------------
 774 // ciTypeFlow::StateVector::do_jsr
 775 void ciTypeFlow::StateVector::do_jsr(ciBytecodeStream* str) {
 776   push(ciReturnAddress::make(str->next_bci()));
 777 }
 778 
 779 // ------------------------------------------------------------------
 780 // ciTypeFlow::StateVector::do_ldc
 781 void ciTypeFlow::StateVector::do_ldc(ciBytecodeStream* str) {
 782   if (str->is_in_error()) {
 783     trap(str, nullptr, Deoptimization::make_trap_request(Deoptimization::Reason_unhandled,
 784                                                          Deoptimization::Action_none));
 785     return;
 786   }
 787   ciConstant con = str->get_constant();
 788   if (con.is_valid()) {
 789     int cp_index = str->get_constant_pool_index();
 790     if (!con.is_loaded()) {
 791       trap(str, nullptr, Deoptimization::make_trap_request(Deoptimization::Reason_unloaded,
 792                                                            Deoptimization::Action_reinterpret,
 793                                                            cp_index));
 794       return;
 795     }
 796     BasicType basic_type = str->get_basic_type_for_constant_at(cp_index);
 797     if (is_reference_type(basic_type)) {
 798       ciObject* obj = con.as_object();
 799       if (obj->is_null_object()) {
 800         push_null();
 801       } else {
 802         assert(obj->is_instance() || obj->is_array(), "must be java_mirror of klass");
 803         ciType* type = obj->klass();
 804         if (type->is_inlinetype()) {
 805           type = outer()->mark_as_null_free(type);
 806         }
 807         push(type);
 808       }
 809     } else {
 810       assert(basic_type == con.basic_type() || con.basic_type() == T_OBJECT,
 811              "not a boxed form: %s vs %s", type2name(basic_type), type2name(con.basic_type()));
 812       push_translate(ciType::make(basic_type));
 813     }
 814   } else {
 815     // OutOfMemoryError in the CI while loading a String constant.
 816     push_null();
 817     outer()->record_failure("ldc did not link");
 818   }
 819 }
 820 
 821 // ------------------------------------------------------------------
 822 // ciTypeFlow::StateVector::do_multianewarray
 823 void ciTypeFlow::StateVector::do_multianewarray(ciBytecodeStream* str) {
 824   int dimensions = str->get_dimensions();
 825   bool will_link;
 826   ciArrayKlass* array_klass = str->get_klass(will_link)->as_array_klass();
 827   if (!will_link) {
 828     trap(str, array_klass, str->get_klass_index());
 829   } else {
 830     for (int i = 0; i < dimensions; i++) {
 831       pop_int();
 832     }
 833     push_object(array_klass);
 834   }
 835 }
 836 
 837 // ------------------------------------------------------------------
 838 // ciTypeFlow::StateVector::do_new
 839 void ciTypeFlow::StateVector::do_new(ciBytecodeStream* str) {
 840   bool will_link;
 841   ciKlass* klass = str->get_klass(will_link);
 842   if (!will_link || str->is_unresolved_klass()) {
 843     trap(str, klass, str->get_klass_index());
 844   } else {
 845     if (klass->is_inlinetype()) {
 846       push(outer()->mark_as_early_larval(klass));
 847       return;
 848     }
 849     push_object(klass);
 850   }
 851 }
 852 
 853 // ------------------------------------------------------------------
 854 // ciTypeFlow::StateVector::do_newarray
 855 void ciTypeFlow::StateVector::do_newarray(ciBytecodeStream* str) {
 856   pop_int();
 857   ciKlass* klass = ciTypeArrayKlass::make((BasicType)str->get_index());
 858   push_object(klass);
 859 }
 860 
 861 // ------------------------------------------------------------------
 862 // ciTypeFlow::StateVector::do_putfield
 863 void ciTypeFlow::StateVector::do_putfield(ciBytecodeStream* str) {
 864   do_putstatic(str);
 865   if (_trap_bci != -1)  return;  // unloaded field holder, etc.
 866   // could add assert here for type of object.
 867   pop_object();
 868 }
 869 
 870 // ------------------------------------------------------------------
 871 // ciTypeFlow::StateVector::do_putstatic
 872 void ciTypeFlow::StateVector::do_putstatic(ciBytecodeStream* str) {
 873   bool will_link;
 874   ciField* field = str->get_field(will_link);
 875   if (!will_link) {
 876     trap(str, field->holder(), str->get_field_holder_index());
 877   } else {
 878     ciType* field_type = field->type();
 879     ciType* type = pop_value();
 880     // Do I want to check this type?
 881     //      assert(type->is_subtype_of(field_type), "bad type for field value");
 882     if (field_type->is_two_word()) {
 883       ciType* type2 = pop_value();
 884       assert(type2->is_two_word(), "must be 2nd half");
 885       assert(type == half_type(type2), "must be 2nd half");
 886     }
 887   }
 888 }
 889 
 890 // ------------------------------------------------------------------
 891 // ciTypeFlow::StateVector::do_ret
 892 void ciTypeFlow::StateVector::do_ret(ciBytecodeStream* str) {
 893   Cell index = local(str->get_index());
 894 
 895   ciType* address = type_at(index);
 896   assert(address->is_return_address(), "bad return address");
 897   set_type_at(index, bottom_type());
 898 }
 899 
 900 // ------------------------------------------------------------------
 901 // ciTypeFlow::StateVector::trap
 902 //
 903 // Stop interpretation of this path with a trap.
 904 void ciTypeFlow::StateVector::trap(ciBytecodeStream* str, ciKlass* klass, int index) {
 905   _trap_bci = str->cur_bci();
 906   _trap_index = index;
 907 
 908   // Log information about this trap:
 909   CompileLog* log = outer()->env()->log();
 910   if (log != nullptr) {
 911     int mid = log->identify(outer()->method());
 912     int kid = (klass == nullptr)? -1: log->identify(klass);
 913     log->begin_elem("uncommon_trap method='%d' bci='%d'", mid, str->cur_bci());
 914     char buf[100];
 915     log->print(" %s", Deoptimization::format_trap_request(buf, sizeof(buf),
 916                                                           index));
 917     if (kid >= 0)
 918       log->print(" klass='%d'", kid);
 919     log->end_elem();
 920   }
 921 }
 922 
 923 // ------------------------------------------------------------------
 924 // ciTypeFlow::StateVector::do_null_assert
 925 // Corresponds to graphKit::do_null_assert.
 926 void ciTypeFlow::StateVector::do_null_assert(ciKlass* unloaded_klass) {
 927   if (unloaded_klass->is_loaded()) {
 928     // We failed to link, but we can still compute with this class,
 929     // since it is loaded somewhere.  The compiler will uncommon_trap
 930     // if the object is not null, but the typeflow pass can not assume
 931     // that the object will be null, otherwise it may incorrectly tell
 932     // the parser that an object is known to be null. 4761344, 4807707
 933     push_object(unloaded_klass);
 934   } else {
 935     // The class is not loaded anywhere.  It is safe to model the
 936     // null in the typestates, because we can compile in a null check
 937     // which will deoptimize us if someone manages to load the
 938     // class later.
 939     push_null();
 940   }
 941 }
 942 
 943 
 944 // ------------------------------------------------------------------
 945 // ciTypeFlow::StateVector::apply_one_bytecode
 946 //
 947 // Apply the effect of one bytecode to this StateVector
 948 bool ciTypeFlow::StateVector::apply_one_bytecode(ciBytecodeStream* str) {
 949   _trap_bci = -1;
 950   _trap_index = 0;
 951 
 952   if (CITraceTypeFlow) {
 953     tty->print_cr(">> Interpreting bytecode %d:%s", str->cur_bci(),
 954                   Bytecodes::name(str->cur_bc()));
 955   }
 956 
 957   switch(str->cur_bc()) {
 958   case Bytecodes::_aaload: do_aload(str);                           break;
 959 
 960   case Bytecodes::_aastore:
 961     {
 962       pop_object();
 963       pop_int();
 964       pop_objOrFlatArray();
 965       break;
 966     }
 967   case Bytecodes::_aconst_null:
 968     {
 969       push_null();
 970       break;
 971     }
 972   case Bytecodes::_aload:   load_local_object(str->get_index());    break;
 973   case Bytecodes::_aload_0: load_local_object(0);                   break;
 974   case Bytecodes::_aload_1: load_local_object(1);                   break;
 975   case Bytecodes::_aload_2: load_local_object(2);                   break;
 976   case Bytecodes::_aload_3: load_local_object(3);                   break;
 977 
 978   case Bytecodes::_anewarray:
 979     {
 980       pop_int();
 981       bool will_link;
 982       ciKlass* element_klass = str->get_klass(will_link);
 983       if (!will_link) {
 984         trap(str, element_klass, str->get_klass_index());
 985       } else {
 986         push_object(ciArrayKlass::make(element_klass));
 987       }
 988       break;
 989     }
 990   case Bytecodes::_areturn:
 991   case Bytecodes::_ifnonnull:
 992   case Bytecodes::_ifnull:
 993     {
 994       pop_object();
 995       break;
 996     }
 997   case Bytecodes::_monitorenter:
 998     {
 999       pop_object();
1000       set_monitor_count(monitor_count() + 1);
1001       break;
1002     }
1003   case Bytecodes::_monitorexit:
1004     {
1005       pop_object();
1006       assert(monitor_count() > 0, "must be a monitor to exit from");
1007       set_monitor_count(monitor_count() - 1);
1008       break;
1009     }
1010   case Bytecodes::_arraylength:
1011     {
1012       pop_array();
1013       push_int();
1014       break;
1015     }
1016   case Bytecodes::_astore:   store_local_object(str->get_index());  break;
1017   case Bytecodes::_astore_0: store_local_object(0);                 break;
1018   case Bytecodes::_astore_1: store_local_object(1);                 break;
1019   case Bytecodes::_astore_2: store_local_object(2);                 break;
1020   case Bytecodes::_astore_3: store_local_object(3);                 break;
1021 
1022   case Bytecodes::_athrow:
1023     {
1024       NEEDS_CLEANUP;
1025       pop_object();
1026       break;
1027     }
1028   case Bytecodes::_baload:
1029   case Bytecodes::_caload:
1030   case Bytecodes::_iaload:
1031   case Bytecodes::_saload:
1032     {
1033       pop_int();
1034       ciTypeArrayKlass* array_klass = pop_typeArray();
1035       // Put assert here for right type?
1036       push_int();
1037       break;
1038     }
1039   case Bytecodes::_bastore:
1040   case Bytecodes::_castore:
1041   case Bytecodes::_iastore:
1042   case Bytecodes::_sastore:
1043     {
1044       pop_int();
1045       pop_int();
1046       pop_typeArray();
1047       // assert here?
1048       break;
1049     }
1050   case Bytecodes::_bipush:
1051   case Bytecodes::_iconst_m1:
1052   case Bytecodes::_iconst_0:
1053   case Bytecodes::_iconst_1:
1054   case Bytecodes::_iconst_2:
1055   case Bytecodes::_iconst_3:
1056   case Bytecodes::_iconst_4:
1057   case Bytecodes::_iconst_5:
1058   case Bytecodes::_sipush:
1059     {
1060       push_int();
1061       break;
1062     }
1063   case Bytecodes::_checkcast: do_checkcast(str);                  break;
1064 
1065   case Bytecodes::_d2f:
1066     {
1067       pop_double();
1068       push_float();
1069       break;
1070     }
1071   case Bytecodes::_d2i:
1072     {
1073       pop_double();
1074       push_int();
1075       break;
1076     }
1077   case Bytecodes::_d2l:
1078     {
1079       pop_double();
1080       push_long();
1081       break;
1082     }
1083   case Bytecodes::_dadd:
1084   case Bytecodes::_ddiv:
1085   case Bytecodes::_dmul:
1086   case Bytecodes::_drem:
1087   case Bytecodes::_dsub:
1088     {
1089       pop_double();
1090       pop_double();
1091       push_double();
1092       break;
1093     }
1094   case Bytecodes::_daload:
1095     {
1096       pop_int();
1097       ciTypeArrayKlass* array_klass = pop_typeArray();
1098       // Put assert here for right type?
1099       push_double();
1100       break;
1101     }
1102   case Bytecodes::_dastore:
1103     {
1104       pop_double();
1105       pop_int();
1106       pop_typeArray();
1107       // assert here?
1108       break;
1109     }
1110   case Bytecodes::_dcmpg:
1111   case Bytecodes::_dcmpl:
1112     {
1113       pop_double();
1114       pop_double();
1115       push_int();
1116       break;
1117     }
1118   case Bytecodes::_dconst_0:
1119   case Bytecodes::_dconst_1:
1120     {
1121       push_double();
1122       break;
1123     }
1124   case Bytecodes::_dload:   load_local_double(str->get_index());    break;
1125   case Bytecodes::_dload_0: load_local_double(0);                   break;
1126   case Bytecodes::_dload_1: load_local_double(1);                   break;
1127   case Bytecodes::_dload_2: load_local_double(2);                   break;
1128   case Bytecodes::_dload_3: load_local_double(3);                   break;
1129 
1130   case Bytecodes::_dneg:
1131     {
1132       pop_double();
1133       push_double();
1134       break;
1135     }
1136   case Bytecodes::_dreturn:
1137     {
1138       pop_double();
1139       break;
1140     }
1141   case Bytecodes::_dstore:   store_local_double(str->get_index());  break;
1142   case Bytecodes::_dstore_0: store_local_double(0);                 break;
1143   case Bytecodes::_dstore_1: store_local_double(1);                 break;
1144   case Bytecodes::_dstore_2: store_local_double(2);                 break;
1145   case Bytecodes::_dstore_3: store_local_double(3);                 break;
1146 
1147   case Bytecodes::_dup:
1148     {
1149       push(type_at_tos());
1150       break;
1151     }
1152   case Bytecodes::_dup_x1:
1153     {
1154       ciType* value1 = pop_value();
1155       ciType* value2 = pop_value();
1156       push(value1);
1157       push(value2);
1158       push(value1);
1159       break;
1160     }
1161   case Bytecodes::_dup_x2:
1162     {
1163       ciType* value1 = pop_value();
1164       ciType* value2 = pop_value();
1165       ciType* value3 = pop_value();
1166       push(value1);
1167       push(value3);
1168       push(value2);
1169       push(value1);
1170       break;
1171     }
1172   case Bytecodes::_dup2:
1173     {
1174       ciType* value1 = pop_value();
1175       ciType* value2 = pop_value();
1176       push(value2);
1177       push(value1);
1178       push(value2);
1179       push(value1);
1180       break;
1181     }
1182   case Bytecodes::_dup2_x1:
1183     {
1184       ciType* value1 = pop_value();
1185       ciType* value2 = pop_value();
1186       ciType* value3 = pop_value();
1187       push(value2);
1188       push(value1);
1189       push(value3);
1190       push(value2);
1191       push(value1);
1192       break;
1193     }
1194   case Bytecodes::_dup2_x2:
1195     {
1196       ciType* value1 = pop_value();
1197       ciType* value2 = pop_value();
1198       ciType* value3 = pop_value();
1199       ciType* value4 = pop_value();
1200       push(value2);
1201       push(value1);
1202       push(value4);
1203       push(value3);
1204       push(value2);
1205       push(value1);
1206       break;
1207     }
1208   case Bytecodes::_f2d:
1209     {
1210       pop_float();
1211       push_double();
1212       break;
1213     }
1214   case Bytecodes::_f2i:
1215     {
1216       pop_float();
1217       push_int();
1218       break;
1219     }
1220   case Bytecodes::_f2l:
1221     {
1222       pop_float();
1223       push_long();
1224       break;
1225     }
1226   case Bytecodes::_fadd:
1227   case Bytecodes::_fdiv:
1228   case Bytecodes::_fmul:
1229   case Bytecodes::_frem:
1230   case Bytecodes::_fsub:
1231     {
1232       pop_float();
1233       pop_float();
1234       push_float();
1235       break;
1236     }
1237   case Bytecodes::_faload:
1238     {
1239       pop_int();
1240       ciTypeArrayKlass* array_klass = pop_typeArray();
1241       // Put assert here.
1242       push_float();
1243       break;
1244     }
1245   case Bytecodes::_fastore:
1246     {
1247       pop_float();
1248       pop_int();
1249       ciTypeArrayKlass* array_klass = pop_typeArray();
1250       // Put assert here.
1251       break;
1252     }
1253   case Bytecodes::_fcmpg:
1254   case Bytecodes::_fcmpl:
1255     {
1256       pop_float();
1257       pop_float();
1258       push_int();
1259       break;
1260     }
1261   case Bytecodes::_fconst_0:
1262   case Bytecodes::_fconst_1:
1263   case Bytecodes::_fconst_2:
1264     {
1265       push_float();
1266       break;
1267     }
1268   case Bytecodes::_fload:   load_local_float(str->get_index());     break;
1269   case Bytecodes::_fload_0: load_local_float(0);                    break;
1270   case Bytecodes::_fload_1: load_local_float(1);                    break;
1271   case Bytecodes::_fload_2: load_local_float(2);                    break;
1272   case Bytecodes::_fload_3: load_local_float(3);                    break;
1273 
1274   case Bytecodes::_fneg:
1275     {
1276       pop_float();
1277       push_float();
1278       break;
1279     }
1280   case Bytecodes::_freturn:
1281     {
1282       pop_float();
1283       break;
1284     }
1285   case Bytecodes::_fstore:    store_local_float(str->get_index());   break;
1286   case Bytecodes::_fstore_0:  store_local_float(0);                  break;
1287   case Bytecodes::_fstore_1:  store_local_float(1);                  break;
1288   case Bytecodes::_fstore_2:  store_local_float(2);                  break;
1289   case Bytecodes::_fstore_3:  store_local_float(3);                  break;
1290 
1291   case Bytecodes::_getfield:  do_getfield(str);                      break;
1292   case Bytecodes::_getstatic: do_getstatic(str);                     break;
1293 
1294   case Bytecodes::_goto:
1295   case Bytecodes::_goto_w:
1296   case Bytecodes::_nop:
1297   case Bytecodes::_return:
1298     {
1299       // do nothing.
1300       break;
1301     }
1302   case Bytecodes::_i2b:
1303   case Bytecodes::_i2c:
1304   case Bytecodes::_i2s:
1305   case Bytecodes::_ineg:
1306     {
1307       pop_int();
1308       push_int();
1309       break;
1310     }
1311   case Bytecodes::_i2d:
1312     {
1313       pop_int();
1314       push_double();
1315       break;
1316     }
1317   case Bytecodes::_i2f:
1318     {
1319       pop_int();
1320       push_float();
1321       break;
1322     }
1323   case Bytecodes::_i2l:
1324     {
1325       pop_int();
1326       push_long();
1327       break;
1328     }
1329   case Bytecodes::_iadd:
1330   case Bytecodes::_iand:
1331   case Bytecodes::_idiv:
1332   case Bytecodes::_imul:
1333   case Bytecodes::_ior:
1334   case Bytecodes::_irem:
1335   case Bytecodes::_ishl:
1336   case Bytecodes::_ishr:
1337   case Bytecodes::_isub:
1338   case Bytecodes::_iushr:
1339   case Bytecodes::_ixor:
1340     {
1341       pop_int();
1342       pop_int();
1343       push_int();
1344       break;
1345     }
1346   case Bytecodes::_if_acmpeq:
1347   case Bytecodes::_if_acmpne:
1348     {
1349       pop_object();
1350       pop_object();
1351       break;
1352     }
1353   case Bytecodes::_if_icmpeq:
1354   case Bytecodes::_if_icmpge:
1355   case Bytecodes::_if_icmpgt:
1356   case Bytecodes::_if_icmple:
1357   case Bytecodes::_if_icmplt:
1358   case Bytecodes::_if_icmpne:
1359     {
1360       pop_int();
1361       pop_int();
1362       break;
1363     }
1364   case Bytecodes::_ifeq:
1365   case Bytecodes::_ifle:
1366   case Bytecodes::_iflt:
1367   case Bytecodes::_ifge:
1368   case Bytecodes::_ifgt:
1369   case Bytecodes::_ifne:
1370   case Bytecodes::_ireturn:
1371   case Bytecodes::_lookupswitch:
1372   case Bytecodes::_tableswitch:
1373     {
1374       pop_int();
1375       break;
1376     }
1377   case Bytecodes::_iinc:
1378     {
1379       int lnum = str->get_index();
1380       check_int(local(lnum));
1381       store_to_local(lnum);
1382       break;
1383     }
1384   case Bytecodes::_iload:   load_local_int(str->get_index()); break;
1385   case Bytecodes::_iload_0: load_local_int(0);                      break;
1386   case Bytecodes::_iload_1: load_local_int(1);                      break;
1387   case Bytecodes::_iload_2: load_local_int(2);                      break;
1388   case Bytecodes::_iload_3: load_local_int(3);                      break;
1389 
1390   case Bytecodes::_instanceof:
1391     {
1392       // Check for uncommon trap:
1393       do_checkcast(str);
1394       pop_object();
1395       push_int();
1396       break;
1397     }
1398   case Bytecodes::_invokeinterface: do_invoke(str, true);           break;
1399   case Bytecodes::_invokespecial:   do_invoke(str, true);           break;
1400   case Bytecodes::_invokestatic:    do_invoke(str, false);          break;
1401   case Bytecodes::_invokevirtual:   do_invoke(str, true);           break;
1402   case Bytecodes::_invokedynamic:   do_invoke(str, false);          break;
1403 
1404   case Bytecodes::_istore:   store_local_int(str->get_index());     break;
1405   case Bytecodes::_istore_0: store_local_int(0);                    break;
1406   case Bytecodes::_istore_1: store_local_int(1);                    break;
1407   case Bytecodes::_istore_2: store_local_int(2);                    break;
1408   case Bytecodes::_istore_3: store_local_int(3);                    break;
1409 
1410   case Bytecodes::_jsr:
1411   case Bytecodes::_jsr_w: do_jsr(str);                              break;
1412 
1413   case Bytecodes::_l2d:
1414     {
1415       pop_long();
1416       push_double();
1417       break;
1418     }
1419   case Bytecodes::_l2f:
1420     {
1421       pop_long();
1422       push_float();
1423       break;
1424     }
1425   case Bytecodes::_l2i:
1426     {
1427       pop_long();
1428       push_int();
1429       break;
1430     }
1431   case Bytecodes::_ladd:
1432   case Bytecodes::_land:
1433   case Bytecodes::_ldiv:
1434   case Bytecodes::_lmul:
1435   case Bytecodes::_lor:
1436   case Bytecodes::_lrem:
1437   case Bytecodes::_lsub:
1438   case Bytecodes::_lxor:
1439     {
1440       pop_long();
1441       pop_long();
1442       push_long();
1443       break;
1444     }
1445   case Bytecodes::_laload:
1446     {
1447       pop_int();
1448       ciTypeArrayKlass* array_klass = pop_typeArray();
1449       // Put assert here for right type?
1450       push_long();
1451       break;
1452     }
1453   case Bytecodes::_lastore:
1454     {
1455       pop_long();
1456       pop_int();
1457       pop_typeArray();
1458       // assert here?
1459       break;
1460     }
1461   case Bytecodes::_lcmp:
1462     {
1463       pop_long();
1464       pop_long();
1465       push_int();
1466       break;
1467     }
1468   case Bytecodes::_lconst_0:
1469   case Bytecodes::_lconst_1:
1470     {
1471       push_long();
1472       break;
1473     }
1474   case Bytecodes::_ldc:
1475   case Bytecodes::_ldc_w:
1476   case Bytecodes::_ldc2_w:
1477     {
1478       do_ldc(str);
1479       break;
1480     }
1481 
1482   case Bytecodes::_lload:   load_local_long(str->get_index());      break;
1483   case Bytecodes::_lload_0: load_local_long(0);                     break;
1484   case Bytecodes::_lload_1: load_local_long(1);                     break;
1485   case Bytecodes::_lload_2: load_local_long(2);                     break;
1486   case Bytecodes::_lload_3: load_local_long(3);                     break;
1487 
1488   case Bytecodes::_lneg:
1489     {
1490       pop_long();
1491       push_long();
1492       break;
1493     }
1494   case Bytecodes::_lreturn:
1495     {
1496       pop_long();
1497       break;
1498     }
1499   case Bytecodes::_lshl:
1500   case Bytecodes::_lshr:
1501   case Bytecodes::_lushr:
1502     {
1503       pop_int();
1504       pop_long();
1505       push_long();
1506       break;
1507     }
1508   case Bytecodes::_lstore:   store_local_long(str->get_index());    break;
1509   case Bytecodes::_lstore_0: store_local_long(0);                   break;
1510   case Bytecodes::_lstore_1: store_local_long(1);                   break;
1511   case Bytecodes::_lstore_2: store_local_long(2);                   break;
1512   case Bytecodes::_lstore_3: store_local_long(3);                   break;
1513 
1514   case Bytecodes::_multianewarray: do_multianewarray(str);          break;
1515 
1516   case Bytecodes::_new:      do_new(str);                           break;
1517 
1518   case Bytecodes::_newarray: do_newarray(str);                      break;
1519 
1520   case Bytecodes::_pop:
1521     {
1522       pop();
1523       break;
1524     }
1525   case Bytecodes::_pop2:
1526     {
1527       pop();
1528       pop();
1529       break;
1530     }
1531 
1532   case Bytecodes::_putfield:       do_putfield(str);                 break;
1533   case Bytecodes::_putstatic:      do_putstatic(str);                break;
1534 
1535   case Bytecodes::_ret: do_ret(str);                                 break;
1536 
1537   case Bytecodes::_swap:
1538     {
1539       ciType* value1 = pop_value();
1540       ciType* value2 = pop_value();
1541       push(value1);
1542       push(value2);
1543       break;
1544     }
1545 
1546   case Bytecodes::_wide:
1547   default:
1548     {
1549       // The iterator should skip this.
1550       ShouldNotReachHere();
1551       break;
1552     }
1553   }
1554 
1555   if (CITraceTypeFlow) {
1556     print_on(tty);
1557   }
1558 
1559   return (_trap_bci != -1);
1560 }
1561 
1562 #ifndef PRODUCT
1563 // ------------------------------------------------------------------
1564 // ciTypeFlow::StateVector::print_cell_on
1565 void ciTypeFlow::StateVector::print_cell_on(outputStream* st, Cell c) const {
1566   ciType* type = type_at(c)->unwrap();
1567   if (type == top_type()) {
1568     st->print("top");
1569   } else if (type == bottom_type()) {
1570     st->print("bottom");
1571   } else if (type == null_type()) {
1572     st->print("null");
1573   } else if (type == long2_type()) {
1574     st->print("long2");
1575   } else if (type == double2_type()) {
1576     st->print("double2");
1577   } else if (is_int(type)) {
1578     st->print("int");
1579   } else if (is_long(type)) {
1580     st->print("long");
1581   } else if (is_float(type)) {
1582     st->print("float");
1583   } else if (is_double(type)) {
1584     st->print("double");
1585   } else if (type->is_return_address()) {
1586     st->print("address(%d)", type->as_return_address()->bci());
1587   } else {
1588     if (type->is_klass()) {
1589       type->as_klass()->name()->print_symbol_on(st);
1590     } else {
1591       st->print("UNEXPECTED TYPE");
1592       type->print();
1593     }
1594   }
1595 }
1596 
1597 // ------------------------------------------------------------------
1598 // ciTypeFlow::StateVector::print_on
1599 void ciTypeFlow::StateVector::print_on(outputStream* st) const {
1600   int num_locals   = _outer->max_locals();
1601   int num_stack    = stack_size();
1602   int num_monitors = monitor_count();
1603   st->print_cr("  State : locals %d, stack %d, monitors %d", num_locals, num_stack, num_monitors);
1604   if (num_stack >= 0) {
1605     int i;
1606     for (i = 0; i < num_locals; i++) {
1607       st->print("    local %2d : ", i);
1608       print_cell_on(st, local(i));
1609       st->cr();
1610     }
1611     for (i = 0; i < num_stack; i++) {
1612       st->print("    stack %2d : ", i);
1613       print_cell_on(st, stack(i));
1614       st->cr();
1615     }
1616   }
1617 }
1618 #endif
1619 
1620 
1621 // ------------------------------------------------------------------
1622 // ciTypeFlow::SuccIter::next
1623 //
1624 void ciTypeFlow::SuccIter::next() {
1625   int succ_ct = _pred->successors()->length();
1626   int next = _index + 1;
1627   if (next < succ_ct) {
1628     _index = next;
1629     _succ = _pred->successors()->at(next);
1630     return;
1631   }
1632   for (int i = next - succ_ct; i < _pred->exceptions()->length(); i++) {
1633     // Do not compile any code for unloaded exception types.
1634     // Following compiler passes are responsible for doing this also.
1635     ciInstanceKlass* exception_klass = _pred->exc_klasses()->at(i);
1636     if (exception_klass->is_loaded()) {
1637       _index = next;
1638       _succ = _pred->exceptions()->at(i);
1639       return;
1640     }
1641     next++;
1642   }
1643   _index = -1;
1644   _succ = nullptr;
1645 }
1646 
1647 // ------------------------------------------------------------------
1648 // ciTypeFlow::SuccIter::set_succ
1649 //
1650 void ciTypeFlow::SuccIter::set_succ(Block* succ) {
1651   int succ_ct = _pred->successors()->length();
1652   if (_index < succ_ct) {
1653     _pred->successors()->at_put(_index, succ);
1654   } else {
1655     int idx = _index - succ_ct;
1656     _pred->exceptions()->at_put(idx, succ);
1657   }
1658 }
1659 
1660 // ciTypeFlow::Block
1661 //
1662 // A basic block.
1663 
1664 // ------------------------------------------------------------------
1665 // ciTypeFlow::Block::Block
1666 ciTypeFlow::Block::Block(ciTypeFlow* outer,
1667                          ciBlock *ciblk,
1668                          ciTypeFlow::JsrSet* jsrs) : _predecessors(outer->arena(), 1, 0, nullptr) {
1669   _ciblock = ciblk;
1670   _exceptions = nullptr;
1671   _exc_klasses = nullptr;
1672   _successors = nullptr;
1673   _state = new (outer->arena()) StateVector(outer);
1674   JsrSet* new_jsrs =
1675     new (outer->arena()) JsrSet(outer->arena(), jsrs->size());
1676   jsrs->copy_into(new_jsrs);
1677   _jsrs = new_jsrs;
1678   _next = nullptr;
1679   _on_work_list = false;
1680   _backedge_copy = false;
1681   _has_monitorenter = false;
1682   _trap_bci = -1;
1683   _trap_index = 0;
1684   df_init();
1685 
1686   if (CITraceTypeFlow) {
1687     tty->print_cr(">> Created new block");
1688     print_on(tty);
1689   }
1690 
1691   assert(this->outer() == outer, "outer link set up");
1692   assert(!outer->have_block_count(), "must not have mapped blocks yet");
1693 }
1694 
1695 // ------------------------------------------------------------------
1696 // ciTypeFlow::Block::df_init
1697 void ciTypeFlow::Block::df_init() {
1698   _pre_order = -1; assert(!has_pre_order(), "");
1699   _post_order = -1; assert(!has_post_order(), "");
1700   _loop = nullptr;
1701   _irreducible_loop_head = false;
1702   _irreducible_loop_secondary_entry = false;
1703   _rpo_next = nullptr;
1704 }
1705 
1706 // ------------------------------------------------------------------
1707 // ciTypeFlow::Block::successors
1708 //
1709 // Get the successors for this Block.
1710 GrowableArray<ciTypeFlow::Block*>*
1711 ciTypeFlow::Block::successors(ciBytecodeStream* str,
1712                               ciTypeFlow::StateVector* state,
1713                               ciTypeFlow::JsrSet* jsrs) {
1714   if (_successors == nullptr) {
1715     if (CITraceTypeFlow) {
1716       tty->print(">> Computing successors for block ");
1717       print_value_on(tty);
1718       tty->cr();
1719     }
1720 
1721     ciTypeFlow* analyzer = outer();
1722     Arena* arena = analyzer->arena();
1723     Block* block = nullptr;
1724     bool has_successor = !has_trap() &&
1725                          (control() != ciBlock::fall_through_bci || limit() < analyzer->code_size());
1726     if (!has_successor) {
1727       _successors =
1728         new (arena) GrowableArray<Block*>(arena, 1, 0, nullptr);
1729       // No successors
1730     } else if (control() == ciBlock::fall_through_bci) {
1731       assert(str->cur_bci() == limit(), "bad block end");
1732       // This block simply falls through to the next.
1733       _successors =
1734         new (arena) GrowableArray<Block*>(arena, 1, 0, nullptr);
1735 
1736       Block* block = analyzer->block_at(limit(), _jsrs);
1737       assert(_successors->length() == FALL_THROUGH, "");
1738       _successors->append(block);
1739     } else {
1740       int current_bci = str->cur_bci();
1741       int next_bci = str->next_bci();
1742       int branch_bci = -1;
1743       Block* target = nullptr;
1744       assert(str->next_bci() == limit(), "bad block end");
1745       // This block is not a simple fall-though.  Interpret
1746       // the current bytecode to find our successors.
1747       switch (str->cur_bc()) {
1748       case Bytecodes::_ifeq:         case Bytecodes::_ifne:
1749       case Bytecodes::_iflt:         case Bytecodes::_ifge:
1750       case Bytecodes::_ifgt:         case Bytecodes::_ifle:
1751       case Bytecodes::_if_icmpeq:    case Bytecodes::_if_icmpne:
1752       case Bytecodes::_if_icmplt:    case Bytecodes::_if_icmpge:
1753       case Bytecodes::_if_icmpgt:    case Bytecodes::_if_icmple:
1754       case Bytecodes::_if_acmpeq:    case Bytecodes::_if_acmpne:
1755       case Bytecodes::_ifnull:       case Bytecodes::_ifnonnull:
1756         // Our successors are the branch target and the next bci.
1757         branch_bci = str->get_dest();
1758         _successors =
1759           new (arena) GrowableArray<Block*>(arena, 2, 0, nullptr);
1760         assert(_successors->length() == IF_NOT_TAKEN, "");
1761         _successors->append(analyzer->block_at(next_bci, jsrs));
1762         assert(_successors->length() == IF_TAKEN, "");
1763         _successors->append(analyzer->block_at(branch_bci, jsrs));
1764         break;
1765 
1766       case Bytecodes::_goto:
1767         branch_bci = str->get_dest();
1768         _successors =
1769           new (arena) GrowableArray<Block*>(arena, 1, 0, nullptr);
1770         assert(_successors->length() == GOTO_TARGET, "");
1771         _successors->append(analyzer->block_at(branch_bci, jsrs));
1772         break;
1773 
1774       case Bytecodes::_jsr:
1775         branch_bci = str->get_dest();
1776         _successors =
1777           new (arena) GrowableArray<Block*>(arena, 1, 0, nullptr);
1778         assert(_successors->length() == GOTO_TARGET, "");
1779         _successors->append(analyzer->block_at(branch_bci, jsrs));
1780         break;
1781 
1782       case Bytecodes::_goto_w:
1783       case Bytecodes::_jsr_w:
1784         _successors =
1785           new (arena) GrowableArray<Block*>(arena, 1, 0, nullptr);
1786         assert(_successors->length() == GOTO_TARGET, "");
1787         _successors->append(analyzer->block_at(str->get_far_dest(), jsrs));
1788         break;
1789 
1790       case Bytecodes::_tableswitch:  {
1791         Bytecode_tableswitch tableswitch(str);
1792 
1793         int len = tableswitch.length();
1794         _successors =
1795           new (arena) GrowableArray<Block*>(arena, len+1, 0, nullptr);
1796         int bci = current_bci + tableswitch.default_offset();
1797         Block* block = analyzer->block_at(bci, jsrs);
1798         assert(_successors->length() == SWITCH_DEFAULT, "");
1799         _successors->append(block);
1800         while (--len >= 0) {
1801           int bci = current_bci + tableswitch.dest_offset_at(len);
1802           block = analyzer->block_at(bci, jsrs);
1803           assert(_successors->length() >= SWITCH_CASES, "");
1804           _successors->append_if_missing(block);
1805         }
1806         break;
1807       }
1808 
1809       case Bytecodes::_lookupswitch: {
1810         Bytecode_lookupswitch lookupswitch(str);
1811 
1812         int npairs = lookupswitch.number_of_pairs();
1813         _successors =
1814           new (arena) GrowableArray<Block*>(arena, npairs+1, 0, nullptr);
1815         int bci = current_bci + lookupswitch.default_offset();
1816         Block* block = analyzer->block_at(bci, jsrs);
1817         assert(_successors->length() == SWITCH_DEFAULT, "");
1818         _successors->append(block);
1819         while(--npairs >= 0) {
1820           LookupswitchPair pair = lookupswitch.pair_at(npairs);
1821           int bci = current_bci + pair.offset();
1822           Block* block = analyzer->block_at(bci, jsrs);
1823           assert(_successors->length() >= SWITCH_CASES, "");
1824           _successors->append_if_missing(block);
1825         }
1826         break;
1827       }
1828 
1829       case Bytecodes::_athrow:
1830       case Bytecodes::_ireturn:
1831       case Bytecodes::_lreturn:
1832       case Bytecodes::_freturn:
1833       case Bytecodes::_dreturn:
1834       case Bytecodes::_areturn:
1835       case Bytecodes::_return:
1836         _successors =
1837           new (arena) GrowableArray<Block*>(arena, 1, 0, nullptr);
1838         // No successors
1839         break;
1840 
1841       case Bytecodes::_ret: {
1842         _successors =
1843           new (arena) GrowableArray<Block*>(arena, 1, 0, nullptr);
1844 
1845         Cell local = state->local(str->get_index());
1846         ciType* return_address = state->type_at(local);
1847         assert(return_address->is_return_address(), "verify: wrong type");
1848         int bci = return_address->as_return_address()->bci();
1849         assert(_successors->length() == GOTO_TARGET, "");
1850         _successors->append(analyzer->block_at(bci, jsrs));
1851         break;
1852       }
1853 
1854       case Bytecodes::_wide:
1855       default:
1856         ShouldNotReachHere();
1857         break;
1858       }
1859     }
1860 
1861     // Set predecessor information
1862     for (int i = 0; i < _successors->length(); i++) {
1863       Block* block = _successors->at(i);
1864       block->predecessors()->append(this);
1865     }
1866   }
1867   return _successors;
1868 }
1869 
1870 // ------------------------------------------------------------------
1871 // ciTypeFlow::Block:compute_exceptions
1872 //
1873 // Compute the exceptional successors and types for this Block.
1874 void ciTypeFlow::Block::compute_exceptions() {
1875   assert(_exceptions == nullptr && _exc_klasses == nullptr, "repeat");
1876 
1877   if (CITraceTypeFlow) {
1878     tty->print(">> Computing exceptions for block ");
1879     print_value_on(tty);
1880     tty->cr();
1881   }
1882 
1883   ciTypeFlow* analyzer = outer();
1884   Arena* arena = analyzer->arena();
1885 
1886   // Any bci in the block will do.
1887   ciExceptionHandlerStream str(analyzer->method(), start());
1888 
1889   // Allocate our growable arrays.
1890   int exc_count = str.count();
1891   _exceptions = new (arena) GrowableArray<Block*>(arena, exc_count, 0, nullptr);
1892   _exc_klasses = new (arena) GrowableArray<ciInstanceKlass*>(arena, exc_count,
1893                                                              0, nullptr);
1894 
1895   for ( ; !str.is_done(); str.next()) {
1896     ciExceptionHandler* handler = str.handler();
1897     int bci = handler->handler_bci();
1898     ciInstanceKlass* klass = nullptr;
1899     if (bci == -1) {
1900       // There is no catch all.  It is possible to exit the method.
1901       break;
1902     }
1903     if (handler->is_catch_all()) {
1904       klass = analyzer->env()->Throwable_klass();
1905     } else {
1906       klass = handler->catch_klass();
1907     }
1908     Block* block = analyzer->block_at(bci, _jsrs);
1909     _exceptions->append(block);
1910     block->predecessors()->append(this);
1911     _exc_klasses->append(klass);
1912   }
1913 }
1914 
1915 // ------------------------------------------------------------------
1916 // ciTypeFlow::Block::set_backedge_copy
1917 // Use this only to make a pre-existing public block into a backedge copy.
1918 void ciTypeFlow::Block::set_backedge_copy(bool z) {
1919   assert(z || (z == is_backedge_copy()), "cannot make a backedge copy public");
1920   _backedge_copy = z;
1921 }
1922 
1923 // Analogous to PhaseIdealLoop::is_in_irreducible_loop
1924 bool ciTypeFlow::Block::is_in_irreducible_loop() const {
1925   if (!outer()->has_irreducible_entry()) {
1926     return false; // No irreducible loop in method.
1927   }
1928   Loop* lp = loop(); // Innermost loop containing block.
1929   if (lp == nullptr) {
1930     assert(!is_post_visited(), "must have enclosing loop once post-visited");
1931     return false; // Not yet processed, so we do not know, yet.
1932   }
1933   // Walk all the way up the loop-tree, search for an irreducible loop.
1934   do {
1935     if (lp->is_irreducible()) {
1936       return true; // We are in irreducible loop.
1937     }
1938     if (lp->head()->pre_order() == 0) {
1939       return false; // Found root loop, terminate.
1940     }
1941     lp = lp->parent();
1942   } while (lp != nullptr);
1943   // We have "lp->parent() == nullptr", which happens only for infinite loops,
1944   // where no parent is attached to the loop. We did not find any irreducible
1945   // loop from this block out to lp. Thus lp only has one entry, and no exit
1946   // (it is infinite and reducible). We can always rewrite an infinite loop
1947   // that is nested inside other loops:
1948   // while(condition) { infinite_loop; }
1949   // with an equivalent program where the infinite loop is an outermost loop
1950   // that is not nested in any loop:
1951   // while(condition) { break; } infinite_loop;
1952   // Thus, we can understand lp as an outermost loop, and can terminate and
1953   // conclude: this block is in no irreducible loop.
1954   return false;
1955 }
1956 
1957 // ------------------------------------------------------------------
1958 // ciTypeFlow::Block::is_clonable_exit
1959 //
1960 // At most 2 normal successors, one of which continues looping,
1961 // and all exceptional successors must exit.
1962 bool ciTypeFlow::Block::is_clonable_exit(ciTypeFlow::Loop* lp) {
1963   int normal_cnt  = 0;
1964   int in_loop_cnt = 0;
1965   for (SuccIter iter(this); !iter.done(); iter.next()) {
1966     Block* succ = iter.succ();
1967     if (iter.is_normal_ctrl()) {
1968       if (++normal_cnt > 2) return false;
1969       if (lp->contains(succ->loop())) {
1970         if (++in_loop_cnt > 1) return false;
1971       }
1972     } else {
1973       if (lp->contains(succ->loop())) return false;
1974     }
1975   }
1976   return in_loop_cnt == 1;
1977 }
1978 
1979 // ------------------------------------------------------------------
1980 // ciTypeFlow::Block::looping_succ
1981 //
1982 ciTypeFlow::Block* ciTypeFlow::Block::looping_succ(ciTypeFlow::Loop* lp) {
1983   assert(successors()->length() <= 2, "at most 2 normal successors");
1984   for (SuccIter iter(this); !iter.done(); iter.next()) {
1985     Block* succ = iter.succ();
1986     if (lp->contains(succ->loop())) {
1987       return succ;
1988     }
1989   }
1990   return nullptr;
1991 }
1992 
1993 #ifndef PRODUCT
1994 // ------------------------------------------------------------------
1995 // ciTypeFlow::Block::print_value_on
1996 void ciTypeFlow::Block::print_value_on(outputStream* st) const {
1997   if (has_pre_order()) st->print("#%-2d ", pre_order());
1998   if (has_rpo())       st->print("rpo#%-2d ", rpo());
1999   st->print("[%d - %d)", start(), limit());
2000   if (is_loop_head()) st->print(" lphd");
2001   if (is_in_irreducible_loop()) st->print(" in_irred");
2002   if (is_irreducible_loop_head()) st->print(" irred_head");
2003   if (is_irreducible_loop_secondary_entry()) st->print(" irred_entry");
2004   if (_jsrs->size() > 0) { st->print("/");  _jsrs->print_on(st); }
2005   if (is_backedge_copy())  st->print("/backedge_copy");
2006 }
2007 
2008 // ------------------------------------------------------------------
2009 // ciTypeFlow::Block::print_on
2010 void ciTypeFlow::Block::print_on(outputStream* st) const {
2011   if ((Verbose || WizardMode) && (limit() >= 0)) {
2012     // Don't print 'dummy' blocks (i.e. blocks with limit() '-1')
2013     outer()->method()->print_codes_on(start(), limit(), st);
2014   }
2015   st->print_cr("  ====================================================  ");
2016   st->print ("  ");
2017   print_value_on(st);
2018   st->print(" Stored locals: "); def_locals()->print_on(st, outer()->method()->max_locals()); tty->cr();
2019   if (loop() && loop()->parent() != nullptr) {
2020     st->print(" loops:");
2021     Loop* lp = loop();
2022     do {
2023       st->print(" %d<-%d", lp->head()->pre_order(),lp->tail()->pre_order());
2024       if (lp->is_irreducible()) st->print("(ir)");
2025       lp = lp->parent();
2026     } while (lp->parent() != nullptr);
2027   }
2028   st->cr();
2029   _state->print_on(st);
2030   if (_successors == nullptr) {
2031     st->print_cr("  No successor information");
2032   } else {
2033     int num_successors = _successors->length();
2034     st->print_cr("  Successors : %d", num_successors);
2035     for (int i = 0; i < num_successors; i++) {
2036       Block* successor = _successors->at(i);
2037       st->print("    ");
2038       successor->print_value_on(st);
2039       st->cr();
2040     }
2041   }
2042   if (_predecessors.is_empty()) {
2043     st->print_cr("  No predecessor information");
2044   } else {
2045     int num_predecessors = _predecessors.length();
2046     st->print_cr("  Predecessors : %d", num_predecessors);
2047     for (int i = 0; i < num_predecessors; i++) {
2048       Block* predecessor = _predecessors.at(i);
2049       st->print("    ");
2050       predecessor->print_value_on(st);
2051       st->cr();
2052     }
2053   }
2054   if (_exceptions == nullptr) {
2055     st->print_cr("  No exception information");
2056   } else {
2057     int num_exceptions = _exceptions->length();
2058     st->print_cr("  Exceptions : %d", num_exceptions);
2059     for (int i = 0; i < num_exceptions; i++) {
2060       Block* exc_succ = _exceptions->at(i);
2061       ciInstanceKlass* exc_klass = _exc_klasses->at(i);
2062       st->print("    ");
2063       exc_succ->print_value_on(st);
2064       st->print(" -- ");
2065       exc_klass->name()->print_symbol_on(st);
2066       st->cr();
2067     }
2068   }
2069   if (has_trap()) {
2070     st->print_cr("  Traps on %d with trap index %d", trap_bci(), trap_index());
2071   }
2072   st->print_cr("  ====================================================  ");
2073 }
2074 #endif
2075 
2076 #ifndef PRODUCT
2077 // ------------------------------------------------------------------
2078 // ciTypeFlow::LocalSet::print_on
2079 void ciTypeFlow::LocalSet::print_on(outputStream* st, int limit) const {
2080   st->print("{");
2081   for (int i = 0; i < max; i++) {
2082     if (test(i)) st->print(" %d", i);
2083   }
2084   if (limit > max) {
2085     st->print(" %d..%d ", max, limit);
2086   }
2087   st->print(" }");
2088 }
2089 #endif
2090 
2091 // ciTypeFlow
2092 //
2093 // This is a pass over the bytecodes which computes the following:
2094 //   basic block structure
2095 //   interpreter type-states (a la the verifier)
2096 
2097 // ------------------------------------------------------------------
2098 // ciTypeFlow::ciTypeFlow
2099 ciTypeFlow::ciTypeFlow(ciEnv* env, ciMethod* method, int osr_bci) {
2100   _env = env;
2101   _method = method;
2102   _has_irreducible_entry = false;
2103   _osr_bci = osr_bci;
2104   _failure_reason = nullptr;
2105   assert(0 <= start_bci() && start_bci() < code_size() , "correct osr_bci argument: 0 <= %d < %d", start_bci(), code_size());
2106   _work_list = nullptr;
2107 
2108   int ciblock_count = _method->get_method_blocks()->num_blocks();
2109   _idx_to_blocklist = NEW_ARENA_ARRAY(arena(), GrowableArray<Block*>*, ciblock_count);
2110   for (int i = 0; i < ciblock_count; i++) {
2111     _idx_to_blocklist[i] = nullptr;
2112   }
2113   _block_map = nullptr;  // until all blocks are seen
2114   _jsr_records = nullptr;
2115 }
2116 
2117 // ------------------------------------------------------------------
2118 // ciTypeFlow::work_list_next
2119 //
2120 // Get the next basic block from our work list.
2121 ciTypeFlow::Block* ciTypeFlow::work_list_next() {
2122   assert(!work_list_empty(), "work list must not be empty");
2123   Block* next_block = _work_list;
2124   _work_list = next_block->next();
2125   next_block->set_next(nullptr);
2126   next_block->set_on_work_list(false);
2127   return next_block;
2128 }
2129 
2130 // ------------------------------------------------------------------
2131 // ciTypeFlow::add_to_work_list
2132 //
2133 // Add a basic block to our work list.
2134 // List is sorted by decreasing postorder sort (same as increasing RPO)
2135 void ciTypeFlow::add_to_work_list(ciTypeFlow::Block* block) {
2136   assert(!block->is_on_work_list(), "must not already be on work list");
2137 
2138   if (CITraceTypeFlow) {
2139     tty->print(">> Adding block ");
2140     block->print_value_on(tty);
2141     tty->print_cr(" to the work list : ");
2142   }
2143 
2144   block->set_on_work_list(true);
2145 
2146   // decreasing post order sort
2147 
2148   Block* prev = nullptr;
2149   Block* current = _work_list;
2150   int po = block->post_order();
2151   while (current != nullptr) {
2152     if (!current->has_post_order() || po > current->post_order())
2153       break;
2154     prev = current;
2155     current = current->next();
2156   }
2157   if (prev == nullptr) {
2158     block->set_next(_work_list);
2159     _work_list = block;
2160   } else {
2161     block->set_next(current);
2162     prev->set_next(block);
2163   }
2164 
2165   if (CITraceTypeFlow) {
2166     tty->cr();
2167   }
2168 }
2169 
2170 // ------------------------------------------------------------------
2171 // ciTypeFlow::block_at
2172 //
2173 // Return the block beginning at bci which has a JsrSet compatible
2174 // with jsrs.
2175 ciTypeFlow::Block* ciTypeFlow::block_at(int bci, ciTypeFlow::JsrSet* jsrs, CreateOption option) {
2176   // First find the right ciBlock.
2177   if (CITraceTypeFlow) {
2178     tty->print(">> Requesting block for %d/", bci);
2179     jsrs->print_on(tty);
2180     tty->cr();
2181   }
2182 
2183   ciBlock* ciblk = _method->get_method_blocks()->block_containing(bci);
2184   assert(ciblk->start_bci() == bci, "bad ciBlock boundaries");
2185   Block* block = get_block_for(ciblk->index(), jsrs, option);
2186 
2187   assert(block == nullptr? (option == no_create): block->is_backedge_copy() == (option == create_backedge_copy), "create option consistent with result");
2188 
2189   if (CITraceTypeFlow) {
2190     if (block != nullptr) {
2191       tty->print(">> Found block ");
2192       block->print_value_on(tty);
2193       tty->cr();
2194     } else {
2195       tty->print_cr(">> No such block.");
2196     }
2197   }
2198 
2199   return block;
2200 }
2201 
2202 // ------------------------------------------------------------------
2203 // ciTypeFlow::make_jsr_record
2204 //
2205 // Make a JsrRecord for a given (entry, return) pair, if such a record
2206 // does not already exist.
2207 ciTypeFlow::JsrRecord* ciTypeFlow::make_jsr_record(int entry_address,
2208                                                    int return_address) {
2209   if (_jsr_records == nullptr) {
2210     _jsr_records = new (arena()) GrowableArray<JsrRecord*>(arena(),
2211                                                            2,
2212                                                            0,
2213                                                            nullptr);
2214   }
2215   JsrRecord* record = nullptr;
2216   int len = _jsr_records->length();
2217   for (int i = 0; i < len; i++) {
2218     JsrRecord* record = _jsr_records->at(i);
2219     if (record->entry_address() == entry_address &&
2220         record->return_address() == return_address) {
2221       return record;
2222     }
2223   }
2224 
2225   record = new (arena()) JsrRecord(entry_address, return_address);
2226   _jsr_records->append(record);
2227   return record;
2228 }
2229 
2230 // ------------------------------------------------------------------
2231 // ciTypeFlow::flow_exceptions
2232 //
2233 // Merge the current state into all exceptional successors at the
2234 // current point in the code.
2235 void ciTypeFlow::flow_exceptions(GrowableArray<ciTypeFlow::Block*>* exceptions,
2236                                  GrowableArray<ciInstanceKlass*>* exc_klasses,
2237                                  ciTypeFlow::StateVector* state) {
2238   int len = exceptions->length();
2239   assert(exc_klasses->length() == len, "must have same length");
2240   for (int i = 0; i < len; i++) {
2241     Block* block = exceptions->at(i);
2242     ciInstanceKlass* exception_klass = exc_klasses->at(i);
2243 
2244     if (!exception_klass->is_loaded()) {
2245       // Do not compile any code for unloaded exception types.
2246       // Following compiler passes are responsible for doing this also.
2247       continue;
2248     }
2249 
2250     if (block->meet_exception(exception_klass, state)) {
2251       // Block was modified and has PO.  Add it to the work list.
2252       if (block->has_post_order() &&
2253           !block->is_on_work_list()) {
2254         add_to_work_list(block);
2255       }
2256     }
2257   }
2258 }
2259 
2260 // ------------------------------------------------------------------
2261 // ciTypeFlow::flow_successors
2262 //
2263 // Merge the current state into all successors at the current point
2264 // in the code.
2265 void ciTypeFlow::flow_successors(GrowableArray<ciTypeFlow::Block*>* successors,
2266                                  ciTypeFlow::StateVector* state) {
2267   int len = successors->length();
2268   for (int i = 0; i < len; i++) {
2269     Block* block = successors->at(i);
2270     if (block->meet(state)) {
2271       // Block was modified and has PO.  Add it to the work list.
2272       if (block->has_post_order() &&
2273           !block->is_on_work_list()) {
2274         add_to_work_list(block);
2275       }
2276     }
2277   }
2278 }
2279 
2280 // ------------------------------------------------------------------
2281 // ciTypeFlow::can_trap
2282 //
2283 // Tells if a given instruction is able to generate an exception edge.
2284 bool ciTypeFlow::can_trap(ciBytecodeStream& str) {
2285   // Cf. GenerateOopMap::do_exception_edge.
2286   if (!Bytecodes::can_trap(str.cur_bc()))  return false;
2287 
2288   switch (str.cur_bc()) {
2289     case Bytecodes::_ldc:
2290     case Bytecodes::_ldc_w:
2291     case Bytecodes::_ldc2_w:
2292       return str.is_in_error() || !str.get_constant().is_loaded();
2293 
2294     case Bytecodes::_aload_0:
2295       // These bytecodes can trap for rewriting.  We need to assume that
2296       // they do not throw exceptions to make the monitor analysis work.
2297       return false;
2298 
2299     case Bytecodes::_ireturn:
2300     case Bytecodes::_lreturn:
2301     case Bytecodes::_freturn:
2302     case Bytecodes::_dreturn:
2303     case Bytecodes::_areturn:
2304     case Bytecodes::_return:
2305       // We can assume the monitor stack is empty in this analysis.
2306       return false;
2307 
2308     case Bytecodes::_monitorexit:
2309       // We can assume monitors are matched in this analysis.
2310       return false;
2311 
2312     default:
2313       return true;
2314   }
2315 }
2316 
2317 // ------------------------------------------------------------------
2318 // ciTypeFlow::clone_loop_heads
2319 //
2320 // Clone the loop heads
2321 bool ciTypeFlow::clone_loop_heads(StateVector* temp_vector, JsrSet* temp_set) {
2322   bool rslt = false;
2323   for (PreorderLoops iter(loop_tree_root()); !iter.done(); iter.next()) {
2324     Loop* lp = iter.current();
2325     Block* head = lp->head();
2326     if (lp == loop_tree_root() ||
2327         lp->is_irreducible() ||
2328         !head->is_clonable_exit(lp))
2329       continue;
2330 
2331     // Avoid BoxLock merge.
2332     if (EliminateNestedLocks && head->has_monitorenter())
2333       continue;
2334 
2335     // check not already cloned
2336     if (head->backedge_copy_count() != 0)
2337       continue;
2338 
2339     // Don't clone head of OSR loop to get correct types in start block.
2340     if (is_osr_flow() && head->start() == start_bci())
2341       continue;
2342 
2343     // check _no_ shared head below us
2344     Loop* ch;
2345     for (ch = lp->child(); ch != nullptr && ch->head() != head; ch = ch->sibling());
2346     if (ch != nullptr)
2347       continue;
2348 
2349     // Clone head
2350     Block* new_head = head->looping_succ(lp);
2351     Block* clone = clone_loop_head(lp, temp_vector, temp_set);
2352     // Update lp's info
2353     clone->set_loop(lp);
2354     lp->set_head(new_head);
2355     lp->set_tail(clone);
2356     // And move original head into outer loop
2357     head->set_loop(lp->parent());
2358 
2359     rslt = true;
2360   }
2361   return rslt;
2362 }
2363 
2364 // ------------------------------------------------------------------
2365 // ciTypeFlow::clone_loop_head
2366 //
2367 // Clone lp's head and replace tail's successors with clone.
2368 //
2369 //  |
2370 //  v
2371 // head <-> body
2372 //  |
2373 //  v
2374 // exit
2375 //
2376 // new_head
2377 //
2378 //  |
2379 //  v
2380 // head ----------\
2381 //  |             |
2382 //  |             v
2383 //  |  clone <-> body
2384 //  |    |
2385 //  | /--/
2386 //  | |
2387 //  v v
2388 // exit
2389 //
2390 ciTypeFlow::Block* ciTypeFlow::clone_loop_head(Loop* lp, StateVector* temp_vector, JsrSet* temp_set) {
2391   Block* head = lp->head();
2392   Block* tail = lp->tail();
2393   if (CITraceTypeFlow) {
2394     tty->print(">> Requesting clone of loop head "); head->print_value_on(tty);
2395     tty->print("  for predecessor ");                tail->print_value_on(tty);
2396     tty->cr();
2397   }
2398   Block* clone = block_at(head->start(), head->jsrs(), create_backedge_copy);
2399   assert(clone->backedge_copy_count() == 1, "one backedge copy for all back edges");
2400 
2401   assert(!clone->has_pre_order(), "just created");
2402   clone->set_next_pre_order();
2403 
2404   // Accumulate profiled count for all backedges that share this loop's head
2405   int total_count = lp->profiled_count();
2406   for (Loop* lp1 = lp->parent(); lp1 != nullptr; lp1 = lp1->parent()) {
2407     for (Loop* lp2 = lp1; lp2 != nullptr; lp2 = lp2->sibling()) {
2408       if (lp2->head() == head && !lp2->tail()->is_backedge_copy()) {
2409         total_count += lp2->profiled_count();
2410       }
2411     }
2412   }
2413   // Have the most frequent ones branch to the clone instead
2414   int count = 0;
2415   int loops_with_shared_head = 0;
2416   Block* latest_tail = tail;
2417   bool done = false;
2418   for (Loop* lp1 = lp; lp1 != nullptr && !done; lp1 = lp1->parent()) {
2419     for (Loop* lp2 = lp1; lp2 != nullptr && !done; lp2 = lp2->sibling()) {
2420       if (lp2->head() == head && !lp2->tail()->is_backedge_copy()) {
2421         count += lp2->profiled_count();
2422         if (lp2->tail()->post_order() < latest_tail->post_order()) {
2423           latest_tail = lp2->tail();
2424         }
2425         loops_with_shared_head++;
2426         for (SuccIter iter(lp2->tail()); !iter.done(); iter.next()) {
2427           if (iter.succ() == head) {
2428             iter.set_succ(clone);
2429             // Update predecessor information
2430             head->predecessors()->remove(lp2->tail());
2431             clone->predecessors()->append(lp2->tail());
2432           }
2433         }
2434         flow_block(lp2->tail(), temp_vector, temp_set);
2435         if (lp2->head() == lp2->tail()) {
2436           // For self-loops, clone->head becomes clone->clone
2437           flow_block(clone, temp_vector, temp_set);
2438           for (SuccIter iter(clone); !iter.done(); iter.next()) {
2439             if (iter.succ() == lp2->head()) {
2440               iter.set_succ(clone);
2441               // Update predecessor information
2442               lp2->head()->predecessors()->remove(clone);
2443               clone->predecessors()->append(clone);
2444               break;
2445             }
2446           }
2447         }
2448         if (total_count == 0 || count > (total_count * .9)) {
2449           done = true;
2450         }
2451       }
2452     }
2453   }
2454   assert(loops_with_shared_head >= 1, "at least one new");
2455   clone->set_rpo_next(latest_tail->rpo_next());
2456   latest_tail->set_rpo_next(clone);
2457   flow_block(clone, temp_vector, temp_set);
2458 
2459   return clone;
2460 }
2461 
2462 // ------------------------------------------------------------------
2463 // ciTypeFlow::flow_block
2464 //
2465 // Interpret the effects of the bytecodes on the incoming state
2466 // vector of a basic block.  Push the changed state to succeeding
2467 // basic blocks.
2468 void ciTypeFlow::flow_block(ciTypeFlow::Block* block,
2469                             ciTypeFlow::StateVector* state,
2470                             ciTypeFlow::JsrSet* jsrs) {
2471   if (CITraceTypeFlow) {
2472     tty->print("\n>> ANALYZING BLOCK : ");
2473     tty->cr();
2474     block->print_on(tty);
2475   }
2476   assert(block->has_pre_order(), "pre-order is assigned before 1st flow");
2477 
2478   int start = block->start();
2479   int limit = block->limit();
2480   int control = block->control();
2481   if (control != ciBlock::fall_through_bci) {
2482     limit = control;
2483   }
2484 
2485   // Grab the state from the current block.
2486   block->copy_state_into(state);
2487   state->def_locals()->clear();
2488 
2489   GrowableArray<Block*>*           exceptions = block->exceptions();
2490   GrowableArray<ciInstanceKlass*>* exc_klasses = block->exc_klasses();
2491   bool has_exceptions = exceptions->length() > 0;
2492 
2493   bool exceptions_used = false;
2494 
2495   ciBytecodeStream str(method());
2496   str.reset_to_bci(start);
2497   Bytecodes::Code code;
2498   while ((code = str.next()) != ciBytecodeStream::EOBC() &&
2499          str.cur_bci() < limit) {
2500     // Check for exceptional control flow from this point.
2501     if (has_exceptions && can_trap(str)) {
2502       flow_exceptions(exceptions, exc_klasses, state);
2503       exceptions_used = true;
2504     }
2505     // Apply the effects of the current bytecode to our state.
2506     bool res = state->apply_one_bytecode(&str);
2507 
2508     // Watch for bailouts.
2509     if (failing())  return;
2510 
2511     if (str.cur_bc() == Bytecodes::_monitorenter) {
2512       block->set_has_monitorenter();
2513     }
2514 
2515     if (res) {
2516 
2517       // We have encountered a trap.  Record it in this block.
2518       block->set_trap(state->trap_bci(), state->trap_index());
2519 
2520       if (CITraceTypeFlow) {
2521         tty->print_cr(">> Found trap");
2522         block->print_on(tty);
2523       }
2524 
2525       // Save set of locals defined in this block
2526       block->def_locals()->add(state->def_locals());
2527 
2528       // Record (no) successors.
2529       block->successors(&str, state, jsrs);
2530 
2531       assert(!has_exceptions || exceptions_used, "Not removing exceptions");
2532 
2533       // Discontinue interpretation of this Block.
2534       return;
2535     }
2536   }
2537 
2538   GrowableArray<Block*>* successors = nullptr;
2539   if (control != ciBlock::fall_through_bci) {
2540     // Check for exceptional control flow from this point.
2541     if (has_exceptions && can_trap(str)) {
2542       flow_exceptions(exceptions, exc_klasses, state);
2543       exceptions_used = true;
2544     }
2545 
2546     // Fix the JsrSet to reflect effect of the bytecode.
2547     block->copy_jsrs_into(jsrs);
2548     jsrs->apply_control(this, &str, state);
2549 
2550     // Find successor edges based on old state and new JsrSet.
2551     successors = block->successors(&str, state, jsrs);
2552 
2553     // Apply the control changes to the state.
2554     state->apply_one_bytecode(&str);
2555   } else {
2556     // Fall through control
2557     successors = block->successors(&str, nullptr, nullptr);
2558   }
2559 
2560   // Save set of locals defined in this block
2561   block->def_locals()->add(state->def_locals());
2562 
2563   // Remove untaken exception paths
2564   if (!exceptions_used)
2565     exceptions->clear();
2566 
2567   // Pass our state to successors.
2568   flow_successors(successors, state);
2569 }
2570 
2571 // ------------------------------------------------------------------
2572 // ciTypeFlow::PreOrderLoops::next
2573 //
2574 // Advance to next loop tree using a preorder, left-to-right traversal.
2575 void ciTypeFlow::PreorderLoops::next() {
2576   assert(!done(), "must not be done.");
2577   if (_current->child() != nullptr) {
2578     _current = _current->child();
2579   } else if (_current->sibling() != nullptr) {
2580     _current = _current->sibling();
2581   } else {
2582     while (_current != _root && _current->sibling() == nullptr) {
2583       _current = _current->parent();
2584     }
2585     if (_current == _root) {
2586       _current = nullptr;
2587       assert(done(), "must be done.");
2588     } else {
2589       assert(_current->sibling() != nullptr, "must be more to do");
2590       _current = _current->sibling();
2591     }
2592   }
2593 }
2594 
2595 // If the tail is a branch to the head, retrieve how many times that path was taken from profiling
2596 int ciTypeFlow::Loop::profiled_count() {
2597   if (_profiled_count >= 0) {
2598     return _profiled_count;
2599   }
2600   ciMethodData* methodData = outer()->method()->method_data();
2601   if (!methodData->is_mature()) {
2602     _profiled_count = 0;
2603     return 0;
2604   }
2605   ciTypeFlow::Block* tail = this->tail();
2606   if (tail->control() == -1 || tail->has_trap()) {
2607     _profiled_count = 0;
2608     return 0;
2609   }
2610 
2611   ciProfileData* data = methodData->bci_to_data(tail->control());
2612 
2613   if (data == nullptr || !data->is_JumpData()) {
2614     _profiled_count = 0;
2615     return 0;
2616   }
2617 
2618   ciBytecodeStream iter(outer()->method());
2619   iter.reset_to_bci(tail->control());
2620 
2621   bool is_an_if = false;
2622   bool wide = false;
2623   Bytecodes::Code bc = iter.next();
2624   switch (bc) {
2625     case Bytecodes::_ifeq:
2626     case Bytecodes::_ifne:
2627     case Bytecodes::_iflt:
2628     case Bytecodes::_ifge:
2629     case Bytecodes::_ifgt:
2630     case Bytecodes::_ifle:
2631     case Bytecodes::_if_icmpeq:
2632     case Bytecodes::_if_icmpne:
2633     case Bytecodes::_if_icmplt:
2634     case Bytecodes::_if_icmpge:
2635     case Bytecodes::_if_icmpgt:
2636     case Bytecodes::_if_icmple:
2637     case Bytecodes::_if_acmpeq:
2638     case Bytecodes::_if_acmpne:
2639     case Bytecodes::_ifnull:
2640     case Bytecodes::_ifnonnull:
2641       is_an_if = true;
2642       break;
2643     case Bytecodes::_goto_w:
2644     case Bytecodes::_jsr_w:
2645       wide = true;
2646       break;
2647     case Bytecodes::_goto:
2648     case Bytecodes::_jsr:
2649       break;
2650     default:
2651       fatal(" invalid bytecode: %s", Bytecodes::name(iter.cur_bc()));
2652   }
2653 
2654   GrowableArray<ciTypeFlow::Block*>* succs = tail->successors();
2655 
2656   if (!is_an_if) {
2657     assert(((wide ? iter.get_far_dest() : iter.get_dest()) == head()->start()) == (succs->at(ciTypeFlow::GOTO_TARGET) == head()), "branch should lead to loop head");
2658     if (succs->at(ciTypeFlow::GOTO_TARGET) == head()) {
2659       _profiled_count = outer()->method()->scale_count(data->as_JumpData()->taken());
2660       return _profiled_count;
2661     }
2662   } else {
2663     assert((iter.get_dest() == head()->start()) == (succs->at(ciTypeFlow::IF_TAKEN) == head()), "bytecode and CFG not consistent");
2664     assert((tail->limit() == head()->start()) == (succs->at(ciTypeFlow::IF_NOT_TAKEN) == head()), "bytecode and CFG not consistent");
2665     if (succs->at(ciTypeFlow::IF_TAKEN) == head()) {
2666       _profiled_count = outer()->method()->scale_count(data->as_JumpData()->taken());
2667       return _profiled_count;
2668     } else if (succs->at(ciTypeFlow::IF_NOT_TAKEN) == head()) {
2669       _profiled_count = outer()->method()->scale_count(data->as_BranchData()->not_taken());
2670       return _profiled_count;
2671     }
2672   }
2673 
2674   _profiled_count = 0;
2675   return _profiled_count;
2676 }
2677 
2678 bool ciTypeFlow::Loop::at_insertion_point(Loop* lp, Loop* current) {
2679   int lp_pre_order = lp->head()->pre_order();
2680   if (current->head()->pre_order() < lp_pre_order) {
2681     return true;
2682   } else if (current->head()->pre_order() > lp_pre_order) {
2683     return false;
2684   }
2685   // In the case of a shared head, make the most frequent head/tail (as reported by profiling) the inner loop
2686   if (current->head() == lp->head()) {
2687     int lp_count = lp->profiled_count();
2688     int current_count = current->profiled_count();
2689     if (current_count < lp_count) {
2690       return true;
2691     } else if (current_count > lp_count) {
2692       return false;
2693     }
2694   }
2695   if (current->tail()->pre_order() > lp->tail()->pre_order()) {
2696     return true;
2697   }
2698   return false;
2699 }
2700 
2701 // ------------------------------------------------------------------
2702 // ciTypeFlow::Loop::sorted_merge
2703 //
2704 // Merge the branch lp into this branch, sorting on the loop head
2705 // pre_orders. Returns the leaf of the merged branch.
2706 // Child and sibling pointers will be setup later.
2707 // Sort is (looking from leaf towards the root)
2708 //  descending on primary key: loop head's pre_order, and
2709 //  ascending  on secondary key: loop tail's pre_order.
2710 ciTypeFlow::Loop* ciTypeFlow::Loop::sorted_merge(Loop* lp) {
2711   Loop* leaf = this;
2712   Loop* prev = nullptr;
2713   Loop* current = leaf;
2714   while (lp != nullptr) {
2715     int lp_pre_order = lp->head()->pre_order();
2716     // Find insertion point for "lp"
2717     while (current != nullptr) {
2718       if (current == lp) {
2719         return leaf; // Already in list
2720       }
2721       if (at_insertion_point(lp, current)) {
2722         break;
2723       }
2724       prev = current;
2725       current = current->parent();
2726     }
2727     Loop* next_lp = lp->parent(); // Save future list of items to insert
2728     // Insert lp before current
2729     lp->set_parent(current);
2730     if (prev != nullptr) {
2731       prev->set_parent(lp);
2732     } else {
2733       leaf = lp;
2734     }
2735     prev = lp;     // Inserted item is new prev[ious]
2736     lp = next_lp;  // Next item to insert
2737   }
2738   return leaf;
2739 }
2740 
2741 // ------------------------------------------------------------------
2742 // ciTypeFlow::build_loop_tree
2743 //
2744 // Incrementally build loop tree.
2745 void ciTypeFlow::build_loop_tree(Block* blk) {
2746   assert(!blk->is_post_visited(), "precondition");
2747   Loop* innermost = nullptr; // merge of loop tree branches over all successors
2748 
2749   for (SuccIter iter(blk); !iter.done(); iter.next()) {
2750     Loop*  lp   = nullptr;
2751     Block* succ = iter.succ();
2752     if (!succ->is_post_visited()) {
2753       // Found backedge since predecessor post visited, but successor is not
2754       assert(succ->pre_order() <= blk->pre_order(), "should be backedge");
2755 
2756       // Create a LoopNode to mark this loop.
2757       lp = new (arena()) Loop(succ, blk);
2758       if (succ->loop() == nullptr)
2759         succ->set_loop(lp);
2760       // succ->loop will be updated to innermost loop on a later call, when blk==succ
2761 
2762     } else {  // Nested loop
2763       lp = succ->loop();
2764 
2765       // If succ is loop head, find outer loop.
2766       while (lp != nullptr && lp->head() == succ) {
2767         lp = lp->parent();
2768       }
2769       if (lp == nullptr) {
2770         // Infinite loop, it's parent is the root
2771         lp = loop_tree_root();
2772       }
2773     }
2774 
2775     // Check for irreducible loop.
2776     // Successor has already been visited. If the successor's loop head
2777     // has already been post-visited, then this is another entry into the loop.
2778     while (lp->head()->is_post_visited() && lp != loop_tree_root()) {
2779       _has_irreducible_entry = true;
2780       lp->set_irreducible(succ);
2781       if (!succ->is_on_work_list()) {
2782         // Assume irreducible entries need more data flow
2783         add_to_work_list(succ);
2784       }
2785       Loop* plp = lp->parent();
2786       if (plp == nullptr) {
2787         // This only happens for some irreducible cases.  The parent
2788         // will be updated during a later pass.
2789         break;
2790       }
2791       lp = plp;
2792     }
2793 
2794     // Merge loop tree branch for all successors.
2795     innermost = innermost == nullptr ? lp : innermost->sorted_merge(lp);
2796 
2797   } // end loop
2798 
2799   if (innermost == nullptr) {
2800     assert(blk->successors()->length() == 0, "CFG exit");
2801     blk->set_loop(loop_tree_root());
2802   } else if (innermost->head() == blk) {
2803     // If loop header, complete the tree pointers
2804     if (blk->loop() != innermost) {
2805 #ifdef ASSERT
2806       assert(blk->loop()->head() == innermost->head(), "same head");
2807       Loop* dl;
2808       for (dl = innermost; dl != nullptr && dl != blk->loop(); dl = dl->parent());
2809       assert(dl == blk->loop(), "blk->loop() already in innermost list");
2810 #endif
2811       blk->set_loop(innermost);
2812     }
2813     innermost->def_locals()->add(blk->def_locals());
2814     Loop* l = innermost;
2815     Loop* p = l->parent();
2816     while (p && l->head() == blk) {
2817       l->set_sibling(p->child());  // Put self on parents 'next child'
2818       p->set_child(l);             // Make self the first child of parent
2819       p->def_locals()->add(l->def_locals());
2820       l = p;                       // Walk up the parent chain
2821       p = l->parent();
2822     }
2823   } else {
2824     blk->set_loop(innermost);
2825     innermost->def_locals()->add(blk->def_locals());
2826   }
2827 }
2828 
2829 // ------------------------------------------------------------------
2830 // ciTypeFlow::Loop::contains
2831 //
2832 // Returns true if lp is nested loop.
2833 bool ciTypeFlow::Loop::contains(ciTypeFlow::Loop* lp) const {
2834   assert(lp != nullptr, "");
2835   if (this == lp || head() == lp->head()) return true;
2836   int depth1 = depth();
2837   int depth2 = lp->depth();
2838   if (depth1 > depth2)
2839     return false;
2840   while (depth1 < depth2) {
2841     depth2--;
2842     lp = lp->parent();
2843   }
2844   return this == lp;
2845 }
2846 
2847 // ------------------------------------------------------------------
2848 // ciTypeFlow::Loop::depth
2849 //
2850 // Loop depth
2851 int ciTypeFlow::Loop::depth() const {
2852   int dp = 0;
2853   for (Loop* lp = this->parent(); lp != nullptr; lp = lp->parent())
2854     dp++;
2855   return dp;
2856 }
2857 
2858 #ifndef PRODUCT
2859 // ------------------------------------------------------------------
2860 // ciTypeFlow::Loop::print
2861 void ciTypeFlow::Loop::print(outputStream* st, int indent) const {
2862   for (int i = 0; i < indent; i++) st->print(" ");
2863   st->print("%d<-%d %s",
2864             is_root() ? 0 : this->head()->pre_order(),
2865             is_root() ? 0 : this->tail()->pre_order(),
2866             is_irreducible()?" irr":"");
2867   st->print(" defs: ");
2868   def_locals()->print_on(st, _head->outer()->method()->max_locals());
2869   st->cr();
2870   for (Loop* ch = child(); ch != nullptr; ch = ch->sibling())
2871     ch->print(st, indent+2);
2872 }
2873 #endif
2874 
2875 // ------------------------------------------------------------------
2876 // ciTypeFlow::df_flow_types
2877 //
2878 // Perform the depth first type flow analysis. Helper for flow_types.
2879 void ciTypeFlow::df_flow_types(Block* start,
2880                                bool do_flow,
2881                                StateVector* temp_vector,
2882                                JsrSet* temp_set) {
2883   int dft_len = 100;
2884   GrowableArray<Block*> stk(dft_len);
2885 
2886   ciBlock* dummy = _method->get_method_blocks()->make_dummy_block();
2887   JsrSet* root_set = new JsrSet(0);
2888   Block* root_head = new (arena()) Block(this, dummy, root_set);
2889   Block* root_tail = new (arena()) Block(this, dummy, root_set);
2890   root_head->set_pre_order(0);
2891   root_head->set_post_order(0);
2892   root_tail->set_pre_order(max_jint);
2893   root_tail->set_post_order(max_jint);
2894   set_loop_tree_root(new (arena()) Loop(root_head, root_tail));
2895 
2896   stk.push(start);
2897 
2898   _next_pre_order = 0;  // initialize pre_order counter
2899   _rpo_list = nullptr;
2900   int next_po = 0;      // initialize post_order counter
2901 
2902   // Compute RPO and the control flow graph
2903   int size;
2904   while ((size = stk.length()) > 0) {
2905     Block* blk = stk.top(); // Leave node on stack
2906     if (!blk->is_visited()) {
2907       // forward arc in graph
2908       assert (!blk->has_pre_order(), "");
2909       blk->set_next_pre_order();
2910 
2911       if (_next_pre_order >= (int)Compile::current()->max_node_limit() / 2) {
2912         // Too many basic blocks.  Bail out.
2913         // This can happen when try/finally constructs are nested to depth N,
2914         // and there is O(2**N) cloning of jsr bodies.  See bug 4697245!
2915         // "MaxNodeLimit / 2" is used because probably the parser will
2916         // generate at least twice that many nodes and bail out.
2917         record_failure("too many basic blocks");
2918         return;
2919       }
2920       if (do_flow) {
2921         flow_block(blk, temp_vector, temp_set);
2922         if (failing()) return; // Watch for bailouts.
2923       }
2924     } else if (!blk->is_post_visited()) {
2925       // cross or back arc
2926       for (SuccIter iter(blk); !iter.done(); iter.next()) {
2927         Block* succ = iter.succ();
2928         if (!succ->is_visited()) {
2929           stk.push(succ);
2930         }
2931       }
2932       if (stk.length() == size) {
2933         // There were no additional children, post visit node now
2934         stk.pop(); // Remove node from stack
2935 
2936         build_loop_tree(blk);
2937         blk->set_post_order(next_po++);   // Assign post order
2938         prepend_to_rpo_list(blk);
2939         assert(blk->is_post_visited(), "");
2940 
2941         if (blk->is_loop_head() && !blk->is_on_work_list()) {
2942           // Assume loop heads need more data flow
2943           add_to_work_list(blk);
2944         }
2945       }
2946     } else {
2947       stk.pop(); // Remove post-visited node from stack
2948     }
2949   }
2950 }
2951 
2952 // ------------------------------------------------------------------
2953 // ciTypeFlow::flow_types
2954 //
2955 // Perform the type flow analysis, creating and cloning Blocks as
2956 // necessary.
2957 void ciTypeFlow::flow_types() {
2958   ResourceMark rm;
2959   StateVector* temp_vector = new StateVector(this);
2960   JsrSet* temp_set = new JsrSet(4);
2961 
2962   // Create the method entry block.
2963   Block* start = block_at(start_bci(), temp_set);
2964 
2965   // Load the initial state into it.
2966   const StateVector* start_state = get_start_state();
2967   if (failing())  return;
2968   start->meet(start_state);
2969 
2970   // Depth first visit
2971   df_flow_types(start, true /*do flow*/, temp_vector, temp_set);
2972 
2973   if (failing())  return;
2974   assert(_rpo_list == start, "must be start");
2975 
2976   // Any loops found?
2977   if (loop_tree_root()->child() != nullptr &&
2978       env()->comp_level() >= CompLevel_full_optimization) {
2979       // Loop optimizations are not performed on Tier1 compiles.
2980 
2981     bool changed = clone_loop_heads(temp_vector, temp_set);
2982 
2983     // If some loop heads were cloned, recompute postorder and loop tree
2984     if (changed) {
2985       loop_tree_root()->set_child(nullptr);
2986       for (Block* blk = _rpo_list; blk != nullptr;) {
2987         Block* next = blk->rpo_next();
2988         blk->df_init();
2989         blk = next;
2990       }
2991       df_flow_types(start, false /*no flow*/, temp_vector, temp_set);
2992     }
2993   }
2994 
2995   if (CITraceTypeFlow) {
2996     tty->print_cr("\nLoop tree");
2997     loop_tree_root()->print();
2998   }
2999 
3000   // Continue flow analysis until fixed point reached
3001 
3002   DEBUG_ONLY(int max_block = _next_pre_order;)
3003 
3004   while (!work_list_empty()) {
3005     Block* blk = work_list_next();
3006     assert (blk->has_post_order(), "post order assigned above");
3007 
3008     flow_block(blk, temp_vector, temp_set);
3009 
3010     assert (max_block == _next_pre_order, "no new blocks");
3011     assert (!failing(), "no more bailouts");
3012   }
3013 }
3014 
3015 // ------------------------------------------------------------------
3016 // ciTypeFlow::map_blocks
3017 //
3018 // Create the block map, which indexes blocks in reverse post-order.
3019 void ciTypeFlow::map_blocks() {
3020   assert(_block_map == nullptr, "single initialization");
3021   int block_ct = _next_pre_order;
3022   _block_map = NEW_ARENA_ARRAY(arena(), Block*, block_ct);
3023   assert(block_ct == block_count(), "");
3024 
3025   Block* blk = _rpo_list;
3026   for (int m = 0; m < block_ct; m++) {
3027     int rpo = blk->rpo();
3028     assert(rpo == m, "should be sequential");
3029     _block_map[rpo] = blk;
3030     blk = blk->rpo_next();
3031   }
3032   assert(blk == nullptr, "should be done");
3033 
3034   for (int j = 0; j < block_ct; j++) {
3035     assert(_block_map[j] != nullptr, "must not drop any blocks");
3036     Block* block = _block_map[j];
3037     // Remove dead blocks from successor lists:
3038     for (int e = 0; e <= 1; e++) {
3039       GrowableArray<Block*>* l = e? block->exceptions(): block->successors();
3040       for (int k = 0; k < l->length(); k++) {
3041         Block* s = l->at(k);
3042         if (!s->has_post_order()) {
3043           if (CITraceTypeFlow) {
3044             tty->print("Removing dead %s successor of #%d: ", (e? "exceptional":  "normal"), block->pre_order());
3045             s->print_value_on(tty);
3046             tty->cr();
3047           }
3048           l->remove(s);
3049           --k;
3050         }
3051       }
3052     }
3053   }
3054 }
3055 
3056 // ------------------------------------------------------------------
3057 // ciTypeFlow::get_block_for
3058 //
3059 // Find a block with this ciBlock which has a compatible JsrSet.
3060 // If no such block exists, create it, unless the option is no_create.
3061 // If the option is create_backedge_copy, always create a fresh backedge copy.
3062 ciTypeFlow::Block* ciTypeFlow::get_block_for(int ciBlockIndex, ciTypeFlow::JsrSet* jsrs, CreateOption option) {
3063   Arena* a = arena();
3064   GrowableArray<Block*>* blocks = _idx_to_blocklist[ciBlockIndex];
3065   if (blocks == nullptr) {
3066     // Query only?
3067     if (option == no_create)  return nullptr;
3068 
3069     // Allocate the growable array.
3070     blocks = new (a) GrowableArray<Block*>(a, 4, 0, nullptr);
3071     _idx_to_blocklist[ciBlockIndex] = blocks;
3072   }
3073 
3074   if (option != create_backedge_copy) {
3075     int len = blocks->length();
3076     for (int i = 0; i < len; i++) {
3077       Block* block = blocks->at(i);
3078       if (!block->is_backedge_copy() && block->is_compatible_with(jsrs)) {
3079         return block;
3080       }
3081     }
3082   }
3083 
3084   // Query only?
3085   if (option == no_create)  return nullptr;
3086 
3087   // We did not find a compatible block.  Create one.
3088   Block* new_block = new (a) Block(this, _method->get_method_blocks()->block(ciBlockIndex), jsrs);
3089   if (option == create_backedge_copy)  new_block->set_backedge_copy(true);
3090   blocks->append(new_block);
3091   return new_block;
3092 }
3093 
3094 // ------------------------------------------------------------------
3095 // ciTypeFlow::backedge_copy_count
3096 //
3097 int ciTypeFlow::backedge_copy_count(int ciBlockIndex, ciTypeFlow::JsrSet* jsrs) const {
3098   GrowableArray<Block*>* blocks = _idx_to_blocklist[ciBlockIndex];
3099 
3100   if (blocks == nullptr) {
3101     return 0;
3102   }
3103 
3104   int count = 0;
3105   int len = blocks->length();
3106   for (int i = 0; i < len; i++) {
3107     Block* block = blocks->at(i);
3108     if (block->is_backedge_copy() && block->is_compatible_with(jsrs)) {
3109       count++;
3110     }
3111   }
3112 
3113   return count;
3114 }
3115 
3116 // ------------------------------------------------------------------
3117 // ciTypeFlow::do_flow
3118 //
3119 // Perform type inference flow analysis.
3120 void ciTypeFlow::do_flow() {
3121   if (CITraceTypeFlow) {
3122     tty->print_cr("\nPerforming flow analysis on method");
3123     method()->print();
3124     if (is_osr_flow())  tty->print(" at OSR bci %d", start_bci());
3125     tty->cr();
3126     method()->print_codes();
3127   }
3128   if (CITraceTypeFlow) {
3129     tty->print_cr("Initial CI Blocks");
3130     print_on(tty);
3131   }
3132   flow_types();
3133   // Watch for bailouts.
3134   if (failing()) {
3135     return;
3136   }
3137 
3138   map_blocks();
3139 
3140   if (CIPrintTypeFlow || CITraceTypeFlow) {
3141     rpo_print_on(tty);
3142   }
3143 }
3144 
3145 // ------------------------------------------------------------------
3146 // ciTypeFlow::is_dominated_by
3147 //
3148 // Determine if the instruction at bci is dominated by the instruction at dom_bci.
3149 bool ciTypeFlow::is_dominated_by(int bci, int dom_bci) {
3150   assert(!method()->has_jsrs(), "jsrs are not supported");
3151 
3152   ResourceMark rm;
3153   JsrSet* jsrs = new ciTypeFlow::JsrSet();
3154   int        index = _method->get_method_blocks()->block_containing(bci)->index();
3155   int    dom_index = _method->get_method_blocks()->block_containing(dom_bci)->index();
3156   Block*     block = get_block_for(index, jsrs, ciTypeFlow::no_create);
3157   Block* dom_block = get_block_for(dom_index, jsrs, ciTypeFlow::no_create);
3158 
3159   // Start block dominates all other blocks
3160   if (start_block()->rpo() == dom_block->rpo()) {
3161     return true;
3162   }
3163 
3164   // Dominated[i] is true if block i is dominated by dom_block
3165   int num_blocks = block_count();
3166   bool* dominated = NEW_RESOURCE_ARRAY(bool, num_blocks);
3167   for (int i = 0; i < num_blocks; ++i) {
3168     dominated[i] = true;
3169   }
3170   dominated[start_block()->rpo()] = false;
3171 
3172   // Iterative dominator algorithm
3173   bool changed = true;
3174   while (changed) {
3175     changed = false;
3176     // Use reverse postorder iteration
3177     for (Block* blk = _rpo_list; blk != nullptr; blk = blk->rpo_next()) {
3178       if (blk->is_start()) {
3179         // Ignore start block
3180         continue;
3181       }
3182       // The block is dominated if it is the dominating block
3183       // itself or if all predecessors are dominated.
3184       int index = blk->rpo();
3185       bool dom = (index == dom_block->rpo());
3186       if (!dom) {
3187         // Check if all predecessors are dominated
3188         dom = true;
3189         for (int i = 0; i < blk->predecessors()->length(); ++i) {
3190           Block* pred = blk->predecessors()->at(i);
3191           if (!dominated[pred->rpo()]) {
3192             dom = false;
3193             break;
3194           }
3195         }
3196       }
3197       // Update dominator information
3198       if (dominated[index] != dom) {
3199         changed = true;
3200         dominated[index] = dom;
3201       }
3202     }
3203   }
3204   // block dominated by dom_block?
3205   return dominated[block->rpo()];
3206 }
3207 
3208 // ------------------------------------------------------------------
3209 // ciTypeFlow::record_failure()
3210 // The ciTypeFlow object keeps track of failure reasons separately from the ciEnv.
3211 // This is required because there is not a 1-1 relation between the ciEnv and
3212 // the TypeFlow passes within a compilation task.  For example, if the compiler
3213 // is considering inlining a method, it will request a TypeFlow.  If that fails,
3214 // the compilation as a whole may continue without the inlining.  Some TypeFlow
3215 // requests are not optional; if they fail the requestor is responsible for
3216 // copying the failure reason up to the ciEnv.  (See Parse::Parse.)
3217 void ciTypeFlow::record_failure(const char* reason) {
3218   if (env()->log() != nullptr) {
3219     env()->log()->elem("failure reason='%s' phase='typeflow'", reason);
3220   }
3221   if (_failure_reason == nullptr) {
3222     // Record the first failure reason.
3223     _failure_reason = reason;
3224   }
3225 }
3226 
3227 ciType* ciTypeFlow::mark_as_early_larval(ciType* type) {
3228   // Wrap the type to carry the information that it is null-free
3229   return env()->make_early_larval_wrapper(type);
3230 }
3231 
3232 
3233 ciType* ciTypeFlow::mark_as_null_free(ciType* type) {
3234   // Wrap the type to carry the information that it is null-free
3235   return env()->make_null_free_wrapper(type);
3236 }
3237 
3238 #ifndef PRODUCT
3239 void ciTypeFlow::print() const       { print_on(tty); }
3240 
3241 // ------------------------------------------------------------------
3242 // ciTypeFlow::print_on
3243 void ciTypeFlow::print_on(outputStream* st) const {
3244   // Walk through CI blocks
3245   st->print_cr("********************************************************");
3246   st->print   ("TypeFlow for ");
3247   method()->name()->print_symbol_on(st);
3248   int limit_bci = code_size();
3249   st->print_cr("  %d bytes", limit_bci);
3250   ciMethodBlocks* mblks = _method->get_method_blocks();
3251   ciBlock* current = nullptr;
3252   for (int bci = 0; bci < limit_bci; bci++) {
3253     ciBlock* blk = mblks->block_containing(bci);
3254     if (blk != nullptr && blk != current) {
3255       current = blk;
3256       current->print_on(st);
3257 
3258       GrowableArray<Block*>* blocks = _idx_to_blocklist[blk->index()];
3259       int num_blocks = (blocks == nullptr) ? 0 : blocks->length();
3260 
3261       if (num_blocks == 0) {
3262         st->print_cr("  No Blocks");
3263       } else {
3264         for (int i = 0; i < num_blocks; i++) {
3265           Block* block = blocks->at(i);
3266           block->print_on(st);
3267         }
3268       }
3269       st->print_cr("--------------------------------------------------------");
3270       st->cr();
3271     }
3272   }
3273   st->print_cr("********************************************************");
3274   st->cr();
3275 }
3276 
3277 void ciTypeFlow::rpo_print_on(outputStream* st) const {
3278   st->print_cr("********************************************************");
3279   st->print   ("TypeFlow for ");
3280   method()->name()->print_symbol_on(st);
3281   int limit_bci = code_size();
3282   st->print_cr("  %d bytes", limit_bci);
3283   for (Block* blk = _rpo_list; blk != nullptr; blk = blk->rpo_next()) {
3284     blk->print_on(st);
3285     st->print_cr("--------------------------------------------------------");
3286     st->cr();
3287   }
3288   st->print_cr("********************************************************");
3289   st->cr();
3290 }
3291 #endif
--- EOF ---