/*

 * 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.

 *

 */

// 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.

//

// NOTE THAT the algorithm in StringTable::hash_string() MUST MATCH the

// algorithm in java.lang.String.hashCode().

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()) {

        int hash;

        typeArrayOop value = java_lang_String::value(obj);

        int length = java_lang_String::length(obj);

        if (length == 0) {

          hash = 0;

        } else {

          int offset = java_lang_String::offset(obj);

          jchar* s = value->char_at_addr(offset);

          hash = StringTable::hash_string(s, length);

        }

        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;

}

// 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, excluding symbols

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:  mark common symbols

class MarkCommonSymbols : public ObjectClosure {

private:

  MarkObjectsOopClosure mark_all;

public:

  void do_object(oop obj) {

    // Mark symbols refered to by method objects.

    if (obj->is_method()) {

      methodOop m = methodOop(obj);

      mark_object(m->name());

      mark_object(m->signature());

    }

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

    else if (obj->is_klass()) {

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

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

        mark_object(ik->name());

        mark_object(ik->generic_signature());

        mark_object(ik->source_file_name());

        mark_object(ik->source_debug_extension());

        typeArrayOop inner_classes = ik->inner_classes();

        if (inner_classes != NULL) {

          int length = inner_classes->length();

          for (int i = 0;

                   i < length;

                   i += instanceKlass::inner_class_next_offset) {

            int ioff = i + instanceKlass::inner_class_inner_name_offset;

            int index = inner_classes->ushort_at(ioff);

            if (index != 0) {

              mark_object(ik->constants()->symbol_at(index));

            }

          }

        }

        ik->field_names_and_sigs_iterate(&mark_all);

      }

    }

    // Mark symbols referenced by other constantpool entries.

    if (obj->is_constantPool()) {

      constantPoolOop(obj)->shared_symbols_iterate(&mark_all);

    }

  }

};

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

        if (_read_only) {

          warning("\nThe permanent generation read only space is not large "

                  "enough to \npreload requested classes.  Use "

                  "-XX:SharedReadOnlySize= to increase \nthe initial "

                  "size of the read only space.\n");

        } else {

          warning("\nThe permanent generation read write space is not large "

                  "enough to \npreload requested classes.  Use "

                  "-XX:SharedReadWriteSize= to increase \nthe initial "

                  "size of the read write space.\n");

        }

        exit(2);

      }

      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;

      mark_and_move_for_policy(OP_favor_startup, ik->name(), _move_ro);

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

        mark_and_move_for_policy(OP_favor_startup, k->klass_part()->name(), _move_ro);

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

        // We don't move the name symbolOop here because it may invalidate

        // method ordering, which is dependent on the address of the name

        // symbolOop.  It will get promoted later with the other symbols.

        // Method name is rarely accessed during classloading anyway.

        // mark_and_move_for_policy(OP_balanced, m->name(), _move_ro);

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

      }

      mark_and_move_for_policy(OP_favor_startup, ik->transitive_interfaces(), _move_ro);

      mark_and_move_for_policy(OP_favor_startup, ik->fields(), _move_ro);

      mark_and_move_for_policy(OP_favor_runtime, ik->secondary_supers(),  _move_ro);

      mark_and_move_for_policy(OP_favor_runtime, ik->method_ordering(),   _move_ro);

      mark_and_move_for_policy(OP_favor_runtime, ik->class_annotations(), _move_ro);

      mark_and_move_for_policy(OP_favor_runtime, ik->fields_annotations(), _move_ro);

      mark_and_move_for_policy(OP_favor_runtime, ik->methods_annotations(), _move_ro);

      mark_and_move_for_policy(OP_favor_runtime, ik->methods_parameter_annotations(), _move_ro);

      mark_and_move_for_policy(OP_favor_runtime, ik->methods_default_annotations(), _move_ro);

      mark_and_move_for_policy(OP_favor_runtime, ik->inner_classes(), _move_ro);

      mark_and_move_for_policy(OP_favor_runtime, ik->secondary_supers(), _move_ro);

    }

  }

};

class MarkAndMoveOrderedReadWrite: public ObjectClosure {

private:

  MoveMarkedObjects *_move_rw;

public:

  MarkAndMoveOrderedReadWrite(MoveMarkedObjects *move_rw) : _move_rw(move_rw) {}

  void do_object(oop obj) {

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

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

      int i;

      mark_and_move_for_policy(OP_favor_startup, ik->as_klassOop(), _move_rw);

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

        do_object(ik->super());

      }

      objArrayOop interfaces = ik->local_interfaces();