/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#include "precompiled.hpp"

#include "code/codeBlob.hpp"

#include "code/codeCache.hpp"

#include "code/compiledIC.hpp"

#include "code/dependencies.hpp"

#include "code/icBuffer.hpp"

#include "code/nmethod.hpp"

#include "code/pcDesc.hpp"

#include "compiler/compileBroker.hpp"

#include "gc_implementation/shared/markSweep.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/gcLocker.hpp"

#include "memory/iterator.hpp"

#include "memory/resourceArea.hpp"

#include "oops/method.hpp"

#include "oops/objArrayOop.hpp"

#include "oops/oop.inline.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/arguments.hpp"

#include "runtime/icache.hpp"

#include "runtime/java.hpp"

#include "runtime/mutexLocker.hpp"

#include "services/memoryService.hpp"

#include "utilities/xmlstream.hpp"

// Helper class for printing in CodeCache

class CodeBlob_sizes {

 private:

  int count;

  int total_size;

  int header_size;

  int code_size;

  int stub_size;

  int relocation_size;

  int scopes_oop_size;

  int scopes_metadata_size;

  int scopes_data_size;

  int scopes_pcs_size;

 public:

  CodeBlob_sizes() {

    count            = 0;

    total_size       = 0;

    header_size      = 0;

    code_size        = 0;

    stub_size        = 0;

    relocation_size  = 0;

    scopes_oop_size  = 0;

    scopes_metadata_size  = 0;

    scopes_data_size = 0;

    scopes_pcs_size  = 0;

  }

  int total()                                    { return total_size; }

  bool is_empty()                                { return count == 0; }

  void print(const char* title) {

    tty->print_cr(" #%d %s = %dK (hdr %d%%,  loc %d%%, code %d%%, stub %d%%, [oops %d%%, data %d%%, pcs %d%%])",

                  count,

                  title,

                  total() / K,

                  header_size             * 100 / total_size,

                  relocation_size         * 100 / total_size,

                  code_size               * 100 / total_size,

                  stub_size               * 100 / total_size,

                  scopes_oop_size         * 100 / total_size,

                  scopes_metadata_size    * 100 / total_size,

                  scopes_data_size        * 100 / total_size,

                  scopes_pcs_size         * 100 / total_size);

  }

  void add(CodeBlob* cb) {

    count++;

    total_size       += cb->size();

    header_size      += cb->header_size();

    relocation_size  += cb->relocation_size();

    if (cb->is_nmethod()) {

      nmethod* nm = cb->as_nmethod_or_null();

      code_size        += nm->insts_size();

      stub_size        += nm->stub_size();

      scopes_oop_size  += nm->oops_size();

      scopes_metadata_size  += nm->metadata_size();

      scopes_data_size += nm->scopes_data_size();

      scopes_pcs_size  += nm->scopes_pcs_size();

    } else {

      code_size        += cb->code_size();

    }

  }

};

// CodeCache implementation

CodeHeap * CodeCache::_heap = new CodeHeap();

int CodeCache::_number_of_blobs = 0;

int CodeCache::_number_of_adapters = 0;

int CodeCache::_number_of_nmethods = 0;

int CodeCache::_number_of_nmethods_with_dependencies = 0;

bool CodeCache::_needs_cache_clean = false;

nmethod* CodeCache::_scavenge_root_nmethods = NULL;

nmethod* CodeCache::_saved_nmethods = NULL;

CodeBlob* CodeCache::first() {

  assert_locked_or_safepoint(CodeCache_lock);

  return (CodeBlob*)_heap->first();

}

CodeBlob* CodeCache::next(CodeBlob* cb) {

  assert_locked_or_safepoint(CodeCache_lock);

  return (CodeBlob*)_heap->next(cb);

}

CodeBlob* CodeCache::alive(CodeBlob *cb) {

  assert_locked_or_safepoint(CodeCache_lock);

  while (cb != NULL && !cb->is_alive()) cb = next(cb);

  return cb;

}

nmethod* CodeCache::alive_nmethod(CodeBlob* cb) {

  assert_locked_or_safepoint(CodeCache_lock);

  while (cb != NULL && (!cb->is_alive() || !cb->is_nmethod())) cb = next(cb);

  return (nmethod*)cb;

}

nmethod* CodeCache::first_nmethod() {

  assert_locked_or_safepoint(CodeCache_lock);

  CodeBlob* cb = first();

  while (cb != NULL && !cb->is_nmethod()) {

    cb = next(cb);

  }

  return (nmethod*)cb;

}

nmethod* CodeCache::next_nmethod (CodeBlob* cb) {

  assert_locked_or_safepoint(CodeCache_lock);

  cb = next(cb);

  while (cb != NULL && !cb->is_nmethod()) {

    cb = next(cb);

  }

  return (nmethod*)cb;

}

static size_t maxCodeCacheUsed = 0;

CodeBlob* CodeCache::allocate(int size, bool is_critical) {

  // Do not seize the CodeCache lock here--if the caller has not

  // already done so, we are going to lose bigtime, since the code

  // cache will contain a garbage CodeBlob until the caller can

  // run the constructor for the CodeBlob subclass he is busy

  // instantiating.

  guarantee(size >= 0, "allocation request must be reasonable");

  assert_locked_or_safepoint(CodeCache_lock);

  CodeBlob* cb = NULL;

  _number_of_blobs++;

  while (true) {

    cb = (CodeBlob*)_heap->allocate(size, is_critical);

    if (cb != NULL) break;

    if (!_heap->expand_by(CodeCacheExpansionSize)) {

      // Expansion failed

      return NULL;

    }

    if (PrintCodeCacheExtension) {

      ResourceMark rm;

      tty->print_cr("code cache extended to [" INTPTR_FORMAT ", " INTPTR_FORMAT "] (%d bytes)",

                    (intptr_t)_heap->low_boundary(), (intptr_t)_heap->high(),

                    (address)_heap->high() - (address)_heap->low_boundary());

    }

  }

  maxCodeCacheUsed = MAX2(maxCodeCacheUsed, ((address)_heap->high_boundary() -

                          (address)_heap->low_boundary()) - unallocated_capacity());

  verify_if_often();

  print_trace("allocation", cb, size);

  return cb;

}

void CodeCache::free(CodeBlob* cb) {

  assert_locked_or_safepoint(CodeCache_lock);

  verify_if_often();

  print_trace("free", cb);

  if (cb->is_nmethod()) {

    _number_of_nmethods--;

    if (((nmethod *)cb)->has_dependencies()) {

      _number_of_nmethods_with_dependencies--;

    }

  }

  if (cb->is_adapter_blob()) {

    _number_of_adapters--;

  }

  _number_of_blobs--;

  _heap->deallocate(cb);

  verify_if_often();

  assert(_number_of_blobs >= 0, "sanity check");

}

void CodeCache::commit(CodeBlob* cb) {

  // this is called by nmethod::nmethod, which must already own CodeCache_lock

  assert_locked_or_safepoint(CodeCache_lock);

  if (cb->is_nmethod()) {

    _number_of_nmethods++;

    if (((nmethod *)cb)->has_dependencies()) {

      _number_of_nmethods_with_dependencies++;

    }

  }

  if (cb->is_adapter_blob()) {

    _number_of_adapters++;

  }

  // flush the hardware I-cache

  ICache::invalidate_range(cb->content_begin(), cb->content_size());

}

void CodeCache::flush() {

  assert_locked_or_safepoint(CodeCache_lock);

  Unimplemented();

}

// Iteration over CodeBlobs

#define FOR_ALL_BLOBS(var)       for (CodeBlob *var =       first() ; var != NULL; var =       next(var) )

#define FOR_ALL_ALIVE_BLOBS(var) for (CodeBlob *var = alive(first()); var != NULL; var = alive(next(var)))

#define FOR_ALL_ALIVE_NMETHODS(var) for (nmethod *var = alive_nmethod(first()); var != NULL; var = alive_nmethod(next(var)))

bool CodeCache::contains(void *p) {

  // It should be ok to call contains without holding a lock

  return _heap->contains(p);

}

// This method is safe to call without holding the CodeCache_lock, as long as a dead codeblob is not

// looked up (i.e., one that has been marked for deletion). It only dependes on the _segmap to contain

// valid indices, which it will always do, as long as the CodeBlob is not in the process of being recycled.

CodeBlob* CodeCache::find_blob(void* start) {

  CodeBlob* result = find_blob_unsafe(start);

  if (result == NULL) return NULL;

  // We could potientially look up non_entrant methods

  guarantee(!result->is_zombie() || result->is_locked_by_vm() || is_error_reported(), "unsafe access to zombie method");

  return result;

}

nmethod* CodeCache::find_nmethod(void* start) {

  CodeBlob *cb = find_blob(start);

  assert(cb == NULL || cb->is_nmethod(), "did not find an nmethod");

  return (nmethod*)cb;

}

void CodeCache::blobs_do(void f(CodeBlob* nm)) {

  assert_locked_or_safepoint(CodeCache_lock);

  FOR_ALL_BLOBS(p) {

    f(p);

  }

}

void CodeCache::nmethods_do(void f(nmethod* nm)) {

  assert_locked_or_safepoint(CodeCache_lock);

  FOR_ALL_BLOBS(nm) {

    if (nm->is_nmethod()) f((nmethod*)nm);

  }

}

void CodeCache::alive_nmethods_do(void f(nmethod* nm)) {

  assert_locked_or_safepoint(CodeCache_lock);

  FOR_ALL_ALIVE_NMETHODS(nm) {

    f(nm);

  }

}

int CodeCache::alignment_unit() {

  return (int)_heap->alignment_unit();

}

int CodeCache::alignment_offset() {

  return (int)_heap->alignment_offset();

}

// Mark nmethods for unloading if they contain otherwise unreachable

// oops.

void CodeCache::do_unloading(BoolObjectClosure* is_alive, bool unloading_occurred) {

  assert_locked_or_safepoint(CodeCache_lock);

  FOR_ALL_ALIVE_NMETHODS(nm) {

    nm->do_unloading(is_alive, unloading_occurred);

  }

}

void CodeCache::blobs_do(CodeBlobClosure* f) {

  assert_locked_or_safepoint(CodeCache_lock);

  FOR_ALL_ALIVE_BLOBS(cb) {

    f->do_code_blob(cb);

#ifdef ASSERT

    if (cb->is_nmethod())

      ((nmethod*)cb)->verify_scavenge_root_oops();

#endif //ASSERT

  }

}

// Walk the list of methods which might contain non-perm oops.

void CodeCache::scavenge_root_nmethods_do(CodeBlobClosure* f) {

  assert_locked_or_safepoint(CodeCache_lock);

  debug_only(mark_scavenge_root_nmethods());

  for (nmethod* cur = scavenge_root_nmethods(); cur != NULL; cur = cur->scavenge_root_link()) {

    debug_only(cur->clear_scavenge_root_marked());

    assert(cur->scavenge_root_not_marked(), "");

    assert(cur->on_scavenge_root_list(), "else shouldn't be on this list");

    bool is_live = (!cur->is_zombie() && !cur->is_unloaded());

#ifndef PRODUCT

    if (TraceScavenge) {

      cur->print_on(tty, is_live ? "scavenge root" : "dead scavenge root"); tty->cr();

    }

#endif //PRODUCT

    if (is_live) {

      // Perform cur->oops_do(f), maybe just once per nmethod.

      f->do_code_blob(cur);

    }

  }

  // Check for stray marks.

  debug_only(verify_perm_nmethods(NULL));

}

void CodeCache::add_scavenge_root_nmethod(nmethod* nm) {

  assert_locked_or_safepoint(CodeCache_lock);

  nm->set_on_scavenge_root_list();

  nm->set_scavenge_root_link(_scavenge_root_nmethods);

  set_scavenge_root_nmethods(nm);

  print_trace("add_scavenge_root", nm);

}

void CodeCache::drop_scavenge_root_nmethod(nmethod* nm) {

  assert_locked_or_safepoint(CodeCache_lock);

  print_trace("drop_scavenge_root", nm);

  nmethod* last = NULL;

  nmethod* cur = scavenge_root_nmethods();

  while (cur != NULL) {

    nmethod* next = cur->scavenge_root_link();

    if (cur == nm) {

      if (last != NULL)

            last->set_scavenge_root_link(next);

      else  set_scavenge_root_nmethods(next);

      nm->set_scavenge_root_link(NULL);

      nm->clear_on_scavenge_root_list();

      return;

    }

    last = cur;

    cur = next;

  }

  assert(false, "should have been on list");

}

void CodeCache::prune_scavenge_root_nmethods() {

  assert_locked_or_safepoint(CodeCache_lock);

  debug_only(mark_scavenge_root_nmethods());

  nmethod* last = NULL;

  nmethod* cur = scavenge_root_nmethods();

  while (cur != NULL) {

    nmethod* next = cur->scavenge_root_link();

    debug_only(cur->clear_scavenge_root_marked());

    assert(cur->scavenge_root_not_marked(), "");

    assert(cur->on_scavenge_root_list(), "else shouldn't be on this list");

    if (!cur->is_zombie() && !cur->is_unloaded()

        && cur->detect_scavenge_root_oops()) {

      // Keep it.  Advance 'last' to prevent deletion.

      last = cur;

    } else {

      // Prune it from the list, so we don't have to look at it any more.

      print_trace("prune_scavenge_root", cur);

      cur->set_scavenge_root_link(NULL);

      cur->clear_on_scavenge_root_list();

      if (last != NULL)

            last->set_scavenge_root_link(next);

      else  set_scavenge_root_nmethods(next);

    }

    cur = next;

  }

  // Check for stray marks.

  debug_only(verify_perm_nmethods(NULL));

}

#ifndef PRODUCT

void CodeCache::asserted_non_scavengable_nmethods_do(CodeBlobClosure* f) {

  // While we are here, verify the integrity of the list.

  mark_scavenge_root_nmethods();

  for (nmethod* cur = scavenge_root_nmethods(); cur != NULL; cur = cur->scavenge_root_link()) {

    assert(cur->on_scavenge_root_list(), "else shouldn't be on this list");

    cur->clear_scavenge_root_marked();

  }

  verify_perm_nmethods(f);

}

// Temporarily mark nmethods that are claimed to be on the non-perm list.

void CodeCache::mark_scavenge_root_nmethods() {

  FOR_ALL_ALIVE_BLOBS(cb) {

    if (cb->is_nmethod()) {

      nmethod *nm = (nmethod*)cb;

      assert(nm->scavenge_root_not_marked(), "clean state");

      if (nm->on_scavenge_root_list())

        nm->set_scavenge_root_marked();

    }

  }

}

// If the closure is given, run it on the unlisted nmethods.

// Also make sure that the effects of mark_scavenge_root_nmethods is gone.

void CodeCache::verify_perm_nmethods(CodeBlobClosure* f_or_null) {

  FOR_ALL_ALIVE_BLOBS(cb) {

    bool call_f = (f_or_null != NULL);

    if (cb->is_nmethod()) {

      nmethod *nm = (nmethod*)cb;

      assert(nm->scavenge_root_not_marked(), "must be already processed");

      if (nm->on_scavenge_root_list())

        call_f = false;  // don't show this one to the client

      nm->verify_scavenge_root_oops();

    } else {

      call_f = false;   // not an nmethod

    }

    if (call_f)  f_or_null->do_code_blob(cb);

  }

}

#endif //PRODUCT

/**

 * Remove and return nmethod from the saved code list in order to reanimate it.

 */

nmethod* CodeCache::reanimate_saved_code(Method* m) {

  MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

  nmethod* saved = _saved_nmethods;

  nmethod* prev = NULL;

  while (saved != NULL) {

    if (saved->is_in_use() && saved->method() == m) {

      if (prev != NULL) {

        prev->set_saved_nmethod_link(saved->saved_nmethod_link());

      } else {

        _saved_nmethods = saved->saved_nmethod_link();

      }

      assert(saved->is_speculatively_disconnected(), "shouldn't call for other nmethods");

      saved->set_speculatively_disconnected(false);

      saved->set_saved_nmethod_link(NULL);

      if (PrintMethodFlushing) {

        saved->print_on(tty, " ### nmethod is reconnected");

      }

      if (LogCompilation && (xtty != NULL)) {

        ttyLocker ttyl;

        xtty->begin_elem("nmethod_reconnected compile_id='%3d'", saved->compile_id());

        xtty->method(m);

        xtty->stamp();

        xtty->end_elem();

      }

      return saved;

    }

    prev = saved;

    saved = saved->saved_nmethod_link();

  }

  return NULL;

}

/**

 * Remove nmethod from the saved code list in order to discard it permanently

 */

void CodeCache::remove_saved_code(nmethod* nm) {