/*

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

#include "classfile/loaderConstraints.hpp"

#include "classfile/placeholders.hpp"

#include "classfile/sharedClassUtil.hpp"

#include "classfile/symbolTable.hpp"

#include "classfile/systemDictionary.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 "oops/objArrayOop.hpp"

#include "oops/oop.inline.hpp"

#include "runtime/os.hpp"

#include "runtime/signature.hpp"

#include "runtime/vmThread.hpp"

#include "runtime/vm_operations.hpp"

#include "utilities/hashtable.inline.hpp"

int MetaspaceShared::_max_alignment = 0;

ReservedSpace* MetaspaceShared::_shared_rs = NULL;

MetaspaceSharedStats MetaspaceShared::_stats;

bool MetaspaceShared::_link_classes_made_progress;

bool MetaspaceShared::_check_classes_made_progress;

bool MetaspaceShared::_has_error_classes;

bool MetaspaceShared::_archive_loading_failed = false;

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

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

void MetaspaceShared::serialize(SerializeClosure* soc) {

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

  soc->do_tag(666);

}

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

static void collect_classes(Klass* k) {

  _global_klass_objects->append_if_missing(k);

  if (k->is_instance_klass()) {

    // Add in the array classes too

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

    ik->array_klasses_do(collect_classes);

  }

}

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:         *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();

      }

    }

  }

}

// Patch C++ vtable pointer in metadata.

// Klass and other metadata objects contain references to c++ vtables in the

// JVM library.

// Fix them to point to our constructed vtables.  However, don't iterate

// across the space while doing this, as that causes the vtables to be

// patched, undoing our useful work.  Instead, iterate to make a list,

// then use the list to do the fixing.

//

// Our constructed vtables:

// Dump time:

//  1. init_self_patching_vtbl_list: table of pointers to current virtual method addrs

//  2. generate_vtable_methods: create jump table, appended to above vtbl_list

//  3. patch_klass_vtables: for Klass list, patch the vtable entry in klass and

//     associated metadata to point to jump table rather than to current vtbl

// Table layout: NOTE FIXED SIZE

//   1. vtbl pointers

//   2. #Klass X #virtual methods per Klass

//   1 entry for each, in the order:

//   Klass1:method1 entry, Klass1:method2 entry, ... Klass1:method<num_virtuals> entry

//   Klass2:method1 entry, Klass2:method2 entry, ... Klass2:method<num_virtuals> entry

//   ...

//   Klass<vtbl_list_size>:method1 entry, Klass<vtbl_list_size>:method2 entry,

//       ... Klass<vtbl_list_size>:method<num_virtuals> entry

//  Sample entry: (Sparc):

//   save(sp, -256, sp)

//   ba,pt common_code

//   mov XXX, %L0       %L0 gets: Klass index <<8 + method index (note: max method index 255)

//

// Restore time:

//   1. initialize_shared_space: reserve space for table

//   2. init_self_patching_vtbl_list: update pointers to NEW virtual method addrs in text

//

// Execution time:

//   First virtual method call for any object of these metadata types:

//   1. object->klass

//   2. vtable entry for that klass points to the jump table entries

//   3. branches to common_code with %O0/klass, %L0: Klass index <<8 + method index

//   4. common_code:

//      Get address of new vtbl pointer for this Klass from updated table

//      Update new vtbl pointer in the Klass: future virtual calls go direct

//      Jump to method, using new vtbl pointer and method index

static void* find_matching_vtbl_ptr(void** vtbl_list, void* new_vtable_start, void* obj) {

  void* old_vtbl_ptr = *(void**)obj;

  for (int i = 0; i < MetaspaceShared::vtbl_list_size; i++) {

    if (vtbl_list[i] == old_vtbl_ptr) {

      return (void**)new_vtable_start + i * MetaspaceShared::num_virtuals;

    }

  }

  ShouldNotReachHere();

  return NULL;

}

// Assumes the vtable is in first slot in object.

static void patch_klass_vtables(void** vtbl_list, void* new_vtable_start) {

  int n = _global_klass_objects->length();

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

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

    // Note is_instance_klass() is a virtual call in debug.  After patching vtables

    // all virtual calls on the dummy vtables will restore the original!

    if (obj->is_instance_klass()) {

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

      *(void**)ik = find_matching_vtbl_ptr(vtbl_list, new_vtable_start, ik);

      ConstantPool* cp = ik->constants();

      *(void**)cp = find_matching_vtbl_ptr(vtbl_list, new_vtable_start, cp);

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

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

        *(void**)m = find_matching_vtbl_ptr(vtbl_list, new_vtable_start, m);

      }

    } else {

      // Array klasses

      Klass* k = obj;

      *(void**)k = find_matching_vtbl_ptr(vtbl_list, new_vtable_start, k);

    }

  }

}

// 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_tag(int tag) {

    check_space();

    *top = (intptr_t)tag;

    ++top;

  }

  void do_region(u_char* start, size_t size) {

    if ((char*)top + size > end) {

      report_out_of_shared_space(SharedMiscData);

    }

    assert((intptr_t)start % sizeof(intptr_t) == 0, "bad alignment");

    assert(size % sizeof(intptr_t) == 0, "bad size");

    do_tag((int)size);

    while (size > 0) {

      *top = *(intptr_t*)start;

      ++top;

      start += sizeof(intptr_t);

      size -= sizeof(intptr_t);

    }

  }

  bool reading() const { return false; }

};

// This is for dumping detailed statistics for the allocations

// in the shared spaces.

class DumpAllocClosure : public Metaspace::AllocRecordClosure {

public:

  // Here's poor man's enum inheritance

#define SHAREDSPACE_OBJ_TYPES_DO(f) \

  METASPACE_OBJ_TYPES_DO(f) \

  f(SymbolHashentry) \

  f(SymbolBucket) \

  f(Other)

#define SHAREDSPACE_OBJ_TYPE_DECLARE(name) name ## Type,

#define SHAREDSPACE_OBJ_TYPE_NAME_CASE(name) case name ## Type: return #name;

  enum Type {

    // Types are MetaspaceObj::ClassType, MetaspaceObj::SymbolType, etc

    SHAREDSPACE_OBJ_TYPES_DO(SHAREDSPACE_OBJ_TYPE_DECLARE)

    _number_of_types

  };

  static const char * type_name(Type type) {

    switch(type) {

    SHAREDSPACE_OBJ_TYPES_DO(SHAREDSPACE_OBJ_TYPE_NAME_CASE)

    default:

      ShouldNotReachHere();

      return NULL;

    }

  }

public:

  enum {

    RO = 0,

    RW = 1

  };

  int _counts[2][_number_of_types];

  int _bytes [2][_number_of_types];

  int _which;

  DumpAllocClosure() {

    memset(_counts, 0, sizeof(_counts));

    memset(_bytes,  0, sizeof(_bytes));

  };

  void iterate_metaspace(Metaspace* space, int which) {

    assert(which == RO || which == RW, "sanity");

    _which = which;

    space->iterate(this);

  }

  virtual void doit(address ptr, MetaspaceObj::Type type, int byte_size) {

    assert(int(type) >= 0 && type < MetaspaceObj::_number_of_types, "sanity");

    _counts[_which][type] ++;

    _bytes [_which][type] += byte_size;

  }

  void dump_stats(int ro_all, int rw_all, int md_all, int mc_all);

};

void DumpAllocClosure::dump_stats(int ro_all, int rw_all, int md_all, int mc_all) {

  rw_all += (md_all + mc_all); // md and mc are all mapped Read/Write

  int other_bytes = md_all + mc_all;

  // Calculate size of data that was not allocated by Metaspace::allocate()

  MetaspaceSharedStats *stats = MetaspaceShared::stats();

  // symbols

  _counts[RW][SymbolHashentryType] = stats->symbol.hashentry_count;

  _bytes [RW][SymbolHashentryType] = stats->symbol.hashentry_bytes;

  other_bytes -= stats->symbol.hashentry_bytes;

  _counts[RW][SymbolBucketType] = stats->symbol.bucket_count;

  _bytes [RW][SymbolBucketType] = stats->symbol.bucket_bytes;

  other_bytes -= stats->symbol.bucket_bytes;

  // TODO: count things like dictionary, vtable, etc

  _bytes[RW][OtherType] =  other_bytes;

  // prevent divide-by-zero

  if (ro_all < 1) {

    ro_all = 1;

  }

  if (rw_all < 1) {

    rw_all = 1;

  }

  int all_ro_count = 0;

  int all_ro_bytes = 0;

  int all_rw_count = 0;

  int all_rw_bytes = 0;

// To make fmt_stats be a syntactic constant (for format warnings), use #define.

#define fmt_stats "%-20s: %8d %10d %5.1f | %8d %10d %5.1f | %8d %10d %5.1f"

  const char *sep = "--------------------+---------------------------+---------------------------+--------------------------";

  const char *hdr = "                        ro_cnt   ro_bytes     % |   rw_cnt   rw_bytes     % |  all_cnt  all_bytes     %";

  tty->print_cr("Detailed metadata info (rw includes md and mc):");

  tty->print_cr("%s", hdr);

  tty->print_cr("%s", sep);

  for (int type = 0; type < int(_number_of_types); type ++) {

    const char *name = type_name((Type)type);

    int ro_count = _counts[RO][type];

    int ro_bytes = _bytes [RO][type];

    int rw_count = _counts[RW][type];

    int rw_bytes = _bytes [RW][type];

    int count = ro_count + rw_count;

    int bytes = ro_bytes + rw_bytes;

    double ro_perc = 100.0 * double(ro_bytes) / double(ro_all);

    double rw_perc = 100.0 * double(rw_bytes) / double(rw_all);

    double perc    = 100.0 * double(bytes)    / double(ro_all + rw_all);

    tty->print_cr(fmt_stats, name,

                  ro_count, ro_bytes, ro_perc,

                  rw_count, rw_bytes, rw_perc,

                  count, bytes, perc);

    all_ro_count += ro_count;

    all_ro_bytes += ro_bytes;

    all_rw_count += rw_count;

    all_rw_bytes += rw_bytes;

  }

  int all_count = all_ro_count + all_rw_count;

  int all_bytes = all_ro_bytes + all_rw_bytes;

  double all_ro_perc = 100.0 * double(all_ro_bytes) / double(ro_all);

  double all_rw_perc = 100.0 * double(all_rw_bytes) / double(rw_all);

  double all_perc    = 100.0 * double(all_bytes)    / double(ro_all + rw_all);

  tty->print_cr("%s", sep);

  tty->print_cr(fmt_stats, "Total",

                all_ro_count, all_ro_bytes, all_ro_perc,

                all_rw_count, all_rw_bytes, all_rw_perc,

                all_count, all_bytes, all_perc);

  assert(all_ro_bytes == ro_all, "everything should have been counted");

  assert(all_rw_bytes == rw_all, "everything should have been counted");

#undef fmt_stats

}

// Populate the shared space.

class VM_PopulateDumpSharedSpace: public VM_Operation {

private:

  ClassLoaderData* _loader_data;

  GrowableArray<Klass*> *_class_promote_order;

  VirtualSpace _md_vs;

  VirtualSpace _mc_vs;

  CompactHashtableWriter* _string_cht;

  GrowableArray<MemRegion> *_string_regions;

public:

  VM_PopulateDumpSharedSpace(ClassLoaderData* loader_data,

                             GrowableArray<Klass*> *class_promote_order) :

    _loader_data(loader_data) {

    // Split up and initialize the misc code and data spaces

    ReservedSpace* shared_rs = MetaspaceShared::shared_rs();

    size_t metadata_size = SharedReadOnlySize + SharedReadWriteSize;

    ReservedSpace shared_ro_rw = shared_rs->first_part(metadata_size);

    ReservedSpace misc_section = shared_rs->last_part(metadata_size);

    // Now split into misc sections.

    ReservedSpace md_rs   = misc_section.first_part(SharedMiscDataSize);

    ReservedSpace mc_rs   = misc_section.last_part(SharedMiscDataSize);

    _md_vs.initialize(md_rs, SharedMiscDataSize);

    _mc_vs.initialize(mc_rs, SharedMiscCodeSize);

    _class_promote_order = class_promote_order;

  }

  VMOp_Type type() const { return VMOp_PopulateDumpSharedSpace; }

  void doit();   // outline because gdb sucks

private:

  void handle_misc_data_space_failure(bool success) {

    if (!success) {

      report_out_of_shared_space(SharedMiscData);

    }

  }

}; // class VM_PopulateDumpSharedSpace

void VM_PopulateDumpSharedSpace::doit() {

  Thread* THREAD = VMThread::vm_thread();

  NOT_PRODUCT(SystemDictionary::verify();)

  // The following guarantee is meant to ensure that no loader constraints

  // exist yet, since the constraints table is not shared.  This becomes

  // more important now that we don't re-initialize vtables/itables for

  // shared classes at runtime, where constraints were previously created.

  guarantee(SystemDictionary::constraints()->number_of_entries() == 0,

            "loader constraints are not saved");