/*

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

#include "oops/oop.inline.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::_link_classes_made_progress;

bool MetaspaceShared::_check_classes_made_progress;

bool MetaspaceShared::_has_error_classes;

bool MetaspaceShared::_archive_loading_failed = 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;

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;

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

  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.initialize(md_rs, SharedMiscDataSize, SharedMiscData);

  _mc.initialize(mc_rs, SharedMiscCodeSize, SharedMiscData);

}

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

  // Dump/restore the misc information for system dictionary

  SystemDictionaryShared::serialize(soc);

  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;

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 collect_classes2(Klass* k, ClassLoaderData* class_data) {

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

      }

    }

  }

}

// 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_u4(u4* p) {

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

    do_ptr(&ptr);

  }

  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(StringHashentry) \

  f(StringBucket) \

  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[RO][SymbolHashentryType] = stats->symbol.hashentry_count;

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

  _bytes [RO][TypeArrayU4Type]    -= stats->symbol.hashentry_bytes;

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

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

  _bytes [RO][TypeArrayU4Type] -= stats->symbol.bucket_bytes;

  // strings

  _counts[RO][StringHashentryType] = stats->string.hashentry_count;

  _bytes [RO][StringHashentryType] = stats->string.hashentry_bytes;

  _bytes [RO][TypeArrayU4Type]    -= stats->string.hashentry_bytes;

  _counts[RO][StringBucketType] = stats->string.bucket_count;

  _bytes [RO][StringBucketType] = stats->string.bucket_bytes;

  _bytes [RO][TypeArrayU4Type] -= stats->string.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);