/*

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

#include "classfile/classLoaderExt.hpp"

#include "classfile/dictionary.hpp"

#include "classfile/loaderConstraints.hpp"

#include "classfile/placeholders.hpp"

#include "classfile/sharedClassUtil.hpp"

#include "classfile/symbolTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/systemDictionaryShared.hpp"

#include "code/codeCache.hpp"

#include "gc/shared/gcLocker.hpp"

#include "interpreter/bytecodeStream.hpp"

#include "interpreter/bytecodes.hpp"

#include "memory/filemap.hpp"

#include "memory/metaspace.hpp"

#include "memory/metaspaceShared.hpp"

#include "memory/resourceArea.hpp"

#include "oops/instanceClassLoaderKlass.hpp"

#include "oops/instanceMirrorKlass.hpp"

#include "oops/instanceRefKlass.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/objArrayOop.hpp"

#include "oops/oop.inline.hpp"

#include "oops/typeArrayKlass.hpp"

#include "runtime/timerTrace.hpp"

#include "runtime/os.hpp"

#include "runtime/signature.hpp"

#include "runtime/vmThread.hpp"

#include "runtime/vm_operations.hpp"

#include "utilities/defaultStream.hpp"

#include "utilities/hashtable.inline.hpp"

int MetaspaceShared::_max_alignment = 0;

ReservedSpace* MetaspaceShared::_shared_rs = NULL;

MetaspaceSharedStats MetaspaceShared::_stats;

bool MetaspaceShared::_has_error_classes;

bool MetaspaceShared::_archive_loading_failed = false;

bool MetaspaceShared::_remapped_readwrite = false;

address MetaspaceShared::_cds_i2i_entry_code_buffers = NULL;

size_t MetaspaceShared::_cds_i2i_entry_code_buffers_size = 0;

SharedMiscRegion MetaspaceShared::_mc;

SharedMiscRegion MetaspaceShared::_md;

SharedMiscRegion MetaspaceShared::_od;

void SharedMiscRegion::initialize(ReservedSpace rs, size_t committed_byte_size,  SharedSpaceType space_type) {

  _vs.initialize(rs, committed_byte_size);

  _alloc_top = _vs.low();

  _space_type = space_type;

}

// NOT thread-safe, but this is called during dump time in single-threaded mode.

char* SharedMiscRegion::alloc(size_t num_bytes) {

  assert(DumpSharedSpaces, "dump time only");

  size_t alignment = sizeof(char*);

  num_bytes = align_size_up(num_bytes, alignment);

  _alloc_top = (char*)align_ptr_up(_alloc_top, alignment);

  if (_alloc_top + num_bytes > _vs.high()) {

    report_out_of_shared_space(_space_type);

  }

  char* p = _alloc_top;

  _alloc_top += num_bytes;

  memset(p, 0, num_bytes);

  return p;

}

void MetaspaceShared::initialize_shared_rs(ReservedSpace* rs) {

  assert(DumpSharedSpaces, "dump time only");

  _shared_rs = rs;

  size_t core_spaces_size = FileMapInfo::core_spaces_size();

  size_t metadata_size = SharedReadOnlySize + SharedReadWriteSize;

  // Split into the core and optional sections

  ReservedSpace core_data = _shared_rs->first_part(core_spaces_size);

  ReservedSpace optional_data = _shared_rs->last_part(core_spaces_size);

  // The RO/RW and the misc sections

  ReservedSpace shared_ro_rw = core_data.first_part(metadata_size);

  ReservedSpace misc_section = core_data.last_part(metadata_size);

  // Now split the misc code and misc data sections.

  ReservedSpace md_rs   = misc_section.first_part(SharedMiscDataSize);

  ReservedSpace mc_rs   = misc_section.last_part(SharedMiscDataSize);

  _md.initialize(md_rs, SharedMiscDataSize, SharedMiscData);

  _mc.initialize(mc_rs, SharedMiscCodeSize, SharedMiscCode);

  _od.initialize(optional_data, metadata_size, SharedOptional);

}

// Read/write a data stream for restoring/preserving metadata pointers and

// miscellaneous data from/to the shared archive file.

void MetaspaceShared::serialize(SerializeClosure* soc, GrowableArray<MemRegion> *string_space,

                                size_t* space_size) {

  int tag = 0;

  soc->do_tag(--tag);

  // Verify the sizes of various metadata in the system.

  soc->do_tag(sizeof(Method));

  soc->do_tag(sizeof(ConstMethod));

  soc->do_tag(arrayOopDesc::base_offset_in_bytes(T_BYTE));

  soc->do_tag(sizeof(ConstantPool));

  soc->do_tag(sizeof(ConstantPoolCache));

  soc->do_tag(objArrayOopDesc::base_offset_in_bytes());

  soc->do_tag(typeArrayOopDesc::base_offset_in_bytes(T_BYTE));

  soc->do_tag(sizeof(Symbol));

  // Dump/restore miscellaneous metadata.

  Universe::serialize(soc, true);

  soc->do_tag(--tag);

  // Dump/restore references to commonly used names and signatures.

  vmSymbols::serialize(soc);

  soc->do_tag(--tag);

  // Dump/restore the symbol and string tables

  SymbolTable::serialize(soc);

  StringTable::serialize(soc, string_space, space_size);

  soc->do_tag(--tag);

  soc->do_tag(666);

}

address MetaspaceShared::cds_i2i_entry_code_buffers(size_t total_size) {

  if (DumpSharedSpaces) {

    if (_cds_i2i_entry_code_buffers == NULL) {

      _cds_i2i_entry_code_buffers = (address)misc_data_space_alloc(total_size);

      _cds_i2i_entry_code_buffers_size = total_size;

    }

  } else if (UseSharedSpaces) {

    assert(_cds_i2i_entry_code_buffers != NULL, "must already been initialized");

  } else {

    return NULL;

  }

  assert(_cds_i2i_entry_code_buffers_size == total_size, "must not change");

  return _cds_i2i_entry_code_buffers;

}

// CDS code for dumping shared archive.

// Global object for holding classes that have been loaded.  Since this

// is run at a safepoint just before exit, this is the entire set of classes.

static GrowableArray<Klass*>* _global_klass_objects;

class CollectClassesClosure : public KlassClosure {

  void do_klass(Klass* k) {

    _global_klass_objects->append_if_missing(k);

  }

};

static void remove_unshareable_in_classes() {

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

    Klass* k = _global_klass_objects->at(i);

    k->remove_unshareable_info();

  }

}

static void rewrite_nofast_bytecode(Method* method) {

  RawBytecodeStream bcs(method);

  while (!bcs.is_last_bytecode()) {

    Bytecodes::Code opcode = bcs.raw_next();

    switch (opcode) {

    case Bytecodes::_getfield:      *bcs.bcp() = Bytecodes::_nofast_getfield;      break;

    case Bytecodes::_putfield:      *bcs.bcp() = Bytecodes::_nofast_putfield;      break;

    case Bytecodes::_aload_0:       *bcs.bcp() = Bytecodes::_nofast_aload_0;       break;

    case Bytecodes::_iload: {

      if (!bcs.is_wide()) {

        *bcs.bcp() = Bytecodes::_nofast_iload;

      }

      break;

    }

    default: break;

    }

  }

}

// Walk all methods in the class list to ensure that they won't be modified at

// run time. This includes:

// [1] Rewrite all bytecodes as needed, so that the ConstMethod* will not be modified

//     at run time by RewriteBytecodes/RewriteFrequentPairs

// [2] Assign a fingerprint, so one doesn't need to be assigned at run-time.

static void rewrite_nofast_bytecodes_and_calculate_fingerprints() {

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

    Klass* k = _global_klass_objects->at(i);

    if (k->is_instance_klass()) {

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

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

        Method* m = ik->methods()->at(i);

        rewrite_nofast_bytecode(m);

        Fingerprinter fp(m);

        // The side effect of this call sets method's fingerprint field.

        fp.fingerprint();

      }

    }

  }

}

// Objects of the Metadata types (such as Klass and ConstantPool) have C++ vtables.

// (In GCC this is the field <Type>::_vptr, i.e., first word in the object.)

//

// Addresses of the vtables and the methods may be different across JVM runs,

// if libjvm.so is dynamically loaded at a different base address.

//

// To ensure that the Metadata objects in the CDS archive always have the correct vtable:

//

// + at dump time:  we redirect the _vptr to point to our own vtables inside

//                  the CDS image

// + at run time:   we clone the actual contents of the vtables from libjvm.so

//                  into our own tables.

// Currently, the archive contain ONLY the following types of objects that have C++ vtables.

#define CPP_VTABLE_PATCH_TYPES_DO(f) \

  f(ConstantPool) \

  f(InstanceKlass) \

  f(InstanceClassLoaderKlass) \

  f(InstanceMirrorKlass) \

  f(InstanceRefKlass) \

  f(Method) \

  f(ObjArrayKlass) \

  f(TypeArrayKlass)

class CppVtableInfo {

  intptr_t _vtable_size;

  intptr_t _cloned_vtable[1];

public:

  static int num_slots(int vtable_size) {

    return 1 + vtable_size; // Need to add the space occupied by _vtable_size;

  }

  int vtable_size()           { return int(uintx(_vtable_size)); }

  void set_vtable_size(int n) { _vtable_size = intptr_t(n); }

  intptr_t* cloned_vtable()   { return &_cloned_vtable[0]; }

  void zero()                 { memset(_cloned_vtable, 0, sizeof(intptr_t) * vtable_size()); }

  // Returns the address of the next CppVtableInfo that can be placed immediately after this CppVtableInfo

  intptr_t* next(int vtable_size) {

    return &_cloned_vtable[vtable_size];

  }

};

template <class T> class CppVtableCloner : public T {

  static intptr_t* vtable_of(Metadata& m) {

    return *((intptr_t**)&m);

  }

  static CppVtableInfo* _info;

  static int get_vtable_length(const char* name);

public:

  // Allocate and initialize the C++ vtable, starting from top, but do not go past end.

  static intptr_t* allocate(const char* name, intptr_t* top, intptr_t* end);

  // Clone the vtable to ...

  static intptr_t* clone_vtable(const char* name, CppVtableInfo* info);

  static void zero_vtable_clone() {

    assert(DumpSharedSpaces, "dump-time only");

    _info->zero();

  }

  // Switch the vtable pointer to point to the cloned vtable.

  static void patch(Metadata* obj) {

    assert(DumpSharedSpaces, "dump-time only");

    *(void**)obj = (void*)(_info->cloned_vtable());

  }

  static bool is_valid_shared_object(const T* obj) {

    intptr_t* vptr = *(intptr_t**)obj;

    return vptr == _info->cloned_vtable();

  }

};

template <class T> CppVtableInfo* CppVtableCloner<T>::_info = NULL;

template <class T>

intptr_t* CppVtableCloner<T>::allocate(const char* name, intptr_t* top, intptr_t* end) {

  int n = get_vtable_length(name);

  _info = (CppVtableInfo*)top;

  intptr_t* next = _info->next(n);

  if (next > end) {

    report_out_of_shared_space(SharedMiscData);

  }

  _info->set_vtable_size(n);

  intptr_t* p = clone_vtable(name, _info);

  assert(p == next, "must be");

  return p;

}

template <class T>

intptr_t* CppVtableCloner<T>::clone_vtable(const char* name, CppVtableInfo* info) {

  if (!DumpSharedSpaces) {

    assert(_info == 0, "_info is initialized only at dump time");

    _info = info; // Remember it -- it will be used by MetaspaceShared::is_valid_shared_method()

  }

  T tmp; // Allocate temporary dummy metadata object to get to the original vtable.

  int n = info->vtable_size();

  intptr_t* srcvtable = vtable_of(tmp);

  intptr_t* dstvtable = info->cloned_vtable();

  // We already checked (and, if necessary, adjusted n) when the vtables were allocated, so we are

  // safe to do memcpy.

  memcpy(dstvtable, srcvtable, sizeof(intptr_t) * n);

  return dstvtable + n;

}

// To determine the size of the vtable for each type, we use the following

// trick by declaring 2 subclasses:

//

//   class CppVtableTesterA: public InstanceKlass {virtual int   last_virtual_method() {return 1;}    };

//   class CppVtableTesterB: public InstanceKlass {virtual void* last_virtual_method() {return NULL}; };

//

// CppVtableTesterA and CppVtableTesterB's vtables have the following properties:

// - Their size (N+1) is exactly one more than the size of InstanceKlass's vtable (N)

// - The first N entries have are exactly the same as in InstanceKlass's vtable.

// - Their last entry is different.

//

// So to determine the value of N, we just walk CppVtableTesterA and CppVtableTesterB's tables

// and find the first entry that's different.

//

// This works on all C++ compilers supported by Oracle, but you may need to tweak it for more

// esoteric compilers.

template <class T> class CppVtableTesterB: public T {

public:

  virtual int last_virtual_method() {return 1;}

};

template <class T> class CppVtableTesterA : public T {

public:

  virtual void* last_virtual_method() {

    // Make this different than CppVtableTesterB::last_virtual_method so the C++

    // compiler/linker won't alias the two functions.

    return NULL;

  }

};

template <class T>

int CppVtableCloner<T>::get_vtable_length(const char* name) {

  CppVtableTesterA<T> a;

  CppVtableTesterB<T> b;

  intptr_t* avtable = vtable_of(a);

  intptr_t* bvtable = vtable_of(b);

  // Start at slot 1, because slot 0 may be RTTI (on Solaris/Sparc)

  int vtable_len = 1;

  for (; ; vtable_len++) {

    if (avtable[vtable_len] != bvtable[vtable_len]) {

      break;

    }

  }

  return vtable_len;

}

#define ALLOC_CPP_VTABLE_CLONE(c) \

  top = CppVtableCloner<c>::allocate(#c, top, end);

#define CLONE_CPP_VTABLE(c) \

  p = CppVtableCloner<c>::clone_vtable(#c, (CppVtableInfo*)p);

#define ZERO_CPP_VTABLE(c) \

 CppVtableCloner<c>::zero_vtable_clone();

// This can be called at both dump time and run time.

intptr_t* MetaspaceShared::clone_cpp_vtables(intptr_t* p) {

  assert(DumpSharedSpaces || UseSharedSpaces, "sanity");

  CPP_VTABLE_PATCH_TYPES_DO(CLONE_CPP_VTABLE);

  return p;

}

void MetaspaceShared::zero_cpp_vtable_clones_for_writing() {

  assert(DumpSharedSpaces, "dump-time only");

  CPP_VTABLE_PATCH_TYPES_DO(ZERO_CPP_VTABLE);

}

// Allocate and initialize the C++ vtables, starting from top, but do not go past end.

intptr_t* MetaspaceShared::allocate_cpp_vtable_clones(intptr_t* top, intptr_t* end) {

  assert(DumpSharedSpaces, "dump-time only");

  // Layout (each slot is a intptr_t):

  //   [number of slots in the first vtable = n1]

  //   [ <n1> slots for the first vtable]

  //   [number of slots in the first second = n2]

  //   [ <n2> slots for the second vtable]

  //   ...

  // The order of the vtables is the same as the CPP_VTAB_PATCH_TYPES_DO macro.

  CPP_VTABLE_PATCH_TYPES_DO(ALLOC_CPP_VTABLE_CLONE);

  return top;

}

// Switch the vtable pointer to point to the cloned vtable. We assume the

// vtable pointer is in first slot in object.

void MetaspaceShared::patch_cpp_vtable_pointers() {

  int n = _global_klass_objects->length();

  for (int i = 0; i < n; i++) {

    Klass* obj = _global_klass_objects->at(i);

    if (obj->is_instance_klass()) {

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

      if (ik->is_class_loader_instance_klass()) {

        CppVtableCloner<InstanceClassLoaderKlass>::patch(ik);

      } else if (ik->is_reference_instance_klass()) {

        CppVtableCloner<InstanceRefKlass>::patch(ik);

      } else if (ik->is_mirror_instance_klass()) {

        CppVtableCloner<InstanceMirrorKlass>::patch(ik);

      } else {

        CppVtableCloner<InstanceKlass>::patch(ik);

      }

      ConstantPool* cp = ik->constants();

      CppVtableCloner<ConstantPool>::patch(cp);

      for (int j = 0; j < ik->methods()->length(); j++) {

        Method* m = ik->methods()->at(j);

        CppVtableCloner<Method>::patch(m);

        assert(CppVtableCloner<Method>::is_valid_shared_object(m), "must be");

      }

    } else if (obj->is_objArray_klass()) {

      CppVtableCloner<ObjArrayKlass>::patch(obj);

    } else {

      assert(obj->is_typeArray_klass(), "sanity");

      CppVtableCloner<TypeArrayKlass>::patch(obj);

    }

  }

}

bool MetaspaceShared::is_valid_shared_method(const Method* m) {

  assert(is_in_shared_space(m), "must be");

  return CppVtableCloner<Method>::is_valid_shared_object(m);

}

// Closure for serializing initialization data out to a data area to be

// written to the shared file.

class WriteClosure : public SerializeClosure {

private:

  intptr_t* top;

  char* end;

  inline void check_space() {

    if ((char*)top + sizeof(intptr_t) > end) {

      report_out_of_shared_space(SharedMiscData);

    }

  }

public:

  WriteClosure(char* md_top, char* md_end) {

    top = (intptr_t*)md_top;

    end = md_end;

  }

  char* get_top() { return (char*)top; }

  void do_ptr(void** p) {

    check_space();

    *top = (intptr_t)*p;

    ++top;

  }

  void do_u4(u4* p) {

    void* ptr = (void*)(uintx(*p));

    do_ptr(&ptr);

  }

  void do_tag(int tag) {

    check_space();

    *top = (intptr_t)tag;