/*
 * Copyright (c) 2017, 2018, Oracle and/or its affiliates. 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 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 "classfile/classLoaderDataGraph.hpp"
#include "jfr/leakprofiler/utilities/saveRestore.hpp"
#include "oops/oop.inline.hpp"

MarkOopContext::MarkOopContext() : _obj(NULL), _mark_oop(NULL) {}

MarkOopContext::MarkOopContext(const oop obj) : _obj(obj), _mark_oop(obj->mark()) {
  assert(_obj->mark() == _mark_oop, "invariant");
  // now we will "poison" the mark word of the object
  // to the intermediate monitor INFLATING state.
  // This is an "impossible" state during a safepoint,
  // hence we will use it to quickly identify objects
  // during the reachability search from gc roots.
  assert(NULL == markOopDesc::INFLATING(), "invariant");
  _obj->set_mark(markOopDesc::INFLATING());
  assert(NULL == obj->mark(), "invariant");
}

MarkOopContext::~MarkOopContext() {
  if (_obj != NULL) {
    _obj->set_mark(_mark_oop);
    assert(_obj->mark() == _mark_oop, "invariant");
  }
}

MarkOopContext::MarkOopContext(const MarkOopContext& rhs) : _obj(NULL), _mark_oop(NULL) {
  swap(const_cast<MarkOopContext&>(rhs));
}

void MarkOopContext::operator=(MarkOopContext rhs) {
  swap(rhs);
}

void MarkOopContext::swap(MarkOopContext& rhs) {
  oop temp_obj = rhs._obj;
  markOop temp_mark_oop = rhs._mark_oop;
  rhs._obj = _obj;
  rhs._mark_oop = _mark_oop;
  _obj = temp_obj;
  _mark_oop = temp_mark_oop;
}

CLDClaimContext::CLDClaimContext() : _cld(NULL) {}

CLDClaimContext::CLDClaimContext(ClassLoaderData* cld) : _cld(cld) {
  assert(_cld->claimed(), "invariant");
  _cld->clear_claim();
}

CLDClaimContext::~CLDClaimContext() {
  if (_cld != NULL) {
    _cld->try_claim(ClassLoaderData::_claim_strong);
    assert(_cld->claimed(), "invariant");
  }
}

CLDClaimContext::CLDClaimContext(const CLDClaimContext& rhs) : _cld(NULL) {
  swap(const_cast<CLDClaimContext&>(rhs));
}

void CLDClaimContext::operator=(CLDClaimContext rhs) {
  swap(rhs);
}

void CLDClaimContext::swap(CLDClaimContext& rhs) {
  ClassLoaderData* temp_cld = rhs._cld;
  rhs._cld = _cld;
  _cld = temp_cld;
}

CLDClaimStateClosure::CLDClaimStateClosure() : CLDClosure(), _state() {}

void CLDClaimStateClosure::do_cld(ClassLoaderData* cld) {
  assert(cld != NULL, "invariant");
  if (cld->claimed()) {
    _state.save(cld);
  }
}

SaveRestoreCLDClaimBits::SaveRestoreCLDClaimBits() : _claim_state_closure() {
  ClassLoaderDataGraph::cld_do(&_claim_state_closure);
}

SaveRestoreCLDClaimBits::~SaveRestoreCLDClaimBits() {
  ClassLoaderDataGraph::clear_claimed_marks();
}