/*

 * Copyright (c) 2003, 2012, 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/javaClasses.hpp"

#include "classfile/loaderConstraints.hpp"

#include "classfile/symbolTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "gc_implementation/shared/spaceDecorator.hpp"

#include "memory/classify.hpp"

#include "memory/filemap.hpp"

#include "memory/oopFactory.hpp"

#include "memory/resourceArea.hpp"

#include "oops/methodDataOop.hpp"

#include "oops/oop.inline.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/signature.hpp"

#include "runtime/vmThread.hpp"

#include "runtime/vm_operations.hpp"

#include "utilities/copy.hpp"

// Closure to set up the fingerprint field for all methods.

class FingerprintMethodsClosure: public ObjectClosure {

public:

  void do_object(oop obj) {

    if (obj->is_method()) {

      methodOop mobj = (methodOop)obj;

      ResourceMark rm;

      (new Fingerprinter(mobj))->fingerprint();

    }

  }

};

// Closure to set the hash value (String.hash field) in all of the

// String objects in the heap.  Setting the hash value is not required.

// However, setting the value in advance prevents the value from being

// written later, increasing the likelihood that the shared page contain

// the hash can be shared.

//

class StringHashCodeClosure: public OopClosure {

private:

  Thread* THREAD;

  int hash_offset;

public:

  StringHashCodeClosure(Thread* t) {

    THREAD = t;

    hash_offset = java_lang_String::hash_offset_in_bytes();

  }

  void do_oop(oop* p) {

    if (p != NULL) {

      oop obj = *p;

      if (obj->klass() == SystemDictionary::String_klass() &&

          java_lang_String::has_hash_field()) {

        obj->int_field_put(hash_offset, hash);

      }

    }

  }

  void do_oop(narrowOop* p) { ShouldNotReachHere(); }

};

// Remove data from objects which should not appear in the shared file

// (as it pertains only to the current JVM).

class RemoveUnshareableInfoClosure : public ObjectClosure {

public:

  void do_object(oop obj) {

    // Zap data from the objects which is pertains only to this JVM.  We

    // want that data recreated in new JVMs when the shared file is used.

    if (obj->is_method()) {

      ((methodOop)obj)->remove_unshareable_info();

    }

    else if (obj->is_klass()) {

      Klass::cast((klassOop)obj)->remove_unshareable_info();

    }

    // Don't save compiler related special oops (shouldn't be any yet).

    if (obj->is_methodData() || obj->is_compiledICHolder()) {

      ShouldNotReachHere();

    }

  }

};

static bool mark_object(oop obj) {

  if (obj != NULL &&

      !obj->is_shared() &&

      !obj->is_forwarded() &&

      !obj->is_gc_marked()) {

    obj->set_mark(markOopDesc::prototype()->set_marked());

    return true;

  }

  return false;

}

class MoveSymbols : public SymbolClosure {

private:

  char* _start;

  char* _end;

  char* _top;

  int _count;

  bool in_shared_space(Symbol* sym) const {

    return (char*)sym >= _start && (char*)sym < _end;

  }

  Symbol* get_shared_copy(Symbol* sym) {

    return sym->refcount() > 0 ? NULL : (Symbol*)(_start - sym->refcount());

  }

  Symbol* make_shared_copy(Symbol* sym) {

    Symbol* new_sym = (Symbol*)_top;

    int size = sym->object_size();

    _top += size * HeapWordSize;

    if (_top <= _end) {

      Copy::disjoint_words((HeapWord*)sym, (HeapWord*)new_sym, size);

      // Encode a reference to the copy as a negative distance from _start

      // When a symbol is being copied to a shared space

      // during CDS archive creation, the original symbol is marked

      // as relocated by putting a negative value to its _refcount field,

      // This value is also used to find where exactly the shared copy is

      // (see MoveSymbols::get_shared_copy), so that the other references

      // to this symbol could be changed to point to the shared copy.

      sym->_refcount = (int)(_start - (char*)new_sym);

      // Mark the symbol in the shared archive as immortal so it is read only

      // and not refcounted.

      new_sym->_refcount = -1;

      _count++;

    } else {

      report_out_of_shared_space(SharedMiscData);

    }

    return new_sym;

  }

public:

  MoveSymbols(char* top, char* end) :

    _start(top), _end(end), _top(top), _count(0) { }

  char* get_top() const { return _top; }

  int count()     const { return _count; }

  void do_symbol(Symbol** p) {

    Symbol* sym = load_symbol(p);

    if (sym != NULL && !in_shared_space(sym)) {

      Symbol* new_sym = get_shared_copy(sym);

      if (new_sym == NULL) {

        // The symbol has not been relocated yet; copy it to _top address

        assert(sym->refcount() > 0, "should have positive reference count");

        new_sym = make_shared_copy(sym);

      }

      // Make the reference point to the shared copy of the symbol

      store_symbol(p, new_sym);

    }

  }

};

// Closure:  mark objects closure.

class MarkObjectsOopClosure : public OopClosure {

public:

  void do_oop(oop* p)       { mark_object(*p); }

  void do_oop(narrowOop* p) { ShouldNotReachHere(); }

};

class MarkObjectsSkippingKlassesOopClosure : public OopClosure {

public:

  void do_oop(oop* pobj) {

    oop obj = *pobj;

    if (obj != NULL &&

        !obj->is_klass()) {

      mark_object(obj);

    }

  }

  void do_oop(narrowOop* pobj) { ShouldNotReachHere(); }

};

static void mark_object_recursive_skipping_klasses(oop obj) {

  mark_object(obj);

  if (obj != NULL) {

    MarkObjectsSkippingKlassesOopClosure mark_all;

    obj->oop_iterate(&mark_all);

  }

}

// Closure:  mark common read-only objects

class MarkCommonReadOnly : public ObjectClosure {

private:

  MarkObjectsOopClosure mark_all;

public:

  void do_object(oop obj) {

    // Mark all constMethod objects.

    if (obj->is_constMethod()) {

      mark_object(obj);

      mark_object(constMethodOop(obj)->stackmap_data());

      // Exception tables are needed by ci code during compilation.

      mark_object(constMethodOop(obj)->exception_table());

    }

    // Mark objects referenced by klass objects which are read-only.

    else if (obj->is_klass()) {

      Klass* k = Klass::cast((klassOop)obj);

      mark_object(k->secondary_supers());

      // The METHODS() OBJARRAYS CANNOT BE MADE READ-ONLY, even though

      // it is never modified. Otherwise, they will be pre-marked; the

      // GC marking phase will skip them; and by skipping them will fail

      // to mark the methods objects referenced by the array.

      if (obj->blueprint()->oop_is_instanceKlass()) {

        instanceKlass* ik = instanceKlass::cast((klassOop)obj);

        mark_object(ik->method_ordering());

        mark_object(ik->local_interfaces());

        mark_object(ik->transitive_interfaces());

        mark_object(ik->fields());

        mark_object(ik->class_annotations());

        mark_object_recursive_skipping_klasses(ik->fields_annotations());

        mark_object_recursive_skipping_klasses(ik->methods_annotations());

        mark_object_recursive_skipping_klasses(ik->methods_parameter_annotations());

        mark_object_recursive_skipping_klasses(ik->methods_default_annotations());

        typeArrayOop inner_classes = ik->inner_classes();

        if (inner_classes != NULL) {

          mark_object(inner_classes);

        }

      }

    }

  }

};

// Closure:  find symbol references in Java Heap objects

class CommonSymbolsClosure : public ObjectClosure {

private:

  SymbolClosure* _closure;

public:

  CommonSymbolsClosure(SymbolClosure* closure) : _closure(closure) { }

  void do_object(oop obj) {

    // Traverse symbols referenced by method objects.

    if (obj->is_method()) {

      methodOop m = methodOop(obj);

      constantPoolOop constants = m->constants();

      _closure->do_symbol(constants->symbol_at_addr(m->name_index()));

      _closure->do_symbol(constants->symbol_at_addr(m->signature_index()));

    }

    // Traverse symbols referenced by klass objects which are read-only.

    else if (obj->is_klass()) {

      Klass* k = Klass::cast((klassOop)obj);

      k->shared_symbols_iterate(_closure);

      if (obj->blueprint()->oop_is_instanceKlass()) {

        instanceKlass* ik = instanceKlass::cast((klassOop)obj);

        instanceKlassHandle ik_h((klassOop)obj);

        InnerClassesIterator iter(ik_h);

        constantPoolOop constants = ik->constants();

        for (; !iter.done(); iter.next()) {

          int index = iter.inner_name_index();

          if (index != 0) {

            _closure->do_symbol(constants->symbol_at_addr(index));

          }

        }

      }

    }

    // Traverse symbols referenced by other constantpool entries.

    else if (obj->is_constantPool()) {

      constantPoolOop(obj)->shared_symbols_iterate(_closure);

    }

  }

};

// Closure:  mark char arrays used by strings

class MarkStringValues : public ObjectClosure {

private:

  MarkObjectsOopClosure mark_all;

public:

  void do_object(oop obj) {

    // Character arrays referenced by String objects are read-only.

    if (java_lang_String::is_instance(obj)) {

      mark_object(java_lang_String::value(obj));

    }

  }

};

#ifdef DEBUG

// Closure:  Check for objects left in the heap which have not been moved.

class CheckRemainingObjects : public ObjectClosure {

private:

  int count;

public:

  CheckRemainingObjects() {

    count = 0;

  }

  void do_object(oop obj) {

    if (!obj->is_shared() &&

        !obj->is_forwarded()) {

      ++count;

      if (Verbose) {

        tty->print("Unreferenced object: ");

        obj->print_on(tty);

      }

    }

  }

  void status() {

    tty->print_cr("%d objects no longer referenced, not shared.", count);

  }

};

#endif

// Closure:  Mark remaining objects read-write, except Strings.

class MarkReadWriteObjects : public ObjectClosure {

private:

  MarkObjectsOopClosure mark_objects;

public:

  void do_object(oop obj) {

      // The METHODS() OBJARRAYS CANNOT BE MADE READ-ONLY, even though

      // it is never modified. Otherwise, they will be pre-marked; the

      // GC marking phase will skip them; and by skipping them will fail

      // to mark the methods objects referenced by the array.

    if (obj->is_klass()) {

      mark_object(obj);

      Klass* k = klassOop(obj)->klass_part();

      mark_object(k->java_mirror());

      if (obj->blueprint()->oop_is_instanceKlass()) {

        instanceKlass* ik = (instanceKlass*)k;

        mark_object(ik->methods());

        mark_object(ik->constants());

      }

      if (obj->blueprint()->oop_is_javaArray()) {

        arrayKlass* ak = (arrayKlass*)k;

        mark_object(ak->component_mirror());

      }

      return;

    }

    // Mark constantPool tags and the constantPoolCache.

    else if (obj->is_constantPool()) {

      constantPoolOop pool = constantPoolOop(obj);

      mark_object(pool->cache());

      pool->shared_tags_iterate(&mark_objects);

      return;

    }

    // Mark all method objects.

    if (obj->is_method()) {

      mark_object(obj);

    }

  }

};

// Closure:  Mark String objects read-write.

class MarkStringObjects : public ObjectClosure {

private:

  MarkObjectsOopClosure mark_objects;

public:

  void do_object(oop obj) {

    // Mark String objects referenced by constant pool entries.

    if (obj->is_constantPool()) {

      constantPoolOop pool = constantPoolOop(obj);

      pool->shared_strings_iterate(&mark_objects);

      return;

    }

  }

};

// Move objects matching specified type (ie. lock_bits) to the specified

// space.

class MoveMarkedObjects : public ObjectClosure {

private:

  OffsetTableContigSpace* _space;

  bool _read_only;

public:

  MoveMarkedObjects(OffsetTableContigSpace* space, bool read_only) {

    _space = space;

    _read_only = read_only;

  }

  void do_object(oop obj) {

    if (obj->is_shared()) {

      return;

    }

    if (obj->is_gc_marked() && obj->forwardee() == NULL) {

      int s = obj->size();

      oop sh_obj = (oop)_space->allocate(s);

      if (sh_obj == NULL) {

        report_out_of_shared_space(_read_only ? SharedReadOnly : SharedReadWrite);

      }

      if (PrintSharedSpaces && Verbose && WizardMode) {

        tty->print_cr("\nMoveMarkedObjects: " PTR_FORMAT " -> " PTR_FORMAT " %s", obj, sh_obj,

                      (_read_only ? "ro" : "rw"));

      }

      Copy::aligned_disjoint_words((HeapWord*)obj, (HeapWord*)sh_obj, s);

      obj->forward_to(sh_obj);

      if (_read_only) {

        // Readonly objects: set hash value to self pointer and make gc_marked.

        sh_obj->forward_to(sh_obj);

      } else {

        sh_obj->init_mark();

      }

    }

  }

};

static void mark_and_move(oop obj, MoveMarkedObjects* move) {

  if (mark_object(obj)) move->do_object(obj);

}

enum order_policy {

  OP_favor_startup = 0,

  OP_balanced = 1,

  OP_favor_runtime = 2

};

static void mark_and_move_for_policy(order_policy policy, oop obj, MoveMarkedObjects* move) {

  if (SharedOptimizeColdStartPolicy >= policy) mark_and_move(obj, move);

}

class MarkAndMoveOrderedReadOnly : public ObjectClosure {

private:

  MoveMarkedObjects *_move_ro;

public:

  MarkAndMoveOrderedReadOnly(MoveMarkedObjects *move_ro) : _move_ro(move_ro) {}

  void do_object(oop obj) {

    if (obj->is_klass() && obj->blueprint()->oop_is_instanceKlass()) {

      instanceKlass* ik = instanceKlass::cast((klassOop)obj);

      int i;

      if (ik->super() != NULL) {

        do_object(ik->super());

      }

      objArrayOop interfaces = ik->local_interfaces();

      mark_and_move_for_policy(OP_favor_startup, interfaces, _move_ro);

      for(i = 0; i < interfaces->length(); i++) {

        klassOop k = klassOop(interfaces->obj_at(i));

        do_object(k);

      }

      objArrayOop methods = ik->methods();

      for(i = 0; i < methods->length(); i++) {

        methodOop m = methodOop(methods->obj_at(i));

        mark_and_move_for_policy(OP_favor_startup, m->constMethod(), _move_ro);

        mark_and_move_for_policy(OP_favor_runtime, m->constMethod()->exception_table(), _move_ro);

        mark_and_move_for_policy(OP_favor_runtime, m->constMethod()->stackmap_data(), _move_ro);