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