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