1 /*
   2  * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "classfile/vmSymbols.hpp"
  26 #include "interpreter/bytecodeStream.hpp"
  27 #include "logging/log.hpp"
  28 #include "logging/logStream.hpp"
  29 #include "memory/allocation.inline.hpp"
  30 #include "memory/resourceArea.hpp"
  31 #include "oops/constantPool.hpp"
  32 #include "oops/generateOopMap.hpp"
  33 #include "oops/oop.inline.hpp"
  34 #include "oops/symbol.hpp"
  35 #include "runtime/handles.inline.hpp"
  36 #include "runtime/java.hpp"
  37 #include "runtime/os.hpp"
  38 #include "runtime/relocator.hpp"
  39 #include "runtime/timerTrace.hpp"
  40 #include "utilities/bitMap.inline.hpp"
  41 #include "utilities/ostream.hpp"
  42 
  43 //
  44 //
  45 // Compute stack layouts for each instruction in method.
  46 //
  47 //  Problems:
  48 //  - What to do about jsr with different types of local vars?
  49 //  Need maps that are conditional on jsr path?
  50 //  - Jsr and exceptions should be done more efficiently (the retAddr stuff)
  51 //
  52 //  Alternative:
  53 //  - Could extend verifier to provide this information.
  54 //    For: one fewer abstract interpreter to maintain. Against: the verifier
  55 //    solves a bigger problem so slower (undesirable to force verification of
  56 //    everything?).
  57 //
  58 //  Algorithm:
  59 //    Partition bytecodes into basic blocks
  60 //    For each basic block: store entry state (vars, stack). For instructions
  61 //    inside basic blocks we do not store any state (instead we recompute it
  62 //    from state produced by previous instruction).
  63 //
  64 //    Perform abstract interpretation of bytecodes over this lattice:
  65 //
  66 //                _--'#'--_
  67 //               /  /  \   \
  68 //             /   /     \   \
  69 //            /    |     |     \
  70 //          'r'   'v'   'p'   ' '
  71 //           \     |     |     /
  72 //            \    \     /    /
  73 //              \   \   /    /
  74 //                -- '@' --
  75 //
  76 //    '#'  top, result of conflict merge
  77 //    'r'  reference type
  78 //    'v'  value type
  79 //    'p'  pc type for jsr/ret
  80 //    ' '  uninitialized; never occurs on operand stack in Java
  81 //    '@'  bottom/unexecuted; initial state each bytecode.
  82 //
  83 //    Basic block headers are the only merge points. We use this iteration to
  84 //    compute the information:
  85 //
  86 //    find basic blocks;
  87 //    initialize them with uninitialized state;
  88 //    initialize first BB according to method signature;
  89 //    mark first BB changed
  90 //    while (some BB is changed) do {
  91 //      perform abstract interpration of all bytecodes in BB;
  92 //      merge exit state of BB into entry state of all successor BBs,
  93 //      noting if any of these change;
  94 //    }
  95 //
  96 //  One additional complication is necessary. The jsr instruction pushes
  97 //  a return PC on the stack (a 'p' type in the abstract interpretation).
  98 //  To be able to process "ret" bytecodes, we keep track of these return
  99 //  PC's in a 'retAddrs' structure in abstract interpreter context (when
 100 //  processing a "ret" bytecodes, it is not sufficient to know that it gets
 101 //  an argument of the right type 'p'; we need to know which address it
 102 //  returns to).
 103 //
 104 // (Note this comment is borrowed form the original author of the algorithm)
 105 
 106 // ComputeCallStack
 107 //
 108 // Specialization of SignatureIterator - compute the effects of a call
 109 //
 110 class ComputeCallStack : public SignatureIterator {
 111   CellTypeState *_effect;
 112   int _idx;
 113 
 114   void setup();
 115   void set(CellTypeState state)         { _effect[_idx++] = state; }
 116   int  length()                         { return _idx; };
 117 
 118   friend class SignatureIterator;  // so do_parameters_on can call do_type
 119   void do_type(BasicType type, bool for_return = false) {
 120     if (for_return && type == T_VOID) {
 121       set(CellTypeState::bottom);
 122     } else if (is_reference_type(type)) {
 123       set(CellTypeState::ref);
 124     } else {
 125       assert(is_java_primitive(type), "");
 126       set(CellTypeState::value);
 127       if (is_double_word_type(type)) {
 128         set(CellTypeState::value);
 129       }
 130     }
 131   }
 132 
 133  public:
 134   ComputeCallStack(Symbol* signature) : SignatureIterator(signature) {};
 135 
 136   // Compute methods
 137   int compute_for_parameters(bool is_static, CellTypeState *effect) {
 138     _idx    = 0;
 139     _effect = effect;
 140 
 141     if (!is_static) {
 142       effect[_idx++] = CellTypeState::ref;
 143     }
 144 
 145     do_parameters_on(this);
 146 
 147     return length();
 148   };
 149 
 150   int compute_for_returntype(CellTypeState *effect) {
 151     _idx    = 0;
 152     _effect = effect;
 153     do_type(return_type(), true);
 154     set(CellTypeState::bottom);  // Always terminate with a bottom state, so ppush works
 155 
 156     return length();
 157   }
 158 };
 159 
 160 //=========================================================================================
 161 // ComputeEntryStack
 162 //
 163 // Specialization of SignatureIterator - in order to set up first stack frame
 164 //
 165 class ComputeEntryStack : public SignatureIterator {
 166   CellTypeState *_effect;
 167   int _idx;
 168 
 169   void setup();
 170   void set(CellTypeState state)         { _effect[_idx++] = state; }
 171   int  length()                         { return _idx; };
 172 
 173   friend class SignatureIterator;  // so do_parameters_on can call do_type
 174   void do_type(BasicType type, bool for_return = false) {
 175     if (for_return && type == T_VOID) {
 176       set(CellTypeState::bottom);
 177     } else if (is_reference_type(type)) {
 178       set(CellTypeState::make_slot_ref(_idx));
 179     } else {
 180       assert(is_java_primitive(type), "");
 181       set(CellTypeState::value);
 182       if (is_double_word_type(type)) {
 183         set(CellTypeState::value);
 184       }
 185     }
 186   }
 187 
 188  public:
 189   ComputeEntryStack(Symbol* signature) : SignatureIterator(signature) {};
 190 
 191   // Compute methods
 192   int compute_for_parameters(bool is_static, CellTypeState *effect) {
 193     _idx    = 0;
 194     _effect = effect;
 195 
 196     if (!is_static)
 197       effect[_idx++] = CellTypeState::make_slot_ref(0);
 198 
 199     do_parameters_on(this);
 200 
 201     return length();
 202   };
 203 
 204   int compute_for_returntype(CellTypeState *effect) {
 205     _idx    = 0;
 206     _effect = effect;
 207     do_type(return_type(), true);
 208     set(CellTypeState::bottom);  // Always terminate with a bottom state, so ppush works
 209 
 210     return length();
 211   }
 212 };
 213 
 214 //=====================================================================================
 215 //
 216 // Implementation of RetTable/RetTableEntry
 217 //
 218 // Contains function to itereate through all bytecodes
 219 // and find all return entry points
 220 //
 221 int RetTable::_init_nof_entries = 10;
 222 int RetTableEntry::_init_nof_jsrs = 5;
 223 
 224 RetTableEntry::RetTableEntry(int target, RetTableEntry *next) {
 225   _target_bci = target;
 226   _jsrs = new GrowableArray<int>(_init_nof_jsrs);
 227   _next = next;
 228 }
 229 
 230 void RetTableEntry::add_delta(int bci, int delta) {
 231   if (_target_bci > bci) _target_bci += delta;
 232 
 233   for (int k = 0; k < _jsrs->length(); k++) {
 234     int jsr = _jsrs->at(k);
 235     if (jsr > bci) _jsrs->at_put(k, jsr+delta);
 236   }
 237 }
 238 
 239 void RetTable::compute_ret_table(const methodHandle& method) {
 240   BytecodeStream i(method);
 241   Bytecodes::Code bytecode;
 242 
 243   while( (bytecode = i.next()) >= 0) {
 244     switch (bytecode) {
 245       case Bytecodes::_jsr:
 246         add_jsr(i.next_bci(), i.dest());
 247         break;
 248       case Bytecodes::_jsr_w:
 249         add_jsr(i.next_bci(), i.dest_w());
 250         break;
 251       default:
 252         break;
 253     }
 254   }
 255 }
 256 
 257 void RetTable::add_jsr(int return_bci, int target_bci) {
 258   RetTableEntry* entry = _first;
 259 
 260   // Scan table for entry
 261   for (;entry && entry->target_bci() != target_bci; entry = entry->next());
 262 
 263   if (!entry) {
 264     // Allocate new entry and put in list
 265     entry = new RetTableEntry(target_bci, _first);
 266     _first = entry;
 267   }
 268 
 269   // Now "entry" is set.  Make sure that the entry is initialized
 270   // and has room for the new jsr.
 271   entry->add_jsr(return_bci);
 272 }
 273 
 274 RetTableEntry* RetTable::find_jsrs_for_target(int targBci) {
 275   RetTableEntry *cur = _first;
 276 
 277   while(cur) {
 278     assert(cur->target_bci() != -1, "sanity check");
 279     if (cur->target_bci() == targBci)  return cur;
 280     cur = cur->next();
 281   }
 282   ShouldNotReachHere();
 283   return nullptr;
 284 }
 285 
 286 // The instruction at bci is changing size by "delta".  Update the return map.
 287 void RetTable::update_ret_table(int bci, int delta) {
 288   RetTableEntry *cur = _first;
 289   while(cur) {
 290     cur->add_delta(bci, delta);
 291     cur = cur->next();
 292   }
 293 }
 294 
 295 //
 296 // Celltype state
 297 //
 298 
 299 CellTypeState CellTypeState::bottom      = CellTypeState::make_bottom();
 300 CellTypeState CellTypeState::uninit      = CellTypeState::make_any(uninit_value);
 301 CellTypeState CellTypeState::ref         = CellTypeState::make_any(ref_conflict);
 302 CellTypeState CellTypeState::value       = CellTypeState::make_any(val_value);
 303 CellTypeState CellTypeState::refUninit   = CellTypeState::make_any(ref_conflict | uninit_value);
 304 CellTypeState CellTypeState::top         = CellTypeState::make_top();
 305 CellTypeState CellTypeState::addr        = CellTypeState::make_any(addr_conflict);
 306 
 307 // Commonly used constants
 308 static CellTypeState epsilonCTS[1] = { CellTypeState::bottom };
 309 static CellTypeState   refCTS   = CellTypeState::ref;
 310 static CellTypeState   valCTS   = CellTypeState::value;
 311 static CellTypeState    vCTS[2] = { CellTypeState::value, CellTypeState::bottom };
 312 static CellTypeState    rCTS[2] = { CellTypeState::ref,   CellTypeState::bottom };
 313 static CellTypeState   rrCTS[3] = { CellTypeState::ref,   CellTypeState::ref,   CellTypeState::bottom };
 314 static CellTypeState   vrCTS[3] = { CellTypeState::value, CellTypeState::ref,   CellTypeState::bottom };
 315 static CellTypeState   vvCTS[3] = { CellTypeState::value, CellTypeState::value, CellTypeState::bottom };
 316 static CellTypeState  rvrCTS[4] = { CellTypeState::ref,   CellTypeState::value, CellTypeState::ref,   CellTypeState::bottom };
 317 static CellTypeState  vvrCTS[4] = { CellTypeState::value, CellTypeState::value, CellTypeState::ref,   CellTypeState::bottom };
 318 static CellTypeState  vvvCTS[4] = { CellTypeState::value, CellTypeState::value, CellTypeState::value, CellTypeState::bottom };
 319 static CellTypeState vvvrCTS[5] = { CellTypeState::value, CellTypeState::value, CellTypeState::value, CellTypeState::ref,   CellTypeState::bottom };
 320 static CellTypeState vvvvCTS[5] = { CellTypeState::value, CellTypeState::value, CellTypeState::value, CellTypeState::value, CellTypeState::bottom };
 321 
 322 char CellTypeState::to_char() const {
 323   if (can_be_reference()) {
 324     if (can_be_value() || can_be_address())
 325       return '#';    // Conflict that needs to be rewritten
 326     else
 327       return 'r';
 328   } else if (can_be_value())
 329     return 'v';
 330   else if (can_be_address())
 331     return 'p';
 332   else if (can_be_uninit())
 333     return ' ';
 334   else
 335     return '@';
 336 }
 337 
 338 
 339 // Print a detailed CellTypeState.  Indicate all bits that are set.  If
 340 // the CellTypeState represents an address or a reference, print the
 341 // value of the additional information.
 342 void CellTypeState::print(outputStream *os) {
 343   if (can_be_address()) {
 344     os->print("(p");
 345   } else {
 346     os->print("( ");
 347   }
 348   if (can_be_reference()) {
 349     os->print("r");
 350   } else {
 351     os->print(" ");
 352   }
 353   if (can_be_value()) {
 354     os->print("v");
 355   } else {
 356     os->print(" ");
 357   }
 358   if (can_be_uninit()) {
 359     os->print("u|");
 360   } else {
 361     os->print(" |");
 362   }
 363   if (is_info_top()) {
 364     os->print("Top)");
 365   } else if (is_info_bottom()) {
 366     os->print("Bot)");
 367   } else {
 368     if (is_reference()) {
 369       int info = get_info();
 370       int data = info & ~(ref_not_lock_bit | ref_slot_bit);
 371       if (info & ref_not_lock_bit) {
 372         // Not a monitor lock reference.
 373         if (info & ref_slot_bit) {
 374           // slot
 375           os->print("slot%d)", data);
 376         } else {
 377           // line
 378           os->print("line%d)", data);
 379         }
 380       } else {
 381         // lock
 382         os->print("lock%d)", data);
 383       }
 384     } else {
 385       os->print("%d)", get_info());
 386     }
 387   }
 388 }
 389 
 390 //
 391 // Basicblock handling methods
 392 //
 393 
 394 void GenerateOopMap::initialize_bb() {
 395   _gc_points = 0;
 396   _bb_count  = 0;
 397   _bb_hdr_bits.reinitialize(method()->code_size());
 398 }
 399 
 400 void GenerateOopMap::bb_mark_fct(GenerateOopMap *c, int bci, int *data) {
 401   assert(bci>= 0 && bci < c->method()->code_size(), "index out of bounds");
 402   if (c->is_bb_header(bci))
 403      return;
 404 
 405   if (TraceNewOopMapGeneration) {
 406      tty->print_cr("Basicblock#%d begins at: %d", c->_bb_count, bci);
 407   }
 408   c->set_bbmark_bit(bci);
 409   c->_bb_count++;
 410 }
 411 
 412 
 413 void GenerateOopMap::mark_bbheaders_and_count_gc_points() {
 414   initialize_bb();
 415 
 416   bool fellThrough = false;  // False to get first BB marked.
 417 
 418   // First mark all exception handlers as start of a basic-block
 419   ExceptionTable excps(method());
 420   for(int i = 0; i < excps.length(); i ++) {
 421     bb_mark_fct(this, excps.handler_pc(i), nullptr);
 422   }
 423 
 424   // Then iterate through the code
 425   BytecodeStream bcs(_method);
 426   Bytecodes::Code bytecode;
 427 
 428   while( (bytecode = bcs.next()) >= 0) {
 429     int bci = bcs.bci();
 430 
 431     if (!fellThrough)
 432         bb_mark_fct(this, bci, nullptr);
 433 
 434     fellThrough = jump_targets_do(&bcs, &GenerateOopMap::bb_mark_fct, nullptr);
 435 
 436      /* We will also mark successors of jsr's as basic block headers. */
 437     switch (bytecode) {
 438       case Bytecodes::_jsr:
 439       case Bytecodes::_jsr_w:
 440         assert(!fellThrough, "should not happen");
 441         // If this is the last bytecode, there is no successor to mark
 442         if (bci + Bytecodes::length_for(bytecode) < method()->code_size()) {
 443           bb_mark_fct(this, bci + Bytecodes::length_for(bytecode), nullptr);
 444         }
 445         break;
 446       default:
 447         break;
 448     }
 449 
 450     if (possible_gc_point(&bcs))
 451       _gc_points++;
 452   }
 453 }
 454 
 455 void GenerateOopMap::set_bbmark_bit(int bci) {
 456   _bb_hdr_bits.at_put(bci, true);
 457 }
 458 
 459 void GenerateOopMap::reachable_basicblock(GenerateOopMap *c, int bci, int *data) {
 460   assert(bci>= 0 && bci < c->method()->code_size(), "index out of bounds");
 461   BasicBlock* bb = c->get_basic_block_at(bci);
 462   if (bb->is_dead()) {
 463     bb->mark_as_alive();
 464     *data = 1; // Mark basicblock as changed
 465   }
 466 }
 467 
 468 
 469 void GenerateOopMap::mark_reachable_code() {
 470   int change = 1; // int to get function pointers to work
 471 
 472   // Mark entry basic block as alive and all exception handlers
 473   _basic_blocks[0].mark_as_alive();
 474   ExceptionTable excps(method());
 475   for(int i = 0; i < excps.length(); i++) {
 476     BasicBlock *bb = get_basic_block_at(excps.handler_pc(i));
 477     // If block is not already alive (due to multiple exception handlers to same bb), then
 478     // make it alive
 479     if (bb->is_dead()) bb->mark_as_alive();
 480   }
 481 
 482   BytecodeStream bcs(_method);
 483 
 484   // Iterate through all basic blocks until we reach a fixpoint
 485   while (change) {
 486     change = 0;
 487 
 488     for (int i = 0; i < _bb_count; i++) {
 489       BasicBlock *bb = &_basic_blocks[i];
 490       if (bb->is_alive()) {
 491         // Position bytecodestream at last bytecode in basicblock
 492         bcs.set_start(bb->_end_bci);
 493         bcs.next();
 494         Bytecodes::Code bytecode = bcs.code();
 495         int bci = bcs.bci();
 496         assert(bci == bb->_end_bci, "wrong bci");
 497 
 498         bool fell_through = jump_targets_do(&bcs, &GenerateOopMap::reachable_basicblock, &change);
 499 
 500         // We will also mark successors of jsr's as alive.
 501         switch (bytecode) {
 502           case Bytecodes::_jsr:
 503           case Bytecodes::_jsr_w:
 504             assert(!fell_through, "should not happen");
 505             // If this is the last bytecode, there is no successor to mark
 506             if (bci + Bytecodes::length_for(bytecode) < method()->code_size()) {
 507               reachable_basicblock(this, bci + Bytecodes::length_for(bytecode), &change);
 508             }
 509             break;
 510           default:
 511             break;
 512         }
 513         if (fell_through) {
 514           // Mark successor as alive
 515           if (bb[1].is_dead()) {
 516             bb[1].mark_as_alive();
 517             change = 1;
 518           }
 519         }
 520       }
 521     }
 522   }
 523 }
 524 
 525 /* If the current instruction in "c" has no effect on control flow,
 526    returns "true".  Otherwise, calls "jmpFct" one or more times, with
 527    "c", an appropriate "pcDelta", and "data" as arguments, then
 528    returns "false".  There is one exception: if the current
 529    instruction is a "ret", returns "false" without calling "jmpFct".
 530    Arrangements for tracking the control flow of a "ret" must be made
 531    externally. */
 532 bool GenerateOopMap::jump_targets_do(BytecodeStream *bcs, jmpFct_t jmpFct, int *data) {
 533   int bci = bcs->bci();
 534 
 535   switch (bcs->code()) {
 536     case Bytecodes::_ifeq:
 537     case Bytecodes::_ifne:
 538     case Bytecodes::_iflt:
 539     case Bytecodes::_ifge:
 540     case Bytecodes::_ifgt:
 541     case Bytecodes::_ifle:
 542     case Bytecodes::_if_icmpeq:
 543     case Bytecodes::_if_icmpne:
 544     case Bytecodes::_if_icmplt:
 545     case Bytecodes::_if_icmpge:
 546     case Bytecodes::_if_icmpgt:
 547     case Bytecodes::_if_icmple:
 548     case Bytecodes::_if_acmpeq:
 549     case Bytecodes::_if_acmpne:
 550     case Bytecodes::_ifnull:
 551     case Bytecodes::_ifnonnull:
 552       (*jmpFct)(this, bcs->dest(), data);
 553       // Class files verified by the old verifier can have a conditional branch
 554       // as their last bytecode, provided the conditional branch is unreachable
 555       // during execution.  Check if this instruction is the method's last bytecode
 556       // and, if so, don't call the jmpFct.
 557       if (bci + 3 < method()->code_size()) {
 558         (*jmpFct)(this, bci + 3, data);
 559       }
 560       break;
 561 
 562     case Bytecodes::_goto:
 563       (*jmpFct)(this, bcs->dest(), data);
 564       break;
 565     case Bytecodes::_goto_w:
 566       (*jmpFct)(this, bcs->dest_w(), data);
 567       break;
 568     case Bytecodes::_tableswitch:
 569       { Bytecode_tableswitch tableswitch(method(), bcs->bcp());
 570         int len = tableswitch.length();
 571 
 572         (*jmpFct)(this, bci + tableswitch.default_offset(), data); /* Default. jump address */
 573         while (--len >= 0) {
 574           (*jmpFct)(this, bci + tableswitch.dest_offset_at(len), data);
 575         }
 576         break;
 577       }
 578 
 579     case Bytecodes::_lookupswitch:
 580       { Bytecode_lookupswitch lookupswitch(method(), bcs->bcp());
 581         int npairs = lookupswitch.number_of_pairs();
 582         (*jmpFct)(this, bci + lookupswitch.default_offset(), data); /* Default. */
 583         while(--npairs >= 0) {
 584           LookupswitchPair pair = lookupswitch.pair_at(npairs);
 585           (*jmpFct)(this, bci + pair.offset(), data);
 586         }
 587         break;
 588       }
 589     case Bytecodes::_jsr:
 590       assert(bcs->is_wide()==false, "sanity check");
 591       (*jmpFct)(this, bcs->dest(), data);
 592       break;
 593     case Bytecodes::_jsr_w:
 594       (*jmpFct)(this, bcs->dest_w(), data);
 595       break;
 596     case Bytecodes::_wide:
 597       ShouldNotReachHere();
 598       return true;
 599       break;
 600     case Bytecodes::_athrow:
 601     case Bytecodes::_ireturn:
 602     case Bytecodes::_lreturn:
 603     case Bytecodes::_freturn:
 604     case Bytecodes::_dreturn:
 605     case Bytecodes::_areturn:
 606     case Bytecodes::_return:
 607     case Bytecodes::_ret:
 608       break;
 609     default:
 610       return true;
 611   }
 612   return false;
 613 }
 614 
 615 /* Requires "pc" to be the head of a basic block; returns that basic
 616    block. */
 617 BasicBlock *GenerateOopMap::get_basic_block_at(int bci) const {
 618   BasicBlock* bb = get_basic_block_containing(bci);
 619   assert(bb->_bci == bci, "should have found BB");
 620   return bb;
 621 }
 622 
 623 // Requires "pc" to be the start of an instruction; returns the basic
 624 //   block containing that instruction. */
 625 BasicBlock  *GenerateOopMap::get_basic_block_containing(int bci) const {
 626   BasicBlock *bbs = _basic_blocks;
 627   int lo = 0, hi = _bb_count - 1;
 628 
 629   while (lo <= hi) {
 630     int m = (lo + hi) / 2;
 631     int mbci = bbs[m]._bci;
 632     int nbci;
 633 
 634     if ( m == _bb_count-1) {
 635       assert( bci >= mbci && bci < method()->code_size(), "sanity check failed");
 636       return bbs+m;
 637     } else {
 638       nbci = bbs[m+1]._bci;
 639     }
 640 
 641     if ( mbci <= bci && bci < nbci) {
 642       return bbs+m;
 643     } else if (mbci < bci) {
 644       lo = m + 1;
 645     } else {
 646       assert(mbci > bci, "sanity check");
 647       hi = m - 1;
 648     }
 649   }
 650 
 651   fatal("should have found BB");
 652   return nullptr;
 653 }
 654 
 655 void GenerateOopMap::restore_state(BasicBlock *bb)
 656 {
 657   memcpy(_state, bb->_state, _state_len*sizeof(CellTypeState));
 658   _stack_top = bb->_stack_top;
 659   _monitor_top = bb->_monitor_top;
 660 }
 661 
 662 int GenerateOopMap::next_bb_start_pc(BasicBlock *bb) {
 663  intptr_t bbNum = bb - _basic_blocks + 1;
 664  if (bbNum == _bb_count)
 665     return method()->code_size();
 666 
 667  return _basic_blocks[bbNum]._bci;
 668 }
 669 
 670 //
 671 // CellType handling methods
 672 //
 673 
 674 // Allocate memory and throw LinkageError if failure.
 675 #define ALLOC_RESOURCE_ARRAY(var, type, count)                           \
 676   var = NEW_RESOURCE_ARRAY_RETURN_NULL(type, count);                     \
 677   if (var == nullptr) {                                                  \
 678     report_error("Cannot reserve enough memory to analyze this method"); \
 679     return;                                                              \
 680   }
 681 
 682 
 683 void GenerateOopMap::init_state() {
 684   _state_len     = _max_locals + _max_stack + _max_monitors;
 685   ALLOC_RESOURCE_ARRAY(_state, CellTypeState, _state_len);
 686   memset(_state, 0, _state_len * sizeof(CellTypeState));
 687   int count = MAX3(_max_locals, _max_stack, _max_monitors) + 1/*for null terminator char */;
 688   ALLOC_RESOURCE_ARRAY(_state_vec_buf, char, count);
 689 }
 690 
 691 void GenerateOopMap::make_context_uninitialized() {
 692   CellTypeState* vs = vars();
 693 
 694   for (int i = 0; i < _max_locals; i++)
 695       vs[i] = CellTypeState::uninit;
 696 
 697   _stack_top = 0;
 698   _monitor_top = 0;
 699 }
 700 
 701 int GenerateOopMap::methodsig_to_effect(Symbol* signature, bool is_static, CellTypeState* effect) {
 702   ComputeEntryStack ces(signature);
 703   return ces.compute_for_parameters(is_static, effect);
 704 }
 705 
 706 // Return result of merging cts1 and cts2.
 707 CellTypeState CellTypeState::merge(CellTypeState cts, int slot) const {
 708   CellTypeState result;
 709 
 710   assert(!is_bottom() && !cts.is_bottom(),
 711          "merge of bottom values is handled elsewhere");
 712 
 713   result._state = _state | cts._state;
 714 
 715   // If the top bit is set, we don't need to do any more work.
 716   if (!result.is_info_top()) {
 717     assert((result.can_be_address() || result.can_be_reference()),
 718            "only addresses and references have non-top info");
 719 
 720     if (!equal(cts)) {
 721       // The two values being merged are different.  Raise to top.
 722       if (result.is_reference()) {
 723         result = CellTypeState::make_slot_ref(slot);
 724       } else {
 725         result._state |= info_conflict;
 726       }
 727     }
 728   }
 729   assert(result.is_valid_state(), "checking that CTS merge maintains legal state");
 730 
 731   return result;
 732 }
 733 
 734 // Merge the variable state for locals and stack from cts into bbts.
 735 bool GenerateOopMap::merge_local_state_vectors(CellTypeState* cts,
 736                                                CellTypeState* bbts) {
 737   int i;
 738   int len = _max_locals + _stack_top;
 739   bool change = false;
 740 
 741   for (i = len - 1; i >= 0; i--) {
 742     CellTypeState v = cts[i].merge(bbts[i], i);
 743     change = change || !v.equal(bbts[i]);
 744     bbts[i] = v;
 745   }
 746 
 747   return change;
 748 }
 749 
 750 // Merge the monitor stack state from cts into bbts.
 751 bool GenerateOopMap::merge_monitor_state_vectors(CellTypeState* cts,
 752                                                  CellTypeState* bbts) {
 753   bool change = false;
 754   if (_max_monitors > 0 && _monitor_top != bad_monitors) {
 755     // If there are no monitors in the program, or there has been
 756     // a monitor matching error before this point in the program,
 757     // then we do not merge in the monitor state.
 758 
 759     int base = _max_locals + _max_stack;
 760     int len = base + _monitor_top;
 761     for (int i = len - 1; i >= base; i--) {
 762       CellTypeState v = cts[i].merge(bbts[i], i);
 763 
 764       // Can we prove that, when there has been a change, it will already
 765       // have been detected at this point?  That would make this equal
 766       // check here unnecessary.
 767       change = change || !v.equal(bbts[i]);
 768       bbts[i] = v;
 769     }
 770   }
 771 
 772   return change;
 773 }
 774 
 775 void GenerateOopMap::copy_state(CellTypeState *dst, CellTypeState *src) {
 776   int len = _max_locals + _stack_top;
 777   for (int i = 0; i < len; i++) {
 778     if (src[i].is_nonlock_reference()) {
 779       dst[i] = CellTypeState::make_slot_ref(i);
 780     } else {
 781       dst[i] = src[i];
 782     }
 783   }
 784   if (_max_monitors > 0 && _monitor_top != bad_monitors) {
 785     int base = _max_locals + _max_stack;
 786     len = base + _monitor_top;
 787     for (int i = base; i < len; i++) {
 788       dst[i] = src[i];
 789     }
 790   }
 791 }
 792 
 793 
 794 // Merge the states for the current block and the next.  As long as a
 795 // block is reachable the locals and stack must be merged.  If the
 796 // stack heights don't match then this is a verification error and
 797 // it's impossible to interpret the code.  Simultaneously monitor
 798 // states are being check to see if they nest statically.  If monitor
 799 // depths match up then their states are merged.  Otherwise the
 800 // mismatch is simply recorded and interpretation continues since
 801 // monitor matching is purely informational and doesn't say anything
 802 // about the correctness of the code.
 803 void GenerateOopMap::merge_state_into_bb(BasicBlock *bb) {
 804   guarantee(bb != nullptr, "null basicblock");
 805   assert(bb->is_alive(), "merging state into a dead basicblock");
 806 
 807   if (_stack_top == bb->_stack_top) {
 808     // always merge local state even if monitors don't match.
 809     if (merge_local_state_vectors(_state, bb->_state)) {
 810       bb->set_changed(true);
 811     }
 812     if (_monitor_top == bb->_monitor_top) {
 813       // monitors still match so continue merging monitor states.
 814       if (merge_monitor_state_vectors(_state, bb->_state)) {
 815         bb->set_changed(true);
 816       }
 817     } else {
 818       if (log_is_enabled(Info, monitormismatch)) {
 819         report_monitor_mismatch("monitor stack height merge conflict");
 820       }
 821       // When the monitor stacks are not matched, we set _monitor_top to
 822       // bad_monitors.  This signals that, from here on, the monitor stack cannot
 823       // be trusted.  In particular, monitorexit bytecodes may throw
 824       // exceptions.  We mark this block as changed so that the change
 825       // propagates properly.
 826       bb->_monitor_top = bad_monitors;
 827       bb->set_changed(true);
 828       _monitor_safe = false;
 829     }
 830   } else if (!bb->is_reachable()) {
 831     // First time we look at this  BB
 832     copy_state(bb->_state, _state);
 833     bb->_stack_top = _stack_top;
 834     bb->_monitor_top = _monitor_top;
 835     bb->set_changed(true);
 836   } else {
 837     verify_error("stack height conflict: %d vs. %d",  _stack_top, bb->_stack_top);
 838   }
 839 }
 840 
 841 void GenerateOopMap::merge_state(GenerateOopMap *gom, int bci, int* data) {
 842    gom->merge_state_into_bb(gom->get_basic_block_at(bci));
 843 }
 844 
 845 void GenerateOopMap::set_var(int localNo, CellTypeState cts) {
 846   assert(cts.is_reference() || cts.is_value() || cts.is_address(),
 847          "wrong celltypestate");
 848   if (localNo < 0 || localNo > _max_locals) {
 849     verify_error("variable write error: r%d", localNo);
 850     return;
 851   }
 852   vars()[localNo] = cts;
 853 }
 854 
 855 CellTypeState GenerateOopMap::get_var(int localNo) {
 856   assert(localNo < _max_locals + _nof_refval_conflicts, "variable read error");
 857   if (localNo < 0 || localNo > _max_locals) {
 858     verify_error("variable read error: r%d", localNo);
 859     return valCTS; // just to pick something;
 860   }
 861   return vars()[localNo];
 862 }
 863 
 864 CellTypeState GenerateOopMap::pop() {
 865   if ( _stack_top <= 0) {
 866     verify_error("stack underflow");
 867     return valCTS; // just to pick something
 868   }
 869   return  stack()[--_stack_top];
 870 }
 871 
 872 void GenerateOopMap::push(CellTypeState cts) {
 873   if ( _stack_top >= _max_stack) {
 874     verify_error("stack overflow");
 875     return;
 876   }
 877   stack()[_stack_top++] = cts;
 878 }
 879 
 880 CellTypeState GenerateOopMap::monitor_pop() {
 881   assert(_monitor_top != bad_monitors, "monitor_pop called on error monitor stack");
 882   if (_monitor_top == 0) {
 883     // We have detected a pop of an empty monitor stack.
 884     _monitor_safe = false;
 885      _monitor_top = bad_monitors;
 886 
 887     if (log_is_enabled(Info, monitormismatch)) {
 888       report_monitor_mismatch("monitor stack underflow");
 889     }
 890     return CellTypeState::ref; // just to keep the analysis going.
 891   }
 892   return  monitors()[--_monitor_top];
 893 }
 894 
 895 void GenerateOopMap::monitor_push(CellTypeState cts) {
 896   assert(_monitor_top != bad_monitors, "monitor_push called on error monitor stack");
 897   if (_monitor_top >= _max_monitors) {
 898     // Some monitorenter is being executed more than once.
 899     // This means that the monitor stack cannot be simulated.
 900     _monitor_safe = false;
 901     _monitor_top = bad_monitors;
 902 
 903     if (log_is_enabled(Info, monitormismatch)) {
 904       report_monitor_mismatch("monitor stack overflow");
 905     }
 906     return;
 907   }
 908   monitors()[_monitor_top++] = cts;
 909 }
 910 
 911 //
 912 // Interpretation handling methods
 913 //
 914 
 915 void GenerateOopMap::do_interpretation()
 916 {
 917   // "i" is just for debugging, so we can detect cases where this loop is
 918   // iterated more than once.
 919   int i = 0;
 920   do {
 921 #ifndef PRODUCT
 922     if (TraceNewOopMapGeneration) {
 923       tty->print("\n\nIteration #%d of do_interpretation loop, method:\n", i);
 924       method()->print_name(tty);
 925       tty->print("\n\n");
 926     }
 927 #endif
 928     _conflict = false;
 929     _monitor_safe = true;
 930     // init_state is now called from init_basic_blocks.  The length of a
 931     // state vector cannot be determined until we have made a pass through
 932     // the bytecodes counting the possible monitor entries.
 933     if (!_got_error) init_basic_blocks();
 934     if (!_got_error) setup_method_entry_state();
 935     if (!_got_error) interp_all();
 936     if (!_got_error) rewrite_refval_conflicts();
 937     i++;
 938   } while (_conflict && !_got_error);
 939 }
 940 
 941 void GenerateOopMap::init_basic_blocks() {
 942   // Note: Could consider reserving only the needed space for each BB's state
 943   // (entry stack may not be of maximal height for every basic block).
 944   // But cumbersome since we don't know the stack heights yet.  (Nor the
 945   // monitor stack heights...)
 946 
 947   ALLOC_RESOURCE_ARRAY(_basic_blocks, BasicBlock, _bb_count);
 948 
 949   // Make a pass through the bytecodes.  Count the number of monitorenters.
 950   // This can be used an upper bound on the monitor stack depth in programs
 951   // which obey stack discipline with their monitor usage.  Initialize the
 952   // known information about basic blocks.
 953   BytecodeStream j(_method);
 954   Bytecodes::Code bytecode;
 955 
 956   int bbNo = 0;
 957   int monitor_count = 0;
 958   int prev_bci = -1;
 959   while( (bytecode = j.next()) >= 0) {
 960     if (j.code() == Bytecodes::_monitorenter) {
 961       monitor_count++;
 962     }
 963 
 964     int bci = j.bci();
 965     if (is_bb_header(bci)) {
 966       // Initialize the basicblock structure
 967       BasicBlock *bb   = _basic_blocks + bbNo;
 968       bb->_bci         = bci;
 969       bb->_max_locals  = _max_locals;
 970       bb->_max_stack   = _max_stack;
 971       bb->set_changed(false);
 972       bb->_stack_top   = BasicBlock::_dead_basic_block; // Initialize all basicblocks are dead.
 973       bb->_monitor_top = bad_monitors;
 974 
 975       if (bbNo > 0) {
 976         _basic_blocks[bbNo - 1]._end_bci = prev_bci;
 977       }
 978 
 979       bbNo++;
 980     }
 981     // Remember previous bci.
 982     prev_bci = bci;
 983   }
 984   // Set
 985   _basic_blocks[bbNo-1]._end_bci = prev_bci;
 986 
 987 
 988   // Check that the correct number of basicblocks was found
 989   if (bbNo !=_bb_count) {
 990     if (bbNo < _bb_count) {
 991       verify_error("jump into the middle of instruction?");
 992       return;
 993     } else {
 994       verify_error("extra basic blocks - should not happen?");
 995       return;
 996     }
 997   }
 998 
 999   _max_monitors = monitor_count;
1000 
1001   // Now that we have a bound on the depth of the monitor stack, we can
1002   // initialize the CellTypeState-related information.
1003   init_state();
1004 
1005   // We allocate space for all state-vectors for all basicblocks in one huge
1006   // chunk.  Then in the next part of the code, we set a pointer in each
1007   // _basic_block that points to each piece.
1008 
1009   // The product of bbNo and _state_len can get large if there are lots of
1010   // basic blocks and stack/locals/monitors.  Need to check to make sure
1011   // we don't overflow the capacity of a pointer.
1012   if ((unsigned)bbNo > UINTPTR_MAX / sizeof(CellTypeState) / _state_len) {
1013     report_error("The amount of memory required to analyze this method "
1014                  "exceeds addressable range");
1015     return;
1016   }
1017 
1018   CellTypeState *basicBlockState;
1019   ALLOC_RESOURCE_ARRAY(basicBlockState, CellTypeState, bbNo * _state_len);
1020   memset(basicBlockState, 0, bbNo * _state_len * sizeof(CellTypeState));
1021 
1022   // Make a pass over the basicblocks and assign their state vectors.
1023   for (int blockNum=0; blockNum < bbNo; blockNum++) {
1024     BasicBlock *bb = _basic_blocks + blockNum;
1025     bb->_state = basicBlockState + blockNum * _state_len;
1026 
1027 #ifdef ASSERT
1028     if (blockNum + 1 < bbNo) {
1029       address bcp = _method->bcp_from(bb->_end_bci);
1030       int bc_len = Bytecodes::java_length_at(_method(), bcp);
1031       assert(bb->_end_bci + bc_len == bb[1]._bci, "unmatched bci info in basicblock");
1032     }
1033 #endif
1034   }
1035 #ifdef ASSERT
1036   { BasicBlock *bb = &_basic_blocks[bbNo-1];
1037     address bcp = _method->bcp_from(bb->_end_bci);
1038     int bc_len = Bytecodes::java_length_at(_method(), bcp);
1039     assert(bb->_end_bci + bc_len == _method->code_size(), "wrong end bci");
1040   }
1041 #endif
1042 
1043   // Mark all alive blocks
1044   mark_reachable_code();
1045 }
1046 
1047 void GenerateOopMap::setup_method_entry_state() {
1048 
1049     // Initialize all locals to 'uninit' and set stack-height to 0
1050     make_context_uninitialized();
1051 
1052     // Initialize CellState type of arguments
1053     methodsig_to_effect(method()->signature(), method()->is_static(), vars());
1054 
1055     // If some references must be pre-assigned to null, then set that up
1056     initialize_vars();
1057 
1058     // This is the start state
1059     merge_state_into_bb(&_basic_blocks[0]);
1060 
1061     assert(_basic_blocks[0].changed(), "we are not getting off the ground");
1062 }
1063 
1064 // The instruction at bci is changing size by "delta".  Update the basic blocks.
1065 void GenerateOopMap::update_basic_blocks(int bci, int delta,
1066                                          int new_method_size) {
1067   assert(new_method_size >= method()->code_size() + delta,
1068          "new method size is too small");
1069 
1070   _bb_hdr_bits.reinitialize(new_method_size);
1071 
1072   for(int k = 0; k < _bb_count; k++) {
1073     if (_basic_blocks[k]._bci > bci) {
1074       _basic_blocks[k]._bci     += delta;
1075       _basic_blocks[k]._end_bci += delta;
1076     }
1077     _bb_hdr_bits.at_put(_basic_blocks[k]._bci, true);
1078   }
1079 }
1080 
1081 //
1082 // Initvars handling
1083 //
1084 
1085 void GenerateOopMap::initialize_vars() {
1086   for (int k = 0; k < _init_vars->length(); k++)
1087     _state[_init_vars->at(k)] = CellTypeState::make_slot_ref(k);
1088 }
1089 
1090 void GenerateOopMap::add_to_ref_init_set(int localNo) {
1091 
1092   if (TraceNewOopMapGeneration)
1093     tty->print_cr("Added init vars: %d", localNo);
1094 
1095   // Is it already in the set?
1096   if (_init_vars->contains(localNo) )
1097     return;
1098 
1099    _init_vars->append(localNo);
1100 }
1101 
1102 //
1103 // Interpreration code
1104 //
1105 
1106 void GenerateOopMap::interp_all() {
1107   bool change = true;
1108 
1109   while (change && !_got_error) {
1110     change = false;
1111     for (int i = 0; i < _bb_count && !_got_error; i++) {
1112       BasicBlock *bb = &_basic_blocks[i];
1113       if (bb->changed()) {
1114          if (_got_error) return;
1115          change = true;
1116          bb->set_changed(false);
1117          interp_bb(bb);
1118       }
1119     }
1120   }
1121 }
1122 
1123 void GenerateOopMap::interp_bb(BasicBlock *bb) {
1124 
1125   // We do not want to do anything in case the basic-block has not been initialized. This
1126   // will happen in the case where there is dead-code hang around in a method.
1127   assert(bb->is_reachable(), "should be reachable or deadcode exist");
1128   restore_state(bb);
1129 
1130   BytecodeStream itr(_method);
1131 
1132   // Set iterator interval to be the current basicblock
1133   int lim_bci = next_bb_start_pc(bb);
1134   itr.set_interval(bb->_bci, lim_bci);
1135   assert(lim_bci != bb->_bci, "must be at least one instruction in a basicblock");
1136   itr.next(); // read first instruction
1137 
1138   // Iterates through all bytecodes except the last in a basic block.
1139   // We handle the last one special, since there is controlflow change.
1140   while(itr.next_bci() < lim_bci && !_got_error) {
1141     if (_has_exceptions || _monitor_top != 0) {
1142       // We do not need to interpret the results of exceptional
1143       // continuation from this instruction when the method has no
1144       // exception handlers and the monitor stack is currently
1145       // empty.
1146       do_exception_edge(&itr);
1147     }
1148     interp1(&itr);
1149     itr.next();
1150   }
1151 
1152   // Handle last instruction.
1153   if (!_got_error) {
1154     assert(itr.next_bci() == lim_bci, "must point to end");
1155     if (_has_exceptions || _monitor_top != 0) {
1156       do_exception_edge(&itr);
1157     }
1158     interp1(&itr);
1159 
1160     bool fall_through = jump_targets_do(&itr, GenerateOopMap::merge_state, nullptr);
1161     if (_got_error)  return;
1162 
1163     if (itr.code() == Bytecodes::_ret) {
1164       assert(!fall_through, "cannot be set if ret instruction");
1165       // Automatically handles 'wide' ret indices
1166       ret_jump_targets_do(&itr, GenerateOopMap::merge_state, itr.get_index(), nullptr);
1167     } else if (fall_through) {
1168      // Hit end of BB, but the instr. was a fall-through instruction,
1169      // so perform transition as if the BB ended in a "jump".
1170      if (lim_bci != bb[1]._bci) {
1171        verify_error("bytecodes fell through last instruction");
1172        return;
1173      }
1174      merge_state_into_bb(bb + 1);
1175     }
1176   }
1177 }
1178 
1179 void GenerateOopMap::do_exception_edge(BytecodeStream* itr) {
1180   // Only check exception edge, if bytecode can trap
1181   if (!Bytecodes::can_trap(itr->code())) return;
1182   switch (itr->code()) {
1183     case Bytecodes::_aload_0:
1184       // These bytecodes can trap for rewriting.  We need to assume that
1185       // they do not throw exceptions to make the monitor analysis work.
1186       return;
1187 
1188     case Bytecodes::_ireturn:
1189     case Bytecodes::_lreturn:
1190     case Bytecodes::_freturn:
1191     case Bytecodes::_dreturn:
1192     case Bytecodes::_areturn:
1193     case Bytecodes::_return:
1194       // If the monitor stack height is not zero when we leave the method,
1195       // then we are either exiting with a non-empty stack or we have
1196       // found monitor trouble earlier in our analysis.  In either case,
1197       // assume an exception could be taken here.
1198       if (_monitor_top == 0) {
1199         return;
1200       }
1201       break;
1202 
1203     case Bytecodes::_monitorexit:
1204       // If the monitor stack height is bad_monitors, then we have detected a
1205       // monitor matching problem earlier in the analysis.  If the
1206       // monitor stack height is 0, we are about to pop a monitor
1207       // off of an empty stack.  In either case, the bytecode
1208       // could throw an exception.
1209       if (_monitor_top != bad_monitors && _monitor_top != 0) {
1210         return;
1211       }
1212       break;
1213 
1214     default:
1215       break;
1216   }
1217 
1218   if (_has_exceptions) {
1219     int bci = itr->bci();
1220     ExceptionTable exct(method());
1221     for(int i = 0; i< exct.length(); i++) {
1222       int start_pc   = exct.start_pc(i);
1223       int end_pc     = exct.end_pc(i);
1224       int handler_pc = exct.handler_pc(i);
1225       int catch_type = exct.catch_type_index(i);
1226 
1227       if (start_pc <= bci && bci < end_pc) {
1228         BasicBlock *excBB = get_basic_block_at(handler_pc);
1229         guarantee(excBB != nullptr, "no basic block for exception");
1230         CellTypeState *excStk = excBB->stack();
1231         CellTypeState *cOpStck = stack();
1232         CellTypeState cOpStck_0 = cOpStck[0];
1233         int cOpStackTop = _stack_top;
1234 
1235         // Exception stacks are always the same.
1236         assert(method()->max_stack() > 0, "sanity check");
1237 
1238         // We remembered the size and first element of "cOpStck"
1239         // above; now we temporarily set them to the appropriate
1240         // values for an exception handler. */
1241         cOpStck[0] = CellTypeState::make_slot_ref(_max_locals);
1242         _stack_top = 1;
1243 
1244         merge_state_into_bb(excBB);
1245 
1246         // Now undo the temporary change.
1247         cOpStck[0] = cOpStck_0;
1248         _stack_top = cOpStackTop;
1249 
1250         // If this is a "catch all" handler, then we do not need to
1251         // consider any additional handlers.
1252         if (catch_type == 0) {
1253           return;
1254         }
1255       }
1256     }
1257   }
1258 
1259   // It is possible that none of the exception handlers would have caught
1260   // the exception.  In this case, we will exit the method.  We must
1261   // ensure that the monitor stack is empty in this case.
1262   if (_monitor_top == 0) {
1263     return;
1264   }
1265 
1266   // We pessimistically assume that this exception can escape the
1267   // method. (It is possible that it will always be caught, but
1268   // we don't care to analyse the types of the catch clauses.)
1269 
1270   // We don't set _monitor_top to bad_monitors because there are no successors
1271   // to this exceptional exit.
1272 
1273   if (log_is_enabled(Info, monitormismatch) && _monitor_safe) {
1274     // We check _monitor_safe so that we only report the first mismatched
1275     // exceptional exit.
1276     report_monitor_mismatch("non-empty monitor stack at exceptional exit");
1277   }
1278   _monitor_safe = false;
1279 
1280 }
1281 
1282 void GenerateOopMap::report_monitor_mismatch(const char *msg) {
1283   LogStream ls(Log(monitormismatch)::info());
1284   ls.print("Monitor mismatch in method ");
1285   method()->print_short_name(&ls);
1286   ls.print_cr(": %s", msg);
1287 }
1288 
1289 void GenerateOopMap::print_states(outputStream *os,
1290                                   CellTypeState* vec, int num) {
1291   for (int i = 0; i < num; i++) {
1292     vec[i].print(tty);
1293   }
1294 }
1295 
1296 // Print the state values at the current bytecode.
1297 void GenerateOopMap::print_current_state(outputStream   *os,
1298                                          BytecodeStream *currentBC,
1299                                          bool            detailed) {
1300   if (detailed) {
1301     os->print("     %4d vars     = ", currentBC->bci());
1302     print_states(os, vars(), _max_locals);
1303     os->print("    %s", Bytecodes::name(currentBC->code()));
1304   } else {
1305     os->print("    %4d  vars = '%s' ", currentBC->bci(),  state_vec_to_string(vars(), _max_locals));
1306     os->print("     stack = '%s' ", state_vec_to_string(stack(), _stack_top));
1307     if (_monitor_top != bad_monitors) {
1308       os->print("  monitors = '%s'  \t%s", state_vec_to_string(monitors(), _monitor_top), Bytecodes::name(currentBC->code()));
1309     } else {
1310       os->print("  [bad monitor stack]");
1311     }
1312   }
1313 
1314   switch(currentBC->code()) {
1315     case Bytecodes::_invokevirtual:
1316     case Bytecodes::_invokespecial:
1317     case Bytecodes::_invokestatic:
1318     case Bytecodes::_invokedynamic:
1319     case Bytecodes::_invokeinterface: {
1320       int idx = currentBC->has_index_u4() ? currentBC->get_index_u4() : currentBC->get_index_u2();
1321       ConstantPool* cp      = method()->constants();
1322       int nameAndTypeIdx    = cp->name_and_type_ref_index_at(idx, currentBC->code());
1323       int signatureIdx      = cp->signature_ref_index_at(nameAndTypeIdx);
1324       Symbol* signature     = cp->symbol_at(signatureIdx);
1325       os->print("%s", signature->as_C_string());
1326     }
1327     default:
1328       break;
1329   }
1330 
1331   if (detailed) {
1332     os->cr();
1333     os->print("          stack    = ");
1334     print_states(os, stack(), _stack_top);
1335     os->cr();
1336     if (_monitor_top != bad_monitors) {
1337       os->print("          monitors = ");
1338       print_states(os, monitors(), _monitor_top);
1339     } else {
1340       os->print("          [bad monitor stack]");
1341     }
1342   }
1343 
1344   os->cr();
1345 }
1346 
1347 // Sets the current state to be the state after executing the
1348 // current instruction, starting in the current state.
1349 void GenerateOopMap::interp1(BytecodeStream *itr) {
1350   if (TraceNewOopMapGeneration) {
1351     print_current_state(tty, itr, TraceNewOopMapGenerationDetailed);
1352   }
1353 
1354   // Should we report the results? Result is reported *before* the instruction at the current bci is executed.
1355   // However, not for calls. For calls we do not want to include the arguments, so we postpone the reporting until
1356   // they have been popped (in method ppl).
1357   if (_report_result == true) {
1358     switch(itr->code()) {
1359       case Bytecodes::_invokevirtual:
1360       case Bytecodes::_invokespecial:
1361       case Bytecodes::_invokestatic:
1362       case Bytecodes::_invokedynamic:
1363       case Bytecodes::_invokeinterface:
1364         _itr_send = itr;
1365         _report_result_for_send = true;
1366         break;
1367       default:
1368        fill_stackmap_for_opcodes(itr, vars(), stack(), _stack_top);
1369        break;
1370     }
1371   }
1372 
1373   // abstract interpretation of current opcode
1374   switch(itr->code()) {
1375     case Bytecodes::_nop:                                           break;
1376     case Bytecodes::_goto:                                          break;
1377     case Bytecodes::_goto_w:                                        break;
1378     case Bytecodes::_iinc:                                          break;
1379     case Bytecodes::_return:            do_return_monitor_check();
1380                                         break;
1381 
1382     case Bytecodes::_aconst_null:
1383     case Bytecodes::_new:               ppush1(CellTypeState::make_line_ref(itr->bci()));
1384                                         break;
1385 
1386     case Bytecodes::_iconst_m1:
1387     case Bytecodes::_iconst_0:
1388     case Bytecodes::_iconst_1:
1389     case Bytecodes::_iconst_2:
1390     case Bytecodes::_iconst_3:
1391     case Bytecodes::_iconst_4:
1392     case Bytecodes::_iconst_5:
1393     case Bytecodes::_fconst_0:
1394     case Bytecodes::_fconst_1:
1395     case Bytecodes::_fconst_2:
1396     case Bytecodes::_bipush:
1397     case Bytecodes::_sipush:            ppush1(valCTS);             break;
1398 
1399     case Bytecodes::_lconst_0:
1400     case Bytecodes::_lconst_1:
1401     case Bytecodes::_dconst_0:
1402     case Bytecodes::_dconst_1:          ppush(vvCTS);               break;
1403 
1404     case Bytecodes::_ldc2_w:            ppush(vvCTS);               break;
1405 
1406     case Bytecodes::_ldc:               // fall through:
1407     case Bytecodes::_ldc_w:             do_ldc(itr->bci());         break;
1408 
1409     case Bytecodes::_iload:
1410     case Bytecodes::_fload:             ppload(vCTS, itr->get_index()); break;
1411 
1412     case Bytecodes::_lload:
1413     case Bytecodes::_dload:             ppload(vvCTS,itr->get_index()); break;
1414 
1415     case Bytecodes::_aload:             ppload(rCTS, itr->get_index()); break;
1416 
1417     case Bytecodes::_iload_0:
1418     case Bytecodes::_fload_0:           ppload(vCTS, 0);            break;
1419     case Bytecodes::_iload_1:
1420     case Bytecodes::_fload_1:           ppload(vCTS, 1);            break;
1421     case Bytecodes::_iload_2:
1422     case Bytecodes::_fload_2:           ppload(vCTS, 2);            break;
1423     case Bytecodes::_iload_3:
1424     case Bytecodes::_fload_3:           ppload(vCTS, 3);            break;
1425 
1426     case Bytecodes::_lload_0:
1427     case Bytecodes::_dload_0:           ppload(vvCTS, 0);           break;
1428     case Bytecodes::_lload_1:
1429     case Bytecodes::_dload_1:           ppload(vvCTS, 1);           break;
1430     case Bytecodes::_lload_2:
1431     case Bytecodes::_dload_2:           ppload(vvCTS, 2);           break;
1432     case Bytecodes::_lload_3:
1433     case Bytecodes::_dload_3:           ppload(vvCTS, 3);           break;
1434 
1435     case Bytecodes::_aload_0:           ppload(rCTS, 0);            break;
1436     case Bytecodes::_aload_1:           ppload(rCTS, 1);            break;
1437     case Bytecodes::_aload_2:           ppload(rCTS, 2);            break;
1438     case Bytecodes::_aload_3:           ppload(rCTS, 3);            break;
1439 
1440     case Bytecodes::_iaload:
1441     case Bytecodes::_faload:
1442     case Bytecodes::_baload:
1443     case Bytecodes::_caload:
1444     case Bytecodes::_saload:            pp(vrCTS, vCTS); break;
1445 
1446     case Bytecodes::_laload:            pp(vrCTS, vvCTS);  break;
1447     case Bytecodes::_daload:            pp(vrCTS, vvCTS); break;
1448 
1449     case Bytecodes::_aaload:            pp_new_ref(vrCTS, itr->bci()); break;
1450 
1451     case Bytecodes::_istore:
1452     case Bytecodes::_fstore:            ppstore(vCTS, itr->get_index()); break;
1453 
1454     case Bytecodes::_lstore:
1455     case Bytecodes::_dstore:            ppstore(vvCTS, itr->get_index()); break;
1456 
1457     case Bytecodes::_astore:            do_astore(itr->get_index());     break;
1458 
1459     case Bytecodes::_istore_0:
1460     case Bytecodes::_fstore_0:          ppstore(vCTS, 0);           break;
1461     case Bytecodes::_istore_1:
1462     case Bytecodes::_fstore_1:          ppstore(vCTS, 1);           break;
1463     case Bytecodes::_istore_2:
1464     case Bytecodes::_fstore_2:          ppstore(vCTS, 2);           break;
1465     case Bytecodes::_istore_3:
1466     case Bytecodes::_fstore_3:          ppstore(vCTS, 3);           break;
1467 
1468     case Bytecodes::_lstore_0:
1469     case Bytecodes::_dstore_0:          ppstore(vvCTS, 0);          break;
1470     case Bytecodes::_lstore_1:
1471     case Bytecodes::_dstore_1:          ppstore(vvCTS, 1);          break;
1472     case Bytecodes::_lstore_2:
1473     case Bytecodes::_dstore_2:          ppstore(vvCTS, 2);          break;
1474     case Bytecodes::_lstore_3:
1475     case Bytecodes::_dstore_3:          ppstore(vvCTS, 3);          break;
1476 
1477     case Bytecodes::_astore_0:          do_astore(0);               break;
1478     case Bytecodes::_astore_1:          do_astore(1);               break;
1479     case Bytecodes::_astore_2:          do_astore(2);               break;
1480     case Bytecodes::_astore_3:          do_astore(3);               break;
1481 
1482     case Bytecodes::_iastore:
1483     case Bytecodes::_fastore:
1484     case Bytecodes::_bastore:
1485     case Bytecodes::_castore:
1486     case Bytecodes::_sastore:           ppop(vvrCTS);               break;
1487     case Bytecodes::_lastore:
1488     case Bytecodes::_dastore:           ppop(vvvrCTS);              break;
1489     case Bytecodes::_aastore:           ppop(rvrCTS);               break;
1490 
1491     case Bytecodes::_pop:               ppop_any(1);                break;
1492     case Bytecodes::_pop2:              ppop_any(2);                break;
1493 
1494     case Bytecodes::_dup:               ppdupswap(1, "11");         break;
1495     case Bytecodes::_dup_x1:            ppdupswap(2, "121");        break;
1496     case Bytecodes::_dup_x2:            ppdupswap(3, "1321");       break;
1497     case Bytecodes::_dup2:              ppdupswap(2, "2121");       break;
1498     case Bytecodes::_dup2_x1:           ppdupswap(3, "21321");      break;
1499     case Bytecodes::_dup2_x2:           ppdupswap(4, "214321");     break;
1500     case Bytecodes::_swap:              ppdupswap(2, "12");         break;
1501 
1502     case Bytecodes::_iadd:
1503     case Bytecodes::_fadd:
1504     case Bytecodes::_isub:
1505     case Bytecodes::_fsub:
1506     case Bytecodes::_imul:
1507     case Bytecodes::_fmul:
1508     case Bytecodes::_idiv:
1509     case Bytecodes::_fdiv:
1510     case Bytecodes::_irem:
1511     case Bytecodes::_frem:
1512     case Bytecodes::_ishl:
1513     case Bytecodes::_ishr:
1514     case Bytecodes::_iushr:
1515     case Bytecodes::_iand:
1516     case Bytecodes::_ior:
1517     case Bytecodes::_ixor:
1518     case Bytecodes::_l2f:
1519     case Bytecodes::_l2i:
1520     case Bytecodes::_d2f:
1521     case Bytecodes::_d2i:
1522     case Bytecodes::_fcmpl:
1523     case Bytecodes::_fcmpg:             pp(vvCTS, vCTS); break;
1524 
1525     case Bytecodes::_ladd:
1526     case Bytecodes::_dadd:
1527     case Bytecodes::_lsub:
1528     case Bytecodes::_dsub:
1529     case Bytecodes::_lmul:
1530     case Bytecodes::_dmul:
1531     case Bytecodes::_ldiv:
1532     case Bytecodes::_ddiv:
1533     case Bytecodes::_lrem:
1534     case Bytecodes::_drem:
1535     case Bytecodes::_land:
1536     case Bytecodes::_lor:
1537     case Bytecodes::_lxor:              pp(vvvvCTS, vvCTS); break;
1538 
1539     case Bytecodes::_ineg:
1540     case Bytecodes::_fneg:
1541     case Bytecodes::_i2f:
1542     case Bytecodes::_f2i:
1543     case Bytecodes::_i2c:
1544     case Bytecodes::_i2s:
1545     case Bytecodes::_i2b:               pp(vCTS, vCTS); break;
1546 
1547     case Bytecodes::_lneg:
1548     case Bytecodes::_dneg:
1549     case Bytecodes::_l2d:
1550     case Bytecodes::_d2l:               pp(vvCTS, vvCTS); break;
1551 
1552     case Bytecodes::_lshl:
1553     case Bytecodes::_lshr:
1554     case Bytecodes::_lushr:             pp(vvvCTS, vvCTS); break;
1555 
1556     case Bytecodes::_i2l:
1557     case Bytecodes::_i2d:
1558     case Bytecodes::_f2l:
1559     case Bytecodes::_f2d:               pp(vCTS, vvCTS); break;
1560 
1561     case Bytecodes::_lcmp:              pp(vvvvCTS, vCTS); break;
1562     case Bytecodes::_dcmpl:
1563     case Bytecodes::_dcmpg:             pp(vvvvCTS, vCTS); break;
1564 
1565     case Bytecodes::_ifeq:
1566     case Bytecodes::_ifne:
1567     case Bytecodes::_iflt:
1568     case Bytecodes::_ifge:
1569     case Bytecodes::_ifgt:
1570     case Bytecodes::_ifle:
1571     case Bytecodes::_tableswitch:       ppop1(valCTS);
1572                                         break;
1573     case Bytecodes::_ireturn:
1574     case Bytecodes::_freturn:           do_return_monitor_check();
1575                                         ppop1(valCTS);
1576                                         break;
1577     case Bytecodes::_if_icmpeq:
1578     case Bytecodes::_if_icmpne:
1579     case Bytecodes::_if_icmplt:
1580     case Bytecodes::_if_icmpge:
1581     case Bytecodes::_if_icmpgt:
1582     case Bytecodes::_if_icmple:         ppop(vvCTS);
1583                                         break;
1584 
1585     case Bytecodes::_lreturn:           do_return_monitor_check();
1586                                         ppop(vvCTS);
1587                                         break;
1588 
1589     case Bytecodes::_dreturn:           do_return_monitor_check();
1590                                         ppop(vvCTS);
1591                                         break;
1592 
1593     case Bytecodes::_if_acmpeq:
1594     case Bytecodes::_if_acmpne:         ppop(rrCTS);                 break;
1595 
1596     case Bytecodes::_jsr:               do_jsr(itr->dest());         break;
1597     case Bytecodes::_jsr_w:             do_jsr(itr->dest_w());       break;
1598 
1599     case Bytecodes::_getstatic:         do_field(true,   true,  itr->get_index_u2(), itr->bci(), itr->code()); break;
1600     case Bytecodes::_putstatic:         do_field(false,  true,  itr->get_index_u2(), itr->bci(), itr->code()); break;
1601     case Bytecodes::_getfield:          do_field(true,   false, itr->get_index_u2(), itr->bci(), itr->code()); break;
1602     case Bytecodes::_putfield:          do_field(false,  false, itr->get_index_u2(), itr->bci(), itr->code()); break;
1603 
1604     case Bytecodes::_invokeinterface:
1605     case Bytecodes::_invokevirtual:
1606     case Bytecodes::_invokespecial:     do_method(false, itr->get_index_u2(), itr->bci(), itr->code()); break;
1607     case Bytecodes::_invokestatic:      do_method(true , itr->get_index_u2(), itr->bci(), itr->code()); break;
1608     case Bytecodes::_invokedynamic:     do_method(true , itr->get_index_u4(), itr->bci(), itr->code()); break;
1609     case Bytecodes::_newarray:
1610     case Bytecodes::_anewarray:         pp_new_ref(vCTS, itr->bci()); break;
1611     case Bytecodes::_checkcast:         do_checkcast(); break;
1612     case Bytecodes::_arraylength:
1613     case Bytecodes::_instanceof:        pp(rCTS, vCTS); break;
1614     case Bytecodes::_monitorenter:      do_monitorenter(itr->bci()); break;
1615     case Bytecodes::_monitorexit:       do_monitorexit(itr->bci()); break;
1616 
1617     case Bytecodes::_athrow:            // handled by do_exception_edge() BUT ...
1618                                         // vlh(apple): do_exception_edge() does not get
1619                                         // called if method has no exception handlers
1620                                         if ((!_has_exceptions) && (_monitor_top > 0)) {
1621                                           _monitor_safe = false;
1622                                         }
1623                                         break;
1624 
1625     case Bytecodes::_areturn:           do_return_monitor_check();
1626                                         ppop1(refCTS);
1627                                         break;
1628 
1629     case Bytecodes::_ifnull:
1630     case Bytecodes::_ifnonnull:         ppop1(refCTS); break;
1631     case Bytecodes::_multianewarray:    do_multianewarray(*(itr->bcp()+3), itr->bci()); break;
1632 
1633     case Bytecodes::_wide:              fatal("Iterator should skip this bytecode"); break;
1634     case Bytecodes::_ret:                                           break;
1635 
1636     // Java opcodes
1637     case Bytecodes::_lookupswitch:      ppop1(valCTS);             break;
1638 
1639     default:
1640          tty->print("unexpected opcode: %d\n", itr->code());
1641          ShouldNotReachHere();
1642     break;
1643   }
1644 }
1645 
1646 void GenerateOopMap::check_type(CellTypeState expected, CellTypeState actual) {
1647   if (!expected.equal_kind(actual)) {
1648     verify_error("wrong type on stack (found: %c expected: %c)", actual.to_char(), expected.to_char());
1649   }
1650 }
1651 
1652 void GenerateOopMap::ppstore(CellTypeState *in, int loc_no) {
1653   while(!(*in).is_bottom()) {
1654     CellTypeState expected =*in++;
1655     CellTypeState actual   = pop();
1656     check_type(expected, actual);
1657     assert(loc_no >= 0, "sanity check");
1658     set_var(loc_no++, actual);
1659   }
1660 }
1661 
1662 void GenerateOopMap::ppload(CellTypeState *out, int loc_no) {
1663   while(!(*out).is_bottom()) {
1664     CellTypeState out1 = *out++;
1665     CellTypeState vcts = get_var(loc_no);
1666     assert(out1.can_be_reference() || out1.can_be_value(),
1667            "can only load refs. and values.");
1668     if (out1.is_reference()) {
1669       assert(loc_no>=0, "sanity check");
1670       if (!vcts.is_reference()) {
1671         // We were asked to push a reference, but the type of the
1672         // variable can be something else
1673         _conflict = true;
1674         if (vcts.can_be_uninit()) {
1675           // It is a ref-uninit conflict (at least). If there are other
1676           // problems, we'll get them in the next round
1677           add_to_ref_init_set(loc_no);
1678           vcts = out1;
1679         } else {
1680           // It wasn't a ref-uninit conflict. So must be a
1681           // ref-val or ref-pc conflict. Split the variable.
1682           record_refval_conflict(loc_no);
1683           vcts = out1;
1684         }
1685         push(out1); // recover...
1686       } else {
1687         push(vcts); // preserve reference.
1688       }
1689       // Otherwise it is a conflict, but one that verification would
1690       // have caught if illegal. In particular, it can't be a topCTS
1691       // resulting from mergeing two difference pcCTS's since the verifier
1692       // would have rejected any use of such a merge.
1693     } else {
1694       push(out1); // handle val/init conflict
1695     }
1696     loc_no++;
1697   }
1698 }
1699 
1700 void GenerateOopMap::ppdupswap(int poplen, const char *out) {
1701   CellTypeState actual[5];
1702   assert(poplen < 5, "this must be less than length of actual vector");
1703 
1704   // Pop all arguments.
1705   for (int i = 0; i < poplen; i++) {
1706     actual[i] = pop();
1707   }
1708   // Field _state is uninitialized when calling push.
1709   for (int i = poplen; i < 5; i++) {
1710     actual[i] = CellTypeState::uninit;
1711   }
1712 
1713   // put them back
1714   char push_ch = *out++;
1715   while (push_ch != '\0') {
1716     int idx = push_ch - '1';
1717     assert(idx >= 0 && idx < poplen, "wrong arguments");
1718     push(actual[idx]);
1719     push_ch = *out++;
1720   }
1721 }
1722 
1723 void GenerateOopMap::ppop1(CellTypeState out) {
1724   CellTypeState actual = pop();
1725   check_type(out, actual);
1726 }
1727 
1728 void GenerateOopMap::ppop(CellTypeState *out) {
1729   while (!(*out).is_bottom()) {
1730     ppop1(*out++);
1731   }
1732 }
1733 
1734 void GenerateOopMap::ppush1(CellTypeState in) {
1735   assert(in.is_reference() || in.is_value(), "sanity check");
1736   push(in);
1737 }
1738 
1739 void GenerateOopMap::ppush(CellTypeState *in) {
1740   while (!(*in).is_bottom()) {
1741     ppush1(*in++);
1742   }
1743 }
1744 
1745 void GenerateOopMap::pp(CellTypeState *in, CellTypeState *out) {
1746   ppop(in);
1747   ppush(out);
1748 }
1749 
1750 void GenerateOopMap::pp_new_ref(CellTypeState *in, int bci) {
1751   ppop(in);
1752   ppush1(CellTypeState::make_line_ref(bci));
1753 }
1754 
1755 void GenerateOopMap::ppop_any(int poplen) {
1756   if (_stack_top >= poplen) {
1757     _stack_top -= poplen;
1758   } else {
1759     verify_error("stack underflow");
1760   }
1761 }
1762 
1763 // Replace all occurrences of the state 'match' with the state 'replace'
1764 // in our current state vector.
1765 void GenerateOopMap::replace_all_CTS_matches(CellTypeState match,
1766                                              CellTypeState replace) {
1767   int i;
1768   int len = _max_locals + _stack_top;
1769   bool change = false;
1770 
1771   for (i = len - 1; i >= 0; i--) {
1772     if (match.equal(_state[i])) {
1773       _state[i] = replace;
1774     }
1775   }
1776 
1777   if (_monitor_top > 0) {
1778     int base = _max_locals + _max_stack;
1779     len = base + _monitor_top;
1780     for (i = len - 1; i >= base; i--) {
1781       if (match.equal(_state[i])) {
1782         _state[i] = replace;
1783       }
1784     }
1785   }
1786 }
1787 
1788 void GenerateOopMap::do_checkcast() {
1789   CellTypeState actual = pop();
1790   check_type(refCTS, actual);
1791   push(actual);
1792 }
1793 
1794 void GenerateOopMap::do_monitorenter(int bci) {
1795   CellTypeState actual = pop();
1796   if (_monitor_top == bad_monitors) {
1797     return;
1798   }
1799 
1800   // Bail out when we get repeated locks on an identical monitor.  This case
1801   // isn't too hard to handle and can be made to work if supporting nested
1802   // redundant synchronized statements becomes a priority.
1803   //
1804   // See also "Note" in do_monitorexit(), below.
1805   if (actual.is_lock_reference()) {
1806     _monitor_top = bad_monitors;
1807     _monitor_safe = false;
1808 
1809     if (log_is_enabled(Info, monitormismatch)) {
1810       report_monitor_mismatch("nested redundant lock -- bailout...");
1811     }
1812     return;
1813   }
1814 
1815   CellTypeState lock = CellTypeState::make_lock_ref(bci);
1816   check_type(refCTS, actual);
1817   if (!actual.is_info_top()) {
1818     replace_all_CTS_matches(actual, lock);
1819     monitor_push(lock);
1820   }
1821 }
1822 
1823 void GenerateOopMap::do_monitorexit(int bci) {
1824   CellTypeState actual = pop();
1825   if (_monitor_top == bad_monitors) {
1826     return;
1827   }
1828   check_type(refCTS, actual);
1829   CellTypeState expected = monitor_pop();
1830   if (!actual.is_lock_reference() || !expected.equal(actual)) {
1831     // The monitor we are exiting is not verifiably the one
1832     // on the top of our monitor stack.  This causes a monitor
1833     // mismatch.
1834     _monitor_top = bad_monitors;
1835     _monitor_safe = false;
1836 
1837     // We need to mark this basic block as changed so that
1838     // this monitorexit will be visited again.  We need to
1839     // do this to ensure that we have accounted for the
1840     // possibility that this bytecode will throw an
1841     // exception.
1842     BasicBlock* bb = get_basic_block_containing(bci);
1843     guarantee(bb != nullptr, "no basic block for bci");
1844     bb->set_changed(true);
1845     bb->_monitor_top = bad_monitors;
1846 
1847     if (log_is_enabled(Info, monitormismatch)) {
1848       report_monitor_mismatch("improper monitor pair");
1849     }
1850   } else {
1851     // This code is a fix for the case where we have repeated
1852     // locking of the same object in straightline code.  We clear
1853     // out the lock when it is popped from the monitor stack
1854     // and replace it with an unobtrusive reference value that can
1855     // be locked again.
1856     //
1857     // Note: when generateOopMap is fixed to properly handle repeated,
1858     //       nested, redundant locks on the same object, then this
1859     //       fix will need to be removed at that time.
1860     replace_all_CTS_matches(actual, CellTypeState::make_line_ref(bci));
1861   }
1862 }
1863 
1864 void GenerateOopMap::do_return_monitor_check() {
1865   if (_monitor_top > 0) {
1866     // The monitor stack must be empty when we leave the method
1867     // for the monitors to be properly matched.
1868     _monitor_safe = false;
1869 
1870     // Since there are no successors to the *return bytecode, it
1871     // isn't necessary to set _monitor_top to bad_monitors.
1872 
1873     if (log_is_enabled(Info, monitormismatch)) {
1874       report_monitor_mismatch("non-empty monitor stack at return");
1875     }
1876   }
1877 }
1878 
1879 void GenerateOopMap::do_jsr(int targ_bci) {
1880   push(CellTypeState::make_addr(targ_bci));
1881 }
1882 
1883 
1884 
1885 void GenerateOopMap::do_ldc(int bci) {
1886   Bytecode_loadconstant ldc(methodHandle(Thread::current(), method()), bci);
1887   ConstantPool* cp  = method()->constants();
1888   constantTag tag = cp->tag_at(ldc.pool_index()); // idx is index in resolved_references
1889   BasicType       bt  = ldc.result_type();
1890 #ifdef ASSERT
1891   BasicType   tag_bt = (tag.is_dynamic_constant() || tag.is_dynamic_constant_in_error()) ? bt : tag.basic_type();
1892   assert(bt == tag_bt, "same result");
1893 #endif
1894   CellTypeState   cts;
1895   if (is_reference_type(bt)) {  // could be T_ARRAY with condy
1896     assert(!tag.is_string_index() && !tag.is_klass_index(), "Unexpected index tag");
1897     cts = CellTypeState::make_line_ref(bci);
1898   } else {
1899     cts = valCTS;
1900   }
1901   ppush1(cts);
1902 }
1903 
1904 void GenerateOopMap::do_multianewarray(int dims, int bci) {
1905   assert(dims >= 1, "sanity check");
1906   for(int i = dims -1; i >=0; i--) {
1907     ppop1(valCTS);
1908   }
1909   ppush1(CellTypeState::make_line_ref(bci));
1910 }
1911 
1912 void GenerateOopMap::do_astore(int idx) {
1913   CellTypeState r_or_p = pop();
1914   if (!r_or_p.is_address() && !r_or_p.is_reference()) {
1915     // We actually expected ref or pc, but we only report that we expected a ref. It does not
1916     // really matter (at least for now)
1917     verify_error("wrong type on stack (found: %c, expected: {pr})", r_or_p.to_char());
1918     return;
1919   }
1920   set_var(idx, r_or_p);
1921 }
1922 
1923 // Copies bottom/zero terminated CTS string from "src" into "dst".
1924 //   Does NOT terminate with a bottom. Returns the number of cells copied.
1925 int GenerateOopMap::copy_cts(CellTypeState *dst, CellTypeState *src) {
1926   int idx = 0;
1927   while (!src[idx].is_bottom()) {
1928     dst[idx] = src[idx];
1929     idx++;
1930   }
1931   return idx;
1932 }
1933 
1934 void GenerateOopMap::do_field(int is_get, int is_static, int idx, int bci, Bytecodes::Code bc) {
1935   // Dig up signature for field in constant pool
1936   ConstantPool* cp     = method()->constants();
1937   int nameAndTypeIdx     = cp->name_and_type_ref_index_at(idx, bc);
1938   int signatureIdx       = cp->signature_ref_index_at(nameAndTypeIdx);
1939   Symbol* signature      = cp->symbol_at(signatureIdx);
1940 
1941   CellTypeState temp[4];
1942   CellTypeState *eff  = signature_to_effect(signature, bci, temp);
1943 
1944   CellTypeState in[4];
1945   CellTypeState *out;
1946   int i =  0;
1947 
1948   if (is_get) {
1949     out = eff;
1950   } else {
1951     out = epsilonCTS;
1952     i   = copy_cts(in, eff);
1953   }
1954   if (!is_static) {
1955     in[i++] = CellTypeState::ref;
1956   }
1957   in[i] = CellTypeState::bottom;
1958   assert(i<=3, "sanity check");
1959   pp(in, out);
1960 }
1961 
1962 void GenerateOopMap::do_method(int is_static, int idx, int bci, Bytecodes::Code bc) {
1963  // Dig up signature for field in constant pool
1964   ConstantPool* cp  = _method->constants();
1965   Symbol* signature   = cp->signature_ref_at(idx, bc);
1966 
1967   // Parse method signature
1968   CellTypeState out[4];
1969   CellTypeState in[MAXARGSIZE+1];   // Includes result
1970   ComputeCallStack cse(signature);
1971 
1972   // Compute return type
1973   int res_length=  cse.compute_for_returntype(out);
1974 
1975   // Temporary hack.
1976   if (out[0].equal(CellTypeState::ref) && out[1].equal(CellTypeState::bottom)) {
1977     out[0] = CellTypeState::make_line_ref(bci);
1978   }
1979 
1980   assert(res_length<=4, "max value should be vv");
1981 
1982   // Compute arguments
1983   int arg_length = cse.compute_for_parameters(is_static != 0, in);
1984   assert(arg_length<=MAXARGSIZE, "too many locals");
1985 
1986   // Pop arguments
1987   for (int i = arg_length - 1; i >= 0; i--) ppop1(in[i]);// Do args in reverse order.
1988 
1989   // Report results
1990   if (_report_result_for_send == true) {
1991      fill_stackmap_for_opcodes(_itr_send, vars(), stack(), _stack_top);
1992      _report_result_for_send = false;
1993   }
1994 
1995   // Push return address
1996   ppush(out);
1997 }
1998 
1999 // This is used to parse the signature for fields, since they are very simple...
2000 CellTypeState *GenerateOopMap::signature_to_effect(const Symbol* sig, int bci, CellTypeState *out) {
2001   // Object and array
2002   BasicType bt = Signature::basic_type(sig);
2003   if (is_reference_type(bt)) {
2004     out[0] = CellTypeState::make_line_ref(bci);
2005     out[1] = CellTypeState::bottom;
2006     return out;
2007   }
2008   if (is_double_word_type(bt)) return vvCTS; // Long and Double
2009   if (bt == T_VOID) return epsilonCTS;       // Void
2010   return vCTS;                               // Otherwise
2011 }
2012 
2013 uint64_t GenerateOopMap::_total_byte_count = 0;
2014 elapsedTimer GenerateOopMap::_total_oopmap_time;
2015 
2016 // This function assumes "bcs" is at a "ret" instruction and that the vars
2017 // state is valid for that instruction. Furthermore, the ret instruction
2018 // must be the last instruction in "bb" (we store information about the
2019 // "ret" in "bb").
2020 void GenerateOopMap::ret_jump_targets_do(BytecodeStream *bcs, jmpFct_t jmpFct, int varNo, int *data) {
2021   CellTypeState ra = vars()[varNo];
2022   if (!ra.is_good_address()) {
2023     verify_error("ret returns from two jsr subroutines?");
2024     return;
2025   }
2026   int target = ra.get_info();
2027 
2028   RetTableEntry* rtEnt = _rt.find_jsrs_for_target(target);
2029   int bci = bcs->bci();
2030   for (int i = 0; i < rtEnt->nof_jsrs(); i++) {
2031     int target_bci = rtEnt->jsrs(i);
2032     // Make sure a jrtRet does not set the changed bit for dead basicblock.
2033     BasicBlock* jsr_bb    = get_basic_block_containing(target_bci - 1);
2034     debug_only(BasicBlock* target_bb = &jsr_bb[1];)
2035     assert(target_bb  == get_basic_block_at(target_bci), "wrong calc. of successor basicblock");
2036     bool alive = jsr_bb->is_alive();
2037     if (TraceNewOopMapGeneration) {
2038       tty->print("pc = %d, ret -> %d alive: %s\n", bci, target_bci, alive ? "true" : "false");
2039     }
2040     if (alive) jmpFct(this, target_bci, data);
2041   }
2042 }
2043 
2044 //
2045 // Debug method
2046 //
2047 char* GenerateOopMap::state_vec_to_string(CellTypeState* vec, int len) {
2048 #ifdef ASSERT
2049   int checklen = MAX3(_max_locals, _max_stack, _max_monitors) + 1;
2050   assert(len < checklen, "state_vec_buf overflow");
2051 #endif
2052   for (int i = 0; i < len; i++) _state_vec_buf[i] = vec[i].to_char();
2053   _state_vec_buf[len] = 0;
2054   return _state_vec_buf;
2055 }
2056 
2057 void GenerateOopMap::print_time() {
2058   tty->print_cr ("Accumulated oopmap times:");
2059   tty->print_cr ("---------------------------");
2060   tty->print_cr ("  Total : %3.3f sec.", GenerateOopMap::_total_oopmap_time.seconds());
2061   tty->print_cr ("  (%3.0f bytecodes per sec) ",
2062   (double)GenerateOopMap::_total_byte_count / GenerateOopMap::_total_oopmap_time.seconds());
2063 }
2064 
2065 //
2066 //  ============ Main Entry Point ===========
2067 //
2068 GenerateOopMap::GenerateOopMap(const methodHandle& method) {
2069   // We have to initialize all variables here, that can be queried directly
2070   _method = method;
2071   _max_locals=0;
2072   _init_vars = nullptr;
2073 
2074 #ifndef PRODUCT
2075   // If we are doing a detailed trace, include the regular trace information.
2076   if (TraceNewOopMapGenerationDetailed) {
2077     TraceNewOopMapGeneration = true;
2078   }
2079 #endif
2080 }
2081 
2082 bool GenerateOopMap::compute_map(Thread* current) {
2083 #ifndef PRODUCT
2084   if (TimeOopMap2) {
2085     method()->print_short_name(tty);
2086     tty->print("  ");
2087   }
2088   if (TimeOopMap) {
2089     _total_byte_count += method()->code_size();
2090   }
2091 #endif
2092   TraceTime t_single("oopmap time", TimeOopMap2);
2093   TraceTime t_all(nullptr, &_total_oopmap_time, TimeOopMap);
2094 
2095   // Initialize values
2096   _got_error      = false;
2097   _conflict       = false;
2098   _max_locals     = method()->max_locals();
2099   _max_stack      = method()->max_stack();
2100   _has_exceptions = (method()->has_exception_handler());
2101   _nof_refval_conflicts = 0;
2102   _init_vars      = new GrowableArray<intptr_t>(5);  // There are seldom more than 5 init_vars
2103   _report_result  = false;
2104   _report_result_for_send = false;
2105   _new_var_map    = nullptr;
2106   _ret_adr_tos    = new GrowableArray<int>(5);  // 5 seems like a good number;
2107   _did_rewriting  = false;
2108   _did_relocation = false;
2109 
2110   if (TraceNewOopMapGeneration) {
2111     tty->print("Method name: %s\n", method()->name()->as_C_string());
2112     if (Verbose) {
2113       _method->print_codes();
2114       tty->print_cr("Exception table:");
2115       ExceptionTable excps(method());
2116       for(int i = 0; i < excps.length(); i ++) {
2117         tty->print_cr("[%d - %d] -> %d",
2118                       excps.start_pc(i), excps.end_pc(i), excps.handler_pc(i));
2119       }
2120     }
2121   }
2122 
2123   // if no code - do nothing
2124   // compiler needs info
2125   if (method()->code_size() == 0 || _max_locals + method()->max_stack() == 0) {
2126     fill_stackmap_prolog(0);
2127     fill_stackmap_epilog();
2128     return true;
2129   }
2130   // Step 1: Compute all jump targets and their return value
2131   if (!_got_error)
2132     _rt.compute_ret_table(_method);
2133 
2134   // Step 2: Find all basic blocks and count GC points
2135   if (!_got_error)
2136     mark_bbheaders_and_count_gc_points();
2137 
2138   // Step 3: Calculate stack maps
2139   if (!_got_error)
2140     do_interpretation();
2141 
2142   // Step 4:Return results
2143   if (!_got_error && report_results())
2144      report_result();
2145 
2146   return !_got_error;
2147 }
2148 
2149 // Error handling methods
2150 //
2151 // If we compute from a suitable JavaThread then we create an exception for the GenerateOopMap
2152 // calling code to retrieve (via exception()) and throw if desired (in most cases errors are ignored).
2153 // Otherwise it is considered a fatal error to hit malformed bytecode.
2154 void GenerateOopMap::error_work(const char *format, va_list ap) {
2155   _got_error = true;
2156   char msg_buffer[512];
2157   os::vsnprintf(msg_buffer, sizeof(msg_buffer), format, ap);
2158   // Append method name
2159   char msg_buffer2[512];
2160   os::snprintf(msg_buffer2, sizeof(msg_buffer2), "%s in method %s", msg_buffer, method()->name()->as_C_string());
2161   Thread* current = Thread::current();
2162   if (current->can_call_java()) {
2163     _exception = Exceptions::new_exception(JavaThread::cast(current),
2164                                            vmSymbols::java_lang_LinkageError(),
2165                                            msg_buffer2);
2166   } else {
2167     fatal("%s", msg_buffer2);
2168   }
2169 }
2170 
2171 void GenerateOopMap::report_error(const char *format, ...) {
2172   va_list ap;
2173   va_start(ap, format);
2174   error_work(format, ap);
2175 }
2176 
2177 void GenerateOopMap::verify_error(const char *format, ...) {
2178   // We do not distinguish between different types of errors for verification
2179   // errors.  Let the verifier give a better message.
2180   report_error("Illegal class file encountered. Try running with -Xverify:all");
2181 }
2182 
2183 //
2184 // Report result opcodes
2185 //
2186 void GenerateOopMap::report_result() {
2187 
2188   if (TraceNewOopMapGeneration) tty->print_cr("Report result pass");
2189 
2190   // We now want to report the result of the parse
2191   _report_result = true;
2192 
2193   // Prolog code
2194   fill_stackmap_prolog(_gc_points);
2195 
2196    // Mark everything changed, then do one interpretation pass.
2197   for (int i = 0; i<_bb_count; i++) {
2198     if (_basic_blocks[i].is_reachable()) {
2199       _basic_blocks[i].set_changed(true);
2200       interp_bb(&_basic_blocks[i]);
2201     }
2202   }
2203 
2204   // Note: Since we are skipping dead-code when we are reporting results, then
2205   // the no. of encountered gc-points might be fewer than the previously number
2206   // we have counted. (dead-code is a pain - it should be removed before we get here)
2207   fill_stackmap_epilog();
2208 
2209   // Report initvars
2210   fill_init_vars(_init_vars);
2211 
2212   _report_result = false;
2213 }
2214 
2215 void GenerateOopMap::result_for_basicblock(int bci) {
2216  if (TraceNewOopMapGeneration) tty->print_cr("Report result pass for basicblock");
2217 
2218   // We now want to report the result of the parse
2219   _report_result = true;
2220 
2221   // Find basicblock and report results
2222   BasicBlock* bb = get_basic_block_containing(bci);
2223   guarantee(bb != nullptr, "no basic block for bci");
2224   assert(bb->is_reachable(), "getting result from unreachable basicblock");
2225   bb->set_changed(true);
2226   interp_bb(bb);
2227 }
2228 
2229 //
2230 // Conflict handling code
2231 //
2232 
2233 void GenerateOopMap::record_refval_conflict(int varNo) {
2234   assert(varNo>=0 && varNo< _max_locals, "index out of range");
2235 
2236   if (TraceOopMapRewrites) {
2237      tty->print("### Conflict detected (local no: %d)\n", varNo);
2238   }
2239 
2240   if (!_new_var_map) {
2241     _new_var_map = NEW_RESOURCE_ARRAY(int, _max_locals);
2242     for (int k = 0; k < _max_locals; k++)  _new_var_map[k] = k;
2243   }
2244 
2245   if ( _new_var_map[varNo] == varNo) {
2246     // Check if max. number of locals has been reached
2247     if (_max_locals + _nof_refval_conflicts >= MAX_LOCAL_VARS) {
2248       report_error("Rewriting exceeded local variable limit");
2249       return;
2250     }
2251     _new_var_map[varNo] = _max_locals + _nof_refval_conflicts;
2252     _nof_refval_conflicts++;
2253   }
2254 }
2255 
2256 void GenerateOopMap::rewrite_refval_conflicts()
2257 {
2258   // We can get here two ways: Either a rewrite conflict was detected, or
2259   // an uninitialize reference was detected. In the second case, we do not
2260   // do any rewriting, we just want to recompute the reference set with the
2261   // new information
2262 
2263   int nof_conflicts = 0;              // Used for debugging only
2264 
2265   if ( _nof_refval_conflicts == 0 )
2266      return;
2267 
2268   // Check if rewrites are allowed in this parse.
2269   if (!allow_rewrites()) {
2270     fatal("Rewriting method not allowed at this stage");
2271   }
2272 
2273 
2274   // Tracing flag
2275   _did_rewriting = true;
2276 
2277   if (TraceOopMapRewrites) {
2278     tty->print_cr("ref/value conflict for method %s - bytecodes are getting rewritten", method()->name()->as_C_string());
2279     method()->print();
2280     method()->print_codes();
2281   }
2282 
2283   assert(_new_var_map!=nullptr, "nothing to rewrite");
2284   assert(_conflict==true, "We should not be here");
2285 
2286   compute_ret_adr_at_TOS();
2287   if (!_got_error) {
2288     for (int k = 0; k < _max_locals && !_got_error; k++) {
2289       if (_new_var_map[k] != k) {
2290         if (TraceOopMapRewrites) {
2291           tty->print_cr("Rewriting: %d -> %d", k, _new_var_map[k]);
2292         }
2293         rewrite_refval_conflict(k, _new_var_map[k]);
2294         if (_got_error) return;
2295         nof_conflicts++;
2296       }
2297     }
2298   }
2299 
2300   assert(nof_conflicts == _nof_refval_conflicts, "sanity check");
2301 
2302   // Adjust the number of locals
2303   method()->set_max_locals(_max_locals+_nof_refval_conflicts);
2304   _max_locals += _nof_refval_conflicts;
2305 
2306   // That was that...
2307   _new_var_map = nullptr;
2308   _nof_refval_conflicts = 0;
2309 }
2310 
2311 void GenerateOopMap::rewrite_refval_conflict(int from, int to) {
2312   bool startOver;
2313   do {
2314     // Make sure that the BytecodeStream is constructed in the loop, since
2315     // during rewriting a new method is going to be used, and the next time
2316     // around we want to use that.
2317     BytecodeStream bcs(_method);
2318     startOver = false;
2319 
2320     while( !startOver && !_got_error &&
2321            // test bcs in case method changed and it became invalid
2322            bcs.next() >=0) {
2323       startOver = rewrite_refval_conflict_inst(&bcs, from, to);
2324     }
2325   } while (startOver && !_got_error);
2326 }
2327 
2328 /* If the current instruction is one that uses local variable "from"
2329    in a ref way, change it to use "to". There's a subtle reason why we
2330    renumber the ref uses and not the non-ref uses: non-ref uses may be
2331    2 slots wide (double, long) which would necessitate keeping track of
2332    whether we should add one or two variables to the method. If the change
2333    affected the width of some instruction, returns "TRUE"; otherwise, returns "FALSE".
2334    Another reason for moving ref's value is for solving (addr, ref) conflicts, which
2335    both uses aload/astore methods.
2336 */
2337 bool GenerateOopMap::rewrite_refval_conflict_inst(BytecodeStream *itr, int from, int to) {
2338   Bytecodes::Code bc = itr->code();
2339   int index;
2340   int bci = itr->bci();
2341 
2342   if (is_aload(itr, &index) && index == from) {
2343     if (TraceOopMapRewrites) {
2344       tty->print_cr("Rewriting aload at bci: %d", bci);
2345     }
2346     return rewrite_load_or_store(itr, Bytecodes::_aload, Bytecodes::_aload_0, to);
2347   }
2348 
2349   if (is_astore(itr, &index) && index == from) {
2350     if (!stack_top_holds_ret_addr(bci)) {
2351       if (TraceOopMapRewrites) {
2352         tty->print_cr("Rewriting astore at bci: %d", bci);
2353       }
2354       return rewrite_load_or_store(itr, Bytecodes::_astore, Bytecodes::_astore_0, to);
2355     } else {
2356       if (TraceOopMapRewrites) {
2357         tty->print_cr("Suppress rewriting of astore at bci: %d", bci);
2358       }
2359     }
2360   }
2361 
2362   return false;
2363 }
2364 
2365 // The argument to this method is:
2366 // bc : Current bytecode
2367 // bcN : either _aload or _astore
2368 // bc0 : either _aload_0 or _astore_0
2369 bool GenerateOopMap::rewrite_load_or_store(BytecodeStream *bcs, Bytecodes::Code bcN, Bytecodes::Code bc0, unsigned int varNo) {
2370   assert(bcN == Bytecodes::_astore   || bcN == Bytecodes::_aload,   "wrong argument (bcN)");
2371   assert(bc0 == Bytecodes::_astore_0 || bc0 == Bytecodes::_aload_0, "wrong argument (bc0)");
2372   int ilen = Bytecodes::length_at(_method(), bcs->bcp());
2373   int newIlen;
2374 
2375   if (ilen == 4) {
2376     // Original instruction was wide; keep it wide for simplicity
2377     newIlen = 4;
2378   } else if (varNo < 4)
2379      newIlen = 1;
2380   else if (varNo >= 256)
2381      newIlen = 4;
2382   else
2383      newIlen = 2;
2384 
2385   // If we need to relocate in order to patch the byte, we
2386   // do the patching in a temp. buffer, that is passed to the reloc.
2387   // The patching of the bytecode stream is then done by the Relocator.
2388   // This is necessary, since relocating the instruction at a certain bci, might
2389   // also relocate that instruction, e.g., if a _goto before it gets widen to a _goto_w.
2390   // Hence, we do not know which bci to patch after relocation.
2391 
2392   assert(newIlen <= 4, "sanity check");
2393   u_char inst_buffer[4]; // Max. instruction size is 4.
2394   address bcp;
2395 
2396   if (newIlen != ilen) {
2397     // Relocation needed do patching in temp. buffer
2398     bcp = (address)inst_buffer;
2399   } else {
2400     bcp = _method->bcp_from(bcs->bci());
2401   }
2402 
2403   // Patch either directly in Method* or in temp. buffer
2404   if (newIlen == 1) {
2405     assert(varNo < 4, "varNo too large");
2406     *bcp = (u1)(bc0 + varNo);
2407   } else if (newIlen == 2) {
2408     assert(varNo < 256, "2-byte index needed!");
2409     *(bcp + 0) = bcN;
2410     *(bcp + 1) = (u1)varNo;
2411   } else {
2412     assert(newIlen == 4, "Wrong instruction length");
2413     *(bcp + 0) = Bytecodes::_wide;
2414     *(bcp + 1) = bcN;
2415     Bytes::put_Java_u2(bcp+2, (u2)varNo);
2416   }
2417 
2418   if (newIlen != ilen) {
2419     expand_current_instr(bcs->bci(), ilen, newIlen, inst_buffer);
2420   }
2421 
2422 
2423   return (newIlen != ilen);
2424 }
2425 
2426 class RelocCallback : public RelocatorListener {
2427  private:
2428   GenerateOopMap* _gom;
2429  public:
2430    RelocCallback(GenerateOopMap* gom) { _gom = gom; };
2431 
2432   // Callback method
2433   virtual void relocated(int bci, int delta, int new_code_length) {
2434     _gom->update_basic_blocks  (bci, delta, new_code_length);
2435     _gom->update_ret_adr_at_TOS(bci, delta);
2436     _gom->_rt.update_ret_table (bci, delta);
2437   }
2438 };
2439 
2440 // Returns true if expanding was successful. Otherwise, reports an error and
2441 // returns false.
2442 void GenerateOopMap::expand_current_instr(int bci, int ilen, int newIlen, u_char inst_buffer[]) {
2443   JavaThread* THREAD = JavaThread::current(); // For exception macros.
2444   RelocCallback rcb(this);
2445   Relocator rc(_method, &rcb);
2446   methodHandle m= rc.insert_space_at(bci, newIlen, inst_buffer, THREAD);
2447   if (m.is_null() || HAS_PENDING_EXCEPTION) {
2448     report_error("could not rewrite method - exception occurred or bytecode buffer overflow");
2449     return;
2450   }
2451 
2452   // Relocator returns a new method.
2453   _did_relocation = true;
2454   _method = m;
2455 }
2456 
2457 
2458 bool GenerateOopMap::is_astore(BytecodeStream *itr, int *index) {
2459   Bytecodes::Code bc = itr->code();
2460   switch(bc) {
2461     case Bytecodes::_astore_0:
2462     case Bytecodes::_astore_1:
2463     case Bytecodes::_astore_2:
2464     case Bytecodes::_astore_3:
2465       *index = bc - Bytecodes::_astore_0;
2466       return true;
2467     case Bytecodes::_astore:
2468       *index = itr->get_index();
2469       return true;
2470     default:
2471       return false;
2472   }
2473 }
2474 
2475 bool GenerateOopMap::is_aload(BytecodeStream *itr, int *index) {
2476   Bytecodes::Code bc = itr->code();
2477   switch(bc) {
2478     case Bytecodes::_aload_0:
2479     case Bytecodes::_aload_1:
2480     case Bytecodes::_aload_2:
2481     case Bytecodes::_aload_3:
2482       *index = bc - Bytecodes::_aload_0;
2483       return true;
2484 
2485     case Bytecodes::_aload:
2486       *index = itr->get_index();
2487       return true;
2488 
2489     default:
2490       return false;
2491   }
2492 }
2493 
2494 
2495 // Return true iff the top of the operand stack holds a return address at
2496 // the current instruction
2497 bool GenerateOopMap::stack_top_holds_ret_addr(int bci) {
2498   for(int i = 0; i < _ret_adr_tos->length(); i++) {
2499     if (_ret_adr_tos->at(i) == bci)
2500       return true;
2501   }
2502 
2503   return false;
2504 }
2505 
2506 void GenerateOopMap::compute_ret_adr_at_TOS() {
2507   assert(_ret_adr_tos != nullptr, "must be initialized");
2508   _ret_adr_tos->clear();
2509 
2510   for (int i = 0; i < bb_count(); i++) {
2511     BasicBlock* bb = &_basic_blocks[i];
2512 
2513     // Make sure to only check basicblocks that are reachable
2514     if (bb->is_reachable()) {
2515 
2516       // For each Basic block we check all instructions
2517       BytecodeStream bcs(_method);
2518       bcs.set_interval(bb->_bci, next_bb_start_pc(bb));
2519 
2520       restore_state(bb);
2521 
2522       while (bcs.next()>=0 && !_got_error) {
2523         // TDT: should this be is_good_address() ?
2524         if (_stack_top > 0 && stack()[_stack_top-1].is_address()) {
2525           _ret_adr_tos->append(bcs.bci());
2526           if (TraceNewOopMapGeneration) {
2527             tty->print_cr("Ret_adr TOS at bci: %d", bcs.bci());
2528           }
2529         }
2530         interp1(&bcs);
2531       }
2532     }
2533   }
2534 }
2535 
2536 void GenerateOopMap::update_ret_adr_at_TOS(int bci, int delta) {
2537   for(int i = 0; i < _ret_adr_tos->length(); i++) {
2538     int v = _ret_adr_tos->at(i);
2539     if (v > bci)  _ret_adr_tos->at_put(i, v + delta);
2540   }
2541 }
2542 
2543 // ===================================================================
2544 
2545 #ifndef PRODUCT
2546 int ResolveOopMapConflicts::_nof_invocations  = 0;
2547 int ResolveOopMapConflicts::_nof_rewrites     = 0;
2548 int ResolveOopMapConflicts::_nof_relocations  = 0;
2549 #endif
2550 
2551 methodHandle ResolveOopMapConflicts::do_potential_rewrite(TRAPS) {
2552   if (!compute_map(THREAD)) {
2553     THROW_HANDLE_(exception(), methodHandle());
2554   }
2555 
2556 #ifndef PRODUCT
2557   // Tracking and statistics
2558   if (PrintRewrites) {
2559     _nof_invocations++;
2560     if (did_rewriting()) {
2561       _nof_rewrites++;
2562       if (did_relocation()) _nof_relocations++;
2563       tty->print("Method was rewritten %s: ", (did_relocation()) ? "and relocated" : "");
2564       method()->print_value(); tty->cr();
2565       tty->print_cr("Cand.: %d rewrts: %d (%d%%) reloc.: %d (%d%%)",
2566           _nof_invocations,
2567           _nof_rewrites,    (_nof_rewrites    * 100) / _nof_invocations,
2568           _nof_relocations, (_nof_relocations * 100) / _nof_invocations);
2569     }
2570   }
2571 #endif
2572   return methodHandle(THREAD, method());
2573 }