1 /*
   2  * Copyright (c) 1997, 2015, 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/oopMapCache.hpp"
  27 #include "logging/log.hpp"
  28 #include "memory/allocation.inline.hpp"
  29 #include "memory/resourceArea.hpp"
  30 #include "oops/oop.inline.hpp"
  31 #include "runtime/handles.inline.hpp"
  32 #include "runtime/signature.hpp"
  33 
  34 class OopMapCacheEntry: private InterpreterOopMap {
  35   friend class InterpreterOopMap;
  36   friend class OopMapForCacheEntry;
  37   friend class OopMapCache;
  38   friend class VerifyClosure;
  39 
  40  protected:
  41   // Initialization
  42   void fill(methodHandle method, int bci);
  43   // fills the bit mask for native calls
  44   void fill_for_native(methodHandle method);
  45   void set_mask(CellTypeState* vars, CellTypeState* stack, int stack_top);
  46 
  47   // Deallocate bit masks and initialize fields
  48   void flush();
  49 
  50  private:
  51   void allocate_bit_mask();   // allocates the bit mask on C heap f necessary
  52   void deallocate_bit_mask(); // allocates the bit mask on C heap f necessary
  53   bool verify_mask(CellTypeState *vars, CellTypeState *stack, int max_locals, int stack_top);
  54 
  55  public:
  56   OopMapCacheEntry() : InterpreterOopMap() {
  57 #ifdef ASSERT
  58      _resource_allocate_bit_mask = false;
  59 #endif
  60   }
  61 };
  62 
  63 
  64 // Implementation of OopMapForCacheEntry
  65 // (subclass of GenerateOopMap, initializes an OopMapCacheEntry for a given method and bci)
  66 
  67 class OopMapForCacheEntry: public GenerateOopMap {
  68   OopMapCacheEntry *_entry;
  69   int               _bci;
  70   int               _stack_top;
  71 
  72   virtual bool report_results() const     { return false; }
  73   virtual bool possible_gc_point          (BytecodeStream *bcs);
  74   virtual void fill_stackmap_prolog       (int nof_gc_points);
  75   virtual void fill_stackmap_epilog       ();
  76   virtual void fill_stackmap_for_opcodes  (BytecodeStream *bcs,
  77                                            CellTypeState* vars,
  78                                            CellTypeState* stack,
  79                                            int stack_top);
  80   virtual void fill_init_vars             (GrowableArray<intptr_t> *init_vars);
  81 
  82  public:
  83   OopMapForCacheEntry(methodHandle method, int bci, OopMapCacheEntry *entry);
  84 
  85   // Computes stack map for (method,bci) and initialize entry
  86   void compute_map(TRAPS);
  87   int  size();
  88 };
  89 
  90 
  91 OopMapForCacheEntry::OopMapForCacheEntry(methodHandle method, int bci, OopMapCacheEntry* entry) : GenerateOopMap(method) {
  92   _bci       = bci;
  93   _entry     = entry;
  94   _stack_top = -1;
  95 }
  96 
  97 
  98 void OopMapForCacheEntry::compute_map(TRAPS) {
  99   assert(!method()->is_native(), "cannot compute oop map for native methods");
 100   // First check if it is a method where the stackmap is always empty
 101   if (method()->code_size() == 0 || method()->max_locals() + method()->max_stack() == 0) {
 102     _entry->set_mask_size(0);
 103   } else {
 104     ResourceMark rm;
 105     GenerateOopMap::compute_map(CATCH);
 106     result_for_basicblock(_bci);
 107   }
 108 }
 109 
 110 
 111 bool OopMapForCacheEntry::possible_gc_point(BytecodeStream *bcs) {
 112   return false; // We are not reporting any result. We call result_for_basicblock directly
 113 }
 114 
 115 
 116 void OopMapForCacheEntry::fill_stackmap_prolog(int nof_gc_points) {
 117   // Do nothing
 118 }
 119 
 120 
 121 void OopMapForCacheEntry::fill_stackmap_epilog() {
 122   // Do nothing
 123 }
 124 
 125 
 126 void OopMapForCacheEntry::fill_init_vars(GrowableArray<intptr_t> *init_vars) {
 127   // Do nothing
 128 }
 129 
 130 
 131 void OopMapForCacheEntry::fill_stackmap_for_opcodes(BytecodeStream *bcs,
 132                                                     CellTypeState* vars,
 133                                                     CellTypeState* stack,
 134                                                     int stack_top) {
 135   // Only interested in one specific bci
 136   if (bcs->bci() == _bci) {
 137     _entry->set_mask(vars, stack, stack_top);
 138     _stack_top = stack_top;
 139   }
 140 }
 141 
 142 
 143 int OopMapForCacheEntry::size() {
 144   assert(_stack_top != -1, "compute_map must be called first");
 145   return ((method()->is_static()) ? 0 : 1) + method()->max_locals() + _stack_top;
 146 }
 147 
 148 
 149 // Implementation of InterpreterOopMap and OopMapCacheEntry
 150 
 151 class VerifyClosure : public OffsetClosure {
 152  private:
 153   OopMapCacheEntry* _entry;
 154   bool              _failed;
 155 
 156  public:
 157   VerifyClosure(OopMapCacheEntry* entry)         { _entry = entry; _failed = false; }
 158   void offset_do(int offset)                     { if (!_entry->is_oop(offset)) _failed = true; }
 159   bool failed() const                            { return _failed; }
 160 };
 161 
 162 InterpreterOopMap::InterpreterOopMap() {
 163   initialize();
 164 #ifdef ASSERT
 165   _resource_allocate_bit_mask = true;
 166 #endif
 167 }
 168 
 169 InterpreterOopMap::~InterpreterOopMap() {
 170   // The expection is that the bit mask was allocated
 171   // last in this resource area.  That would make the free of the
 172   // bit_mask effective (see how FREE_RESOURCE_ARRAY does a free).
 173   // If it was not allocated last, there is not a correctness problem
 174   // but the space for the bit_mask is not freed.
 175   assert(_resource_allocate_bit_mask, "Trying to free C heap space");
 176   if (mask_size() > small_mask_limit) {
 177     FREE_RESOURCE_ARRAY(uintptr_t, _bit_mask[0], mask_word_size());
 178   }
 179 }
 180 
 181 bool InterpreterOopMap::is_empty() const {
 182   bool result = _method == NULL;
 183   assert(_method != NULL || (_bci == 0 &&
 184     (_mask_size == 0 || _mask_size == USHRT_MAX) &&
 185     _bit_mask[0] == 0), "Should be completely empty");
 186   return result;
 187 }
 188 
 189 void InterpreterOopMap::initialize() {
 190   _method    = NULL;
 191   _mask_size = USHRT_MAX;  // This value should cause a failure quickly
 192   _bci       = 0;
 193   _expression_stack_size = 0;
 194   for (int i = 0; i < N; i++) _bit_mask[i] = 0;
 195 }
 196 
 197 void InterpreterOopMap::iterate_oop(OffsetClosure* oop_closure) const {
 198   int n = number_of_entries();
 199   int word_index = 0;
 200   uintptr_t value = 0;
 201   uintptr_t mask = 0;
 202   // iterate over entries
 203   for (int i = 0; i < n; i++, mask <<= bits_per_entry) {
 204     // get current word
 205     if (mask == 0) {
 206       value = bit_mask()[word_index++];
 207       mask = 1;
 208     }
 209     // test for oop
 210     if ((value & (mask << oop_bit_number)) != 0) oop_closure->offset_do(i);
 211   }
 212 }
 213 
 214 void InterpreterOopMap::print() const {
 215   int n = number_of_entries();
 216   tty->print("oop map for ");
 217   method()->print_value();
 218   tty->print(" @ %d = [%d] { ", bci(), n);
 219   for (int i = 0; i < n; i++) {
 220     if (is_dead(i)) tty->print("%d+ ", i);
 221     else
 222     if (is_oop(i)) tty->print("%d ", i);
 223   }
 224   tty->print_cr("}");
 225 }
 226 
 227 class MaskFillerForNative: public NativeSignatureIterator {
 228  private:
 229   uintptr_t * _mask;                             // the bit mask to be filled
 230   int         _size;                             // the mask size in bits
 231 
 232   void set_one(int i) {
 233     i *= InterpreterOopMap::bits_per_entry;
 234     assert(0 <= i && i < _size, "offset out of bounds");
 235     _mask[i / BitsPerWord] |= (((uintptr_t) 1 << InterpreterOopMap::oop_bit_number) << (i % BitsPerWord));
 236   }
 237 
 238  public:
 239   void pass_int()                                { /* ignore */ }
 240   void pass_long()                               { /* ignore */ }
 241   void pass_float()                              { /* ignore */ }
 242   void pass_double()                             { /* ignore */ }
 243   void pass_object()                             { set_one(offset()); }
 244   void pass_valuetype()                          { set_one(offset()); }
 245 
 246   MaskFillerForNative(methodHandle method, uintptr_t* mask, int size) : NativeSignatureIterator(method) {
 247     _mask   = mask;
 248     _size   = size;
 249     // initialize with 0
 250     int i = (size + BitsPerWord - 1) / BitsPerWord;
 251     while (i-- > 0) _mask[i] = 0;
 252   }
 253 
 254   void generate() {
 255     NativeSignatureIterator::iterate();
 256   }
 257 };
 258 
 259 bool OopMapCacheEntry::verify_mask(CellTypeState* vars, CellTypeState* stack, int max_locals, int stack_top) {
 260   // Check mask includes map
 261   VerifyClosure blk(this);
 262   iterate_oop(&blk);
 263   if (blk.failed()) return false;
 264 
 265   // Check if map is generated correctly
 266   // (Use ?: operator to make sure all 'true' & 'false' are represented exactly the same so we can use == afterwards)
 267   if (TraceOopMapGeneration && Verbose) tty->print("Locals (%d): ", max_locals);
 268 
 269   for(int i = 0; i < max_locals; i++) {
 270     bool v1 = is_oop(i)               ? true : false;
 271     bool v2 = vars[i].is_reference() || vars[i].is_valuetype() ? true : false;
 272     assert(v1 == v2, "locals oop mask generation error");
 273     if (TraceOopMapGeneration && Verbose) tty->print("%d", v1 ? 1 : 0);
 274   }
 275 
 276   if (TraceOopMapGeneration && Verbose) { tty->cr(); tty->print("Stack (%d): ", stack_top); }
 277   for(int j = 0; j < stack_top; j++) {
 278     bool v1 = is_oop(max_locals + j)  ? true : false;
 279     bool v2 = stack[j].is_reference() || stack[j].is_valuetype( )? true : false;
 280     assert(v1 == v2, "stack oop mask generation error");
 281     if (TraceOopMapGeneration && Verbose) tty->print("%d", v1 ? 1 : 0);
 282   }
 283   if (TraceOopMapGeneration && Verbose) tty->cr();
 284   return true;
 285 }
 286 
 287 void OopMapCacheEntry::allocate_bit_mask() {
 288   if (mask_size() > small_mask_limit) {
 289     assert(_bit_mask[0] == 0, "bit mask should be new or just flushed");
 290     _bit_mask[0] = (intptr_t)
 291       NEW_C_HEAP_ARRAY(uintptr_t, mask_word_size(), mtClass);
 292   }
 293 }
 294 
 295 void OopMapCacheEntry::deallocate_bit_mask() {
 296   if (mask_size() > small_mask_limit && _bit_mask[0] != 0) {
 297     assert(!Thread::current()->resource_area()->contains((void*)_bit_mask[0]),
 298       "This bit mask should not be in the resource area");
 299     FREE_C_HEAP_ARRAY(uintptr_t, _bit_mask[0]);
 300     debug_only(_bit_mask[0] = 0;)
 301   }
 302 }
 303 
 304 
 305 void OopMapCacheEntry::fill_for_native(methodHandle mh) {
 306   assert(mh->is_native(), "method must be native method");
 307   set_mask_size(mh->size_of_parameters() * bits_per_entry);
 308   allocate_bit_mask();
 309   // fill mask for parameters
 310   MaskFillerForNative mf(mh, bit_mask(), mask_size());
 311   mf.generate();
 312 }
 313 
 314 
 315 void OopMapCacheEntry::fill(methodHandle method, int bci) {
 316   HandleMark hm;
 317   // Flush entry to deallocate an existing entry
 318   flush();
 319   set_method(method());
 320   set_bci(bci);
 321   if (method->is_native()) {
 322     // Native method activations have oops only among the parameters and one
 323     // extra oop following the parameters (the mirror for static native methods).
 324     fill_for_native(method);
 325   } else {
 326     EXCEPTION_MARK;
 327     OopMapForCacheEntry gen(method, bci, this);
 328     gen.compute_map(CATCH);
 329   }
 330 }
 331 
 332 
 333 void OopMapCacheEntry::set_mask(CellTypeState *vars, CellTypeState *stack, int stack_top) {
 334   // compute bit mask size
 335   int max_locals = method()->max_locals();
 336   int n_entries = max_locals + stack_top;
 337   set_mask_size(n_entries * bits_per_entry);
 338   allocate_bit_mask();
 339   set_expression_stack_size(stack_top);
 340 
 341   // compute bits
 342   int word_index = 0;
 343   uintptr_t value = 0;
 344   uintptr_t mask = 1;
 345 
 346   CellTypeState* cell = vars;
 347   for (int entry_index = 0; entry_index < n_entries; entry_index++, mask <<= bits_per_entry, cell++) {
 348     // store last word
 349     if (mask == 0) {
 350       bit_mask()[word_index++] = value;
 351       value = 0;
 352       mask = 1;
 353     }
 354 
 355     // switch to stack when done with locals
 356     if (entry_index == max_locals) {
 357       cell = stack;
 358     }
 359 
 360     // set oop bit
 361     // Note: the interpreter handles value types with oops too
 362     if ( cell->is_reference() || cell->is_valuetype()) {
 363       value |= (mask << oop_bit_number );
 364     }
 365 
 366     // set dead bit
 367     if (!cell->is_live()) {
 368       value |= (mask << dead_bit_number);
 369       assert(!cell->is_reference() && !cell->is_valuetype(), "dead value marked as oop");
 370     }
 371   }
 372 
 373   // make sure last word is stored
 374   bit_mask()[word_index] = value;
 375 
 376   // verify bit mask
 377   assert(verify_mask(vars, stack, max_locals, stack_top), "mask could not be verified");
 378 
 379 
 380 }
 381 
 382 void OopMapCacheEntry::flush() {
 383   deallocate_bit_mask();
 384   initialize();
 385 }
 386 
 387 
 388 // Implementation of OopMapCache
 389 
 390 #ifndef PRODUCT
 391 
 392 static long _total_memory_usage = 0;
 393 
 394 long OopMapCache::memory_usage() {
 395   return _total_memory_usage;
 396 }
 397 
 398 #endif
 399 
 400 void InterpreterOopMap::resource_copy(OopMapCacheEntry* from) {
 401   assert(_resource_allocate_bit_mask,
 402     "Should not resource allocate the _bit_mask");
 403 
 404   set_method(from->method());
 405   set_bci(from->bci());
 406   set_mask_size(from->mask_size());
 407   set_expression_stack_size(from->expression_stack_size());
 408 
 409   // Is the bit mask contained in the entry?
 410   if (from->mask_size() <= small_mask_limit) {
 411     memcpy((void *)_bit_mask, (void *)from->_bit_mask,
 412       mask_word_size() * BytesPerWord);
 413   } else {
 414     // The expectation is that this InterpreterOopMap is a recently created
 415     // and empty. It is used to get a copy of a cached entry.
 416     // If the bit mask has a value, it should be in the
 417     // resource area.
 418     assert(_bit_mask[0] == 0 ||
 419       Thread::current()->resource_area()->contains((void*)_bit_mask[0]),
 420       "The bit mask should have been allocated from a resource area");
 421     // Allocate the bit_mask from a Resource area for performance.  Allocating
 422     // from the C heap as is done for OopMapCache has a significant
 423     // performance impact.
 424     _bit_mask[0] = (uintptr_t) NEW_RESOURCE_ARRAY(uintptr_t, mask_word_size());
 425     assert(_bit_mask[0] != 0, "bit mask was not allocated");
 426     memcpy((void*) _bit_mask[0], (void*) from->_bit_mask[0],
 427       mask_word_size() * BytesPerWord);
 428   }
 429 }
 430 
 431 inline unsigned int OopMapCache::hash_value_for(const methodHandle& method, int bci) const {
 432   // We use method->code_size() rather than method->identity_hash() below since
 433   // the mark may not be present if a pointer to the method is already reversed.
 434   return   ((unsigned int) bci)
 435          ^ ((unsigned int) method->max_locals()         << 2)
 436          ^ ((unsigned int) method->code_size()          << 4)
 437          ^ ((unsigned int) method->size_of_parameters() << 6);
 438 }
 439 
 440 
 441 OopMapCache::OopMapCache() :
 442   _mut(Mutex::leaf, "An OopMapCache lock", true, Monitor::_safepoint_check_never)
 443 {
 444   _array  = NEW_C_HEAP_ARRAY(OopMapCacheEntry, _size, mtClass);
 445   // Cannot call flush for initialization, since flush
 446   // will check if memory should be deallocated
 447   for(int i = 0; i < _size; i++) _array[i].initialize();
 448   NOT_PRODUCT(_total_memory_usage += sizeof(OopMapCache) + (sizeof(OopMapCacheEntry) * _size);)
 449 }
 450 
 451 
 452 OopMapCache::~OopMapCache() {
 453   assert(_array != NULL, "sanity check");
 454   // Deallocate oop maps that are allocated out-of-line
 455   flush();
 456   // Deallocate array
 457   NOT_PRODUCT(_total_memory_usage -= sizeof(OopMapCache) + (sizeof(OopMapCacheEntry) * _size);)
 458   FREE_C_HEAP_ARRAY(OopMapCacheEntry, _array);
 459 }
 460 
 461 OopMapCacheEntry* OopMapCache::entry_at(int i) const {
 462   return &_array[i % _size];
 463 }
 464 
 465 void OopMapCache::flush() {
 466   for (int i = 0; i < _size; i++) _array[i].flush();
 467 }
 468 
 469 void OopMapCache::flush_obsolete_entries() {
 470   for (int i = 0; i < _size; i++)
 471     if (!_array[i].is_empty() && _array[i].method()->is_old()) {
 472       // Cache entry is occupied by an old redefined method and we don't want
 473       // to pin it down so flush the entry.
 474       if (log_is_enabled(Debug, redefine, class, oopmap)) {
 475         ResourceMark rm;
 476         log_debug(redefine, class, oopmap)
 477           ("flush: %s(%s): cached entry @%d",
 478            _array[i].method()->name()->as_C_string(), _array[i].method()->signature()->as_C_string(), i);
 479       }
 480       _array[i].flush();
 481     }
 482 }
 483 
 484 void OopMapCache::lookup(const methodHandle& method,
 485                          int bci,
 486                          InterpreterOopMap* entry_for) const {
 487   MutexLockerEx x(&_mut, Mutex::_no_safepoint_check_flag);
 488 
 489   OopMapCacheEntry* entry = NULL;
 490   int probe = hash_value_for(method, bci);
 491 
 492   // Search hashtable for match
 493   int i;
 494   for(i = 0; i < _probe_depth; i++) {
 495     entry = entry_at(probe + i);
 496     if (entry->match(method, bci)) {
 497       entry_for->resource_copy(entry);
 498       assert(!entry_for->is_empty(), "A non-empty oop map should be returned");
 499       return;
 500     }
 501   }
 502 
 503   if (TraceOopMapGeneration) {
 504     static int count = 0;
 505     ResourceMark rm;
 506     tty->print("%d - Computing oopmap at bci %d for ", ++count, bci);
 507     method->print_value(); tty->cr();
 508   }
 509 
 510   // Entry is not in hashtable.
 511   // Compute entry and return it
 512 
 513   if (method->should_not_be_cached()) {
 514     // It is either not safe or not a good idea to cache this Method*
 515     // at this time. We give the caller of lookup() a copy of the
 516     // interesting info via parameter entry_for, but we don't add it to
 517     // the cache. See the gory details in Method*.cpp.
 518     compute_one_oop_map(method, bci, entry_for);
 519     return;
 520   }
 521 
 522   // First search for an empty slot
 523   for(i = 0; i < _probe_depth; i++) {
 524     entry  = entry_at(probe + i);
 525     if (entry->is_empty()) {
 526       entry->fill(method, bci);
 527       entry_for->resource_copy(entry);
 528       assert(!entry_for->is_empty(), "A non-empty oop map should be returned");
 529       return;
 530     }
 531   }
 532 
 533   if (TraceOopMapGeneration) {
 534     ResourceMark rm;
 535     tty->print_cr("*** collision in oopmap cache - flushing item ***");
 536   }
 537 
 538   // No empty slot (uncommon case). Use (some approximation of a) LRU algorithm
 539   //entry_at(probe + _probe_depth - 1)->flush();
 540   //for(i = _probe_depth - 1; i > 0; i--) {
 541   //  // Coping entry[i] = entry[i-1];
 542   //  OopMapCacheEntry *to   = entry_at(probe + i);
 543   //  OopMapCacheEntry *from = entry_at(probe + i - 1);
 544   //  to->copy(from);
 545   // }
 546 
 547   assert(method->is_method(), "gaga");
 548 
 549   entry = entry_at(probe + 0);
 550   entry->fill(method, bci);
 551 
 552   // Copy the  newly cached entry to input parameter
 553   entry_for->resource_copy(entry);
 554 
 555   if (TraceOopMapGeneration) {
 556     ResourceMark rm;
 557     tty->print("Done with ");
 558     method->print_value(); tty->cr();
 559   }
 560   assert(!entry_for->is_empty(), "A non-empty oop map should be returned");
 561 
 562   return;
 563 }
 564 
 565 void OopMapCache::compute_one_oop_map(const methodHandle& method, int bci, InterpreterOopMap* entry) {
 566   // Due to the invariants above it's tricky to allocate a temporary OopMapCacheEntry on the stack
 567   OopMapCacheEntry* tmp = NEW_C_HEAP_ARRAY(OopMapCacheEntry, 1, mtClass);
 568   tmp->initialize();
 569   tmp->fill(method, bci);
 570   entry->resource_copy(tmp);
 571   FREE_C_HEAP_ARRAY(OopMapCacheEntry, tmp);
 572 }