/*

 * Copyright 1997-2007 Sun Microsystems, Inc.  All Rights Reserved.

 * 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

# include "incls/_precompiled.incl"

# include "incls/_codeCache.cpp.incl"

// 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_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_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_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();

    scopes_oop_size  += cb->oops_size();

    if (cb->is_nmethod()) {

      nmethod *nm = (nmethod*)cb;

      code_size        += nm->code_size();

      stub_size        += nm->stub_size();

      scopes_data_size += nm->scopes_data_size();

      scopes_pcs_size  += nm->scopes_pcs_size();

    } else {

      code_size        += cb->instructions_size();

    }

  }

};

// CodeCache implementation

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

int CodeCache::_number_of_blobs = 0;

int CodeCache::_number_of_nmethods_with_dependencies = 0;

bool CodeCache::_needs_cache_clean = false;

nmethod* CodeCache::_scavenge_root_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;

}

CodeBlob* CodeCache::allocate(int size) {

  // 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);

    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->begin(), (intptr_t)_heap->end(),

                    (address)_heap->end() - (address)_heap->begin());

    }

  }

  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() && ((nmethod *)cb)->has_dependencies()) {

    _number_of_nmethods_with_dependencies--;

  }

  _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() && ((nmethod *)cb)->has_dependencies()) {

    _number_of_nmethods_with_dependencies++;

  }

  // flush the hardware I-cache

  ICache::invalidate_range(cb->instructions_begin(), cb->instructions_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);

  }

}

int CodeCache::alignment_unit() {

  return (int)_heap->alignment_unit();

}

int CodeCache::alignment_offset() {

  return (int)_heap->alignment_offset();

}

// Mark code blobs for unloading if they contain otherwise

// unreachable oops.

void CodeCache::do_unloading(BoolObjectClosure* is_alive,

                             OopClosure* keep_alive,

                             bool unloading_occurred) {

  assert_locked_or_safepoint(CodeCache_lock);

  FOR_ALL_ALIVE_BLOBS(cb) {

    cb->do_unloading(is_alive, keep_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

void CodeCache::gc_prologue() {

  assert(!nmethod::oops_do_marking_is_active(), "oops_do_marking_epilogue must be called");

}

void CodeCache::gc_epilogue() {

  assert_locked_or_safepoint(CodeCache_lock);

  FOR_ALL_ALIVE_BLOBS(cb) {

    if (cb->is_nmethod()) {

      nmethod *nm = (nmethod*)cb;

      assert(!nm->is_unloaded(), "Tautology");

      if (needs_cache_clean()) {

        nm->cleanup_inline_caches();

      }

      debug_only(nm->verify();)

    }

    cb->fix_oop_relocations();

  }

  set_needs_cache_clean(false);

  prune_scavenge_root_nmethods();

  assert(!nmethod::oops_do_marking_is_active(), "oops_do_marking_prologue must be called");

}

address CodeCache::first_address() {

  assert_locked_or_safepoint(CodeCache_lock);

  return (address)_heap->begin();

}

address CodeCache::last_address() {

  assert_locked_or_safepoint(CodeCache_lock);

  return (address)_heap->end();

}