/*

 * Copyright (c) 2019, 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 "jvm.h"

#include "classfile/classLoaderData.inline.hpp"

#include "classfile/symbolTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/systemDictionaryShared.hpp"

#include "logging/log.hpp"

#include "memory/metadataFactory.hpp"

#include "memory/metaspace.hpp"

#include "memory/metaspaceClosure.hpp"

#include "memory/metaspaceShared.hpp"

#include "memory/resourceArea.hpp"

#include "memory/dynamicArchive.hpp"

#include "oops/compressedOops.hpp"

#include "oops/objArrayKlass.hpp"

#include "prims/jvmtiRedefineClasses.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/os.inline.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/vmThread.hpp"

#include "runtime/vmOperations.hpp"

#include "utilities/bitMap.inline.hpp"

#ifndef O_BINARY       // if defined (Win32) use binary files.

#define O_BINARY 0     // otherwise do nothing.

#endif

class DynamicArchiveBuilder : ResourceObj {

  CHeapBitMap _ptrmap;

  static unsigned my_hash(const address& a) {

    return primitive_hash<address>(a);

  }

  static bool my_equals(const address& a0, const address& a1) {

    return primitive_equals<address>(a0, a1);

  }

  typedef ResourceHashtable<

      address, address,

      DynamicArchiveBuilder::my_hash,   // solaris compiler doesn't like: primitive_hash<address>

      DynamicArchiveBuilder::my_equals, // solaris compiler doesn't like: primitive_equals<address>

      16384, ResourceObj::C_HEAP> RelocationTable;

  RelocationTable _new_loc_table;

  intx _buffer_to_target_delta;

  DumpRegion* _current_dump_space;

  static size_t reserve_alignment() {

    return Metaspace::reserve_alignment();

  }

  static const int _total_dump_regions = 3;

  int _num_dump_regions_used;

public:

  void mark_pointer(address* ptr_loc) {

    if (is_in_buffer_space(ptr_loc)) {

      size_t idx = pointer_delta(ptr_loc, _alloc_bottom, sizeof(address));

      _ptrmap.set_bit(idx);

    }

  }

  DumpRegion* current_dump_space() const {

    return _current_dump_space;

  }

  bool is_in_buffer_space(address p) const {

    return (_alloc_bottom <= p && p < (address)current_dump_space()->top());

  }

  template <typename T> bool is_in_target_space(T target_obj) const {

    address buff_obj = address(target_obj) - _buffer_to_target_delta;

    return is_in_buffer_space(buff_obj);

  }

  template <typename T> bool is_in_buffer_space(T obj) const {

    return is_in_buffer_space(address(obj));

  }

  template <typename T> T to_target_no_check(T obj) const {

    return (T)(address(obj) + _buffer_to_target_delta);

  }

  template <typename T> T to_target(T obj) const {

    assert(is_in_buffer_space(obj), "must be");

    return (T)(address(obj) + _buffer_to_target_delta);

  }

  template <typename T> T get_new_loc(T obj) {

    address* pp = _new_loc_table.get((address)obj);

    if (pp == NULL) {

      // Excluded klasses are not copied

      return NULL;

    } else {

      return (T)*pp;

    }

  }

  address get_new_loc(MetaspaceClosure::Ref* ref) {

    return get_new_loc(ref->obj());

  }

  template <typename T> bool has_new_loc(T obj) {

    address* pp = _new_loc_table.get((address)obj);

    return pp != NULL;

  }

protected:

  enum FollowMode {

    make_a_copy, point_to_it, set_to_null

  };

public:

  void copy(MetaspaceClosure::Ref* ref, bool read_only) {

    int bytes = ref->size() * BytesPerWord;

    address old_obj = ref->obj();

    address new_obj = copy_impl(ref, read_only, bytes);

    assert(new_obj != NULL, "must be");

    assert(new_obj != old_obj, "must be");

    bool isnew = _new_loc_table.put(old_obj, new_obj);

    assert(isnew, "must be");

  }

  // Make a shallow copy of each eligible MetaspaceObj into the buffer.

  class ShallowCopier: public UniqueMetaspaceClosure {

    DynamicArchiveBuilder* _builder;

    bool _read_only;

  public:

    ShallowCopier(DynamicArchiveBuilder* shuffler, bool read_only)

      : _builder(shuffler), _read_only(read_only) {}

    virtual bool do_unique_ref(Ref* orig_obj, bool read_only) {

      // This method gets called on each *original* object

      // reachable from _builder->iterate_roots(). Each orig_obj is

      // called exactly once.

      FollowMode mode = _builder->follow_ref(orig_obj);

      if (mode == point_to_it) {

        if (read_only == _read_only) {

          log_debug(cds, dynamic)("ptr : " PTR_FORMAT " %s", p2i(orig_obj->obj()),

                                  MetaspaceObj::type_name(orig_obj->msotype()));

          address p = orig_obj->obj();

          bool isnew = _builder->_new_loc_table.put(p, p);

          assert(isnew, "must be");

        }

        return false;

      }

      if (mode == set_to_null) {

        log_debug(cds, dynamic)("nul : " PTR_FORMAT " %s", p2i(orig_obj->obj()),

                                MetaspaceObj::type_name(orig_obj->msotype()));

        return false;

      }

      if (read_only == _read_only) {

        // Make a shallow copy of orig_obj in a buffer (maintained

        // by copy_impl in a subclass of DynamicArchiveBuilder).

        _builder->copy(orig_obj, read_only);

      }

      return true;

    }

  };

  // Relocate all embedded pointer fields within a MetaspaceObj's shallow copy

  class ShallowCopyEmbeddedRefRelocator: public UniqueMetaspaceClosure {

    DynamicArchiveBuilder* _builder;

  public:

    ShallowCopyEmbeddedRefRelocator(DynamicArchiveBuilder* shuffler)

      : _builder(shuffler) {}

    // This method gets called on each *original* object reachable

    // from _builder->iterate_roots(). Each orig_obj is

    // called exactly once.

    virtual bool do_unique_ref(Ref* orig_ref, bool read_only) {

      FollowMode mode = _builder->follow_ref(orig_ref);

      if (mode == point_to_it) {

        // We did not make a copy of this object

        // and we have nothing to update

        assert(_builder->get_new_loc(orig_ref) == NULL ||

               _builder->get_new_loc(orig_ref) == orig_ref->obj(), "must be");

        return false;

      }

      if (mode == set_to_null) {

        // We did not make a copy of this object

        // and we have nothing to update

        assert(!_builder->has_new_loc(orig_ref->obj()), "must not be copied or pointed to");

        return false;

      }

      // - orig_obj points to the original object.

      // - new_obj points to the shallow copy (created by ShallowCopier)

      //   of orig_obj. new_obj is NULL if the orig_obj is excluded

      address orig_obj = orig_ref->obj();

      address new_obj  = _builder->get_new_loc(orig_ref);

      assert(new_obj != orig_obj, "must be");

#ifdef ASSERT

      if (new_obj == NULL) {

        if (orig_ref->msotype() == MetaspaceObj::ClassType) {

          Klass* k = (Klass*)orig_obj;

          assert(k->is_instance_klass() &&

                 SystemDictionaryShared::is_excluded_class(InstanceKlass::cast(k)),

                 "orig_obj must be excluded Class");

        }

      }

#endif

      log_debug(cds, dynamic)("Relocating " PTR_FORMAT " %s", p2i(new_obj),

                              MetaspaceObj::type_name(orig_ref->msotype()));

      if (new_obj != NULL) {

        EmbeddedRefUpdater updater(_builder, orig_obj, new_obj);

        orig_ref->metaspace_pointers_do(&updater);

      }

      return true; // keep recursing until every object is visited exactly once.

    }

  };

  class EmbeddedRefUpdater: public MetaspaceClosure {

    DynamicArchiveBuilder* _builder;

    address _orig_obj;

    address _new_obj;

  public:

    EmbeddedRefUpdater(DynamicArchiveBuilder* shuffler, address orig_obj, address new_obj) :

      _builder(shuffler), _orig_obj(orig_obj), _new_obj(new_obj) {}

    // This method gets called once for each pointer field F of orig_obj.

    // We update new_obj->F to point to the new location of orig_obj->F.

    //

    // Example: Klass*  0x100 is copied to 0x400

    //          Symbol* 0x200 is copied to 0x500

    //

    // Let orig_obj == 0x100; and

    //     new_obj  == 0x400; and

    //     ((Klass*)orig_obj)->_name == 0x200;

    // Then this function effectively assigns

    //     ((Klass*)new_obj)->_name = 0x500;

    virtual bool do_ref(Ref* ref, bool read_only) {

      address new_pointee = NULL;

      if (ref->not_null()) {

        address old_pointee = ref->obj();

        FollowMode mode = _builder->follow_ref(ref);

        if (mode == point_to_it) {

          new_pointee = old_pointee;

        } else if (mode == set_to_null) {

          new_pointee = NULL;

        } else {

          new_pointee = _builder->get_new_loc(old_pointee);

        }

      }

      const char* kind = MetaspaceObj::type_name(ref->msotype());

      // offset of this field inside the original object

      intx offset = (address)ref->addr() - _orig_obj;

      _builder->update_pointer((address*)(_new_obj + offset), new_pointee, kind, offset);

      // We can't mark the pointer here, because DynamicArchiveBuilder::sort_methods

      // may re-layout the [iv]tables, which would change the offset(s) in an InstanceKlass

      // that would contain pointers. Therefore, we must mark the pointers after

      // sort_methods(), using PointerMarker.

      return false; // Do not recurse.

    }

  };

  class ExternalRefUpdater: public MetaspaceClosure {

    DynamicArchiveBuilder* _builder;

  public:

    ExternalRefUpdater(DynamicArchiveBuilder* shuffler) : _builder(shuffler) {}

    virtual bool do_ref(Ref* ref, bool read_only) {

      // ref is a pointer that lives OUTSIDE of the buffer, but points to an object inside the buffer

      if (ref->not_null()) {

        address new_loc = _builder->get_new_loc(ref);

        const char* kind = MetaspaceObj::type_name(ref->msotype());

        _builder->update_pointer(ref->addr(), new_loc, kind, 0);

        _builder->mark_pointer(ref->addr());

      }

      return false; // Do not recurse.

    }

  };

  class PointerMarker: public UniqueMetaspaceClosure {

    DynamicArchiveBuilder* _builder;

  public:

    PointerMarker(DynamicArchiveBuilder* shuffler) : _builder(shuffler) {}

    virtual bool do_unique_ref(Ref* ref, bool read_only) {

      if (_builder->is_in_buffer_space(ref->obj())) {

        EmbeddedRefMarker ref_marker(_builder);

        ref->metaspace_pointers_do(&ref_marker);

        return true; // keep recursing until every buffered object is visited exactly once.

      } else {

        return false;

      }

    }

  };

  class EmbeddedRefMarker: public MetaspaceClosure {

    DynamicArchiveBuilder* _builder;

  public:

    EmbeddedRefMarker(DynamicArchiveBuilder* shuffler) : _builder(shuffler) {}

    virtual bool do_ref(Ref* ref, bool read_only) {

      if (ref->not_null() && _builder->is_in_buffer_space(ref->obj())) {

        _builder->mark_pointer(ref->addr());

      }

      return false; // Do not recurse.

    }

  };

  void update_pointer(address* addr, address value, const char* kind, uintx offset, bool is_mso_pointer=true) {

    // Propagate the the mask bits to the new value -- see comments above MetaspaceClosure::obj()

    if (is_mso_pointer) {

      const uintx FLAG_MASK = 0x03;

      uintx mask_bits = uintx(*addr) & FLAG_MASK;

      value = (address)(uintx(value) | mask_bits);

    }

    if (*addr != value) {

      log_debug(cds, dynamic)("Update (%18s*) %3d [" PTR_FORMAT "] " PTR_FORMAT " -> " PTR_FORMAT,

                              kind, int(offset), p2i(addr), p2i(*addr), p2i(value));

      *addr = value;

    }

  }

private:

  GrowableArray<Symbol*>* _symbols; // symbols to dump

  GrowableArray<InstanceKlass*>* _klasses; // klasses to dump

  void append(InstanceKlass* k) { _klasses->append(k); }

  void append(Symbol* s)        { _symbols->append(s); }

  class GatherKlassesAndSymbols : public UniqueMetaspaceClosure {

    DynamicArchiveBuilder* _builder;

    bool _read_only;

  public:

    GatherKlassesAndSymbols(DynamicArchiveBuilder* builder)

      : _builder(builder) {}

    virtual bool do_unique_ref(Ref* ref, bool read_only) {

      if (_builder->follow_ref(ref) != make_a_copy) {

        return false;

      }

      if (ref->msotype() == MetaspaceObj::ClassType) {

        Klass* klass = (Klass*)ref->obj();

        assert(klass->is_klass(), "must be");

        if (klass->is_instance_klass()) {

          InstanceKlass* ik = InstanceKlass::cast(klass);

          assert(!SystemDictionaryShared::is_excluded_class(ik), "must be");

          _builder->append(ik);

          _builder->_estimated_metsapceobj_bytes += BytesPerWord; // See RunTimeSharedClassInfo::get_for()

        }

      } else if (ref->msotype() == MetaspaceObj::SymbolType) {

        _builder->append((Symbol*)ref->obj());

      }

      int bytes = ref->size() * BytesPerWord;

      _builder->_estimated_metsapceobj_bytes += bytes;

      return true;

    }

  };

  FollowMode follow_ref(MetaspaceClosure::Ref *ref) {

    address obj = ref->obj();

    if (MetaspaceShared::is_in_shared_metaspace(obj)) {

      // Don't dump existing shared metadata again.

      return point_to_it;

    } else if (ref->msotype() == MetaspaceObj::MethodDataType) {

      return set_to_null;

    } else {

      if (ref->msotype() == MetaspaceObj::ClassType) {

        Klass* klass = (Klass*)ref->obj();

        assert(klass->is_klass(), "must be");

        if (klass->is_instance_klass()) {

          InstanceKlass* ik = InstanceKlass::cast(klass);

          if (SystemDictionaryShared::is_excluded_class(ik)) {

            ResourceMark rm;

            log_debug(cds, dynamic)("Skipping class (excluded): %s", klass->external_name());

            return set_to_null;

          }

        } else if (klass->is_array_klass()) {

          // Don't support archiving of array klasses for now.

          ResourceMark rm;

          log_debug(cds, dynamic)("Skipping class (array): %s", klass->external_name());

          return set_to_null;

        }

      }

      return make_a_copy;

    }

  }

  address copy_impl(MetaspaceClosure::Ref* ref, bool read_only, int bytes) {

    if (ref->msotype() == MetaspaceObj::ClassType) {

      // Save a pointer immediate in front of an InstanceKlass, so

      // we can do a quick lookup from InstanceKlass* -> RunTimeSharedClassInfo*

      // without building another hashtable. See RunTimeSharedClassInfo::get_for()

      // in systemDictionaryShared.cpp.

      address obj = ref->obj();

      Klass* klass = (Klass*)obj;

      if (klass->is_instance_klass()) {

        SystemDictionaryShared::validate_before_archiving(InstanceKlass::cast(klass));

        current_dump_space()->allocate(sizeof(address), BytesPerWord);

      }

    }

    address p = (address)current_dump_space()->allocate(bytes);

    address obj = ref->obj();

    log_debug(cds, dynamic)("COPY: " PTR_FORMAT " ==> " PTR_FORMAT " %5d %s",

                            p2i(obj), p2i(p), bytes,

                            MetaspaceObj::type_name(ref->msotype()));

    memcpy(p, obj, bytes);

    intptr_t* cloned_vtable = MetaspaceShared::fix_cpp_vtable_for_dynamic_archive(ref->msotype(), p);

    if (cloned_vtable != NULL) {

      update_pointer((address*)p, (address)cloned_vtable, "vtb", 0, /*is_mso_pointer*/false);

    }

    return (address)p;

  }

  DynamicArchiveHeader *_header;

  address _alloc_bottom;

  address _last_verified_top;

  size_t _other_region_used_bytes;

  // Conservative estimate for number of bytes needed for:

  size_t _estimated_metsapceobj_bytes;   // all archived MetsapceObj's.

  size_t _estimated_hashtable_bytes;     // symbol table and dictionaries

  size_t _estimated_trampoline_bytes;    // method entry trampolines

  size_t estimate_archive_size();

  size_t estimate_trampoline_size();

  size_t estimate_class_file_size();

  address reserve_space_and_init_buffer_to_target_delta();

  void init_header(address addr);

  void make_trampolines();

  void make_klasses_shareable();

  void sort_methods(InstanceKlass* ik) const;

  void set_symbols_permanent();

  void relocate_buffer_to_target();

  void write_archive(char* serialized_data_start);

  void write_regions(FileMapInfo* dynamic_info);

  void init_first_dump_space(address reserved_bottom) {

    address first_space_base = reserved_bottom;

    DumpRegion* rw_space = MetaspaceShared::read_write_dump_space();

    MetaspaceShared::init_shared_dump_space(rw_space, first_space_base);

    _current_dump_space = rw_space;

    _last_verified_top = first_space_base;

    _num_dump_regions_used = 1;

  }

public:

  DynamicArchiveBuilder() {

    _klasses = new (ResourceObj::C_HEAP, mtClass) GrowableArray<InstanceKlass*>(100, true, mtInternal);

    _symbols = new (ResourceObj::C_HEAP, mtClass) GrowableArray<Symbol*>(1000, true, mtInternal);

    _estimated_metsapceobj_bytes = 0;

    _estimated_hashtable_bytes = 0;

    _estimated_trampoline_bytes = 0;

    _num_dump_regions_used = 0;

  }

  void start_dump_space(DumpRegion* next) {

    address bottom = _last_verified_top;

    address top = (address)(current_dump_space()->top());

    _other_region_used_bytes += size_t(top - bottom);

    MetaspaceShared::pack_dump_space(current_dump_space(), next, MetaspaceShared::shared_rs());

    _current_dump_space = next;

    _num_dump_regions_used ++;

    _last_verified_top = (address)(current_dump_space()->top());

  }

  void verify_estimate_size(size_t estimate, const char* which) {

    address bottom = _last_verified_top;

    address top = (address)(current_dump_space()->top());

    size_t used = size_t(top - bottom) + _other_region_used_bytes;

    int diff = int(estimate) - int(used);

    log_info(cds)("%s estimate = " SIZE_FORMAT " used = " SIZE_FORMAT "; diff = %d bytes", which, estimate, used, diff);

    assert(diff >= 0, "Estimate is too small");

    _last_verified_top = top;

    _other_region_used_bytes = 0;

  }

  // Do this before and after the archive dump to see if any corruption

  // is caused by dynamic dumping.

  void verify_universe(const char* info) {

    if (VerifyBeforeExit) {

      log_info(cds)("Verify %s", info);

      HandleMark hm;

      // Among other things, this ensures that Eden top is correct.