#include "code/icBuffer.hpp"

#include "gc/shenandoah/shenandoahCodeRoots.hpp"

#include "gc/shenandoah/shenandoahNMethod.inline.hpp"

ShenandoahNMethodTable* ShenandoahCodeRoots::_nmethod_table;

int ShenandoahCodeRoots::_disarmed_value = 1;

  _nmethod_table = new ShenandoahNMethodTable();

void ShenandoahCodeRoots::register_nmethod(nmethod* nm) {

      _nmethod_table->register_nmethod(nm);

}

void ShenandoahCodeRoots::unregister_nmethod(nmethod* nm) {

  switch (ShenandoahCodeRootsStyle) {

    case 0:

    case 1: {

      break;

    }

    case 2: {

      assert_locked_or_safepoint(CodeCache_lock);

      _nmethod_table->unregister_nmethod(nm);

      break;

    }

    default:

      ShouldNotReachHere();

  }

}

void ShenandoahCodeRoots::flush_nmethod(nmethod* nm) {

      _nmethod_table->flush_nmethod(nm);

void ShenandoahCodeRoots::prepare_concurrent_unloading() {

  assert(SafepointSynchronize::is_at_safepoint(), "Must be at a safepoint");

  _disarmed_value ++;

  // 0 is reserved for new nmethod

  if (_disarmed_value == 0) {

    _disarmed_value = 1;

  }

  JavaThreadIteratorWithHandle jtiwh;

  for (JavaThread *thr = jtiwh.next(); thr != NULL; thr = jtiwh.next()) {

    ShenandoahThreadLocalData::set_disarmed_value(thr, _disarmed_value);

  }

}

class ShenandoahNMethodUnlinkClosure : public NMethodClosure {

private:

  bool            _unloading_occurred;

  volatile bool   _failed;

  ShenandoahHeap* _heap;

  void set_failed() {

    Atomic::store(&_failed, true);

  }

   void unlink(nmethod* nm) {

     // Unlinking of the dependencies must happen before the

     // handshake separating unlink and purge.

     nm->flush_dependencies(false /* delete_immediately */);

     // unlink_from_method will take the CompiledMethod_lock.

     // In this case we don't strictly need it when unlinking nmethods from

     // the Method, because it is only concurrently unlinked by

     // the entry barrier, which acquires the per nmethod lock.

     nm->unlink_from_method();

     if (nm->is_osr_method()) {

       // Invalidate the osr nmethod only once

       nm->invalidate_osr_method();

     }

   }

public:

  ShenandoahNMethodUnlinkClosure(bool unloading_occurred) :

      _unloading_occurred(unloading_occurred),

      _failed(false),

      _heap(ShenandoahHeap::heap()) {}

  virtual void do_nmethod(nmethod* nm) {

    if (failed()) {

      return;

    }

    ShenandoahNMethod* nm_data = ShenandoahNMethod::gc_data(nm);

    assert(!nm_data->is_unregistered(), "Should not see unregistered entry");

    if (!nm->is_alive()) {

      return;

    }

    if (nm->is_unloading()) {

      ShenandoahReentrantLocker locker(nm_data->lock());

      unlink(nm);

      return;

    }

    ShenandoahReentrantLocker locker(nm_data->lock());

    // Heal oops and disarm

    ShenandoahEvacOOMScope scope;

    ShenandoahNMethod::heal_nmethod(nm);

    ShenandoahNMethod::disarm_nmethod(nm);

    // Clear compiled ICs and exception caches

    if (!nm->unload_nmethod_caches(_unloading_occurred)) {

      set_failed();

    }

  }

  bool failed() const {

    return Atomic::load(&_failed);

  }

};

class ShenandoahUnlinkTask : public AbstractGangTask {

private:

  ShenandoahNMethodUnlinkClosure      _cl;

  ICRefillVerifier*                   _verifier;

  ShenandoahConcurrentNMethodIterator _iterator;

public:

  ShenandoahUnlinkTask(bool unloading_occurred, ICRefillVerifier* verifier) :

    AbstractGangTask("ShenandoahNMethodUnlinkTask"),

    _cl(unloading_occurred),

    _verifier(verifier),

    _iterator(ShenandoahCodeRoots::table()) {

    MutexLocker mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

    _iterator.nmethods_do_begin();

  }

  ~ShenandoahUnlinkTask() {

    MutexLocker mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

    _iterator.nmethods_do_end();

  }

  virtual void work(uint worker_id) {

    ICRefillVerifierMark mark(_verifier);

    _iterator.nmethods_do(&_cl);

  }

  bool success() const {

    return !_cl.failed();

  }

};

void ShenandoahCodeRoots::unlink(WorkGang* workers, bool unloading_occurred) {

  assert(ShenandoahConcurrentRoots::should_do_concurrent_class_unloading(),

         "Only when running concurrent class unloading");

  for (;;) {

    ICRefillVerifier verifier;

    {

      ShenandoahUnlinkTask task(unloading_occurred, &verifier);

      workers->run_task(&task);

      if (task.success()) {

        return;

      }

    }

    // Cleaning failed because we ran out of transitional IC stubs,

    // so we have to refill and try again. Refilling requires taking

    // a safepoint, so we temporarily leave the suspendible thread set.

    SuspendibleThreadSetLeaver sts;

    InlineCacheBuffer::refill_ic_stubs();

  }

}

class ShenandoahNMethodPurgeClosure : public NMethodClosure {

public:

  virtual void do_nmethod(nmethod* nm) {

    if (nm->is_alive() && nm->is_unloading()) {

      nm->make_unloaded();

    }

  }

};

class ShenandoahNMethodPurgeTask : public AbstractGangTask {

private:

  ShenandoahNMethodPurgeClosure       _cl;

  ShenandoahConcurrentNMethodIterator _iterator;

public:

  ShenandoahNMethodPurgeTask() :

    AbstractGangTask("ShenandoahNMethodPurgeTask"),

    _cl(),

    _iterator(ShenandoahCodeRoots::table()) {

    MutexLocker mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

    _iterator.nmethods_do_begin();

  }

  ~ShenandoahNMethodPurgeTask() {

    MutexLocker mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

    _iterator.nmethods_do_end();

  }

  virtual void work(uint worker_id) {

    _iterator.nmethods_do(&_cl);

  }

};

void ShenandoahCodeRoots::purge(WorkGang* workers) {

  assert(ShenandoahConcurrentRoots::should_do_concurrent_class_unloading(),

         "Only when running concurrent class unloading");

  ShenandoahNMethodPurgeTask task;

  workers->run_task(&task);

}

        _table_snapshot(NULL) {

      _table_snapshot = ShenandoahCodeRoots::table()->snapshot_for_iteration();

      ShenandoahCodeRoots::table()->finish_iteration(_table_snapshot);

      _table_snapshot = NULL;

  assert(_table_snapshot != NULL, "Sanity");

  _table_snapshot->parallel_blobs_do<CSET_FILTER>(f);