/*

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

#include "classfile/javaClasses.inline.hpp"

#include "classfile/metadataOnStackMark.hpp"

#include "classfile/stringTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "interpreter/linkResolver.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/heapInspection.hpp"

#include "memory/metadataFactory.hpp"

#include "memory/metaspaceClosure.hpp"

#include "memory/metaspaceShared.hpp"

#include "memory/oopFactory.hpp"

#include "memory/resourceArea.hpp"

#include "oops/constantPool.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/objArrayOop.inline.hpp"

#include "oops/oop.inline.hpp"

#include "runtime/fieldType.hpp"

#include "runtime/init.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/signature.hpp"

#include "runtime/vframe.hpp"

#include "utilities/copy.hpp"

ConstantPool* ConstantPool::allocate(ClassLoaderData* loader_data, int length, TRAPS) {

  Array<u1>* tags = MetadataFactory::new_array<u1>(loader_data, length, 0, CHECK_NULL);

  int size = ConstantPool::size(length);

  return new (loader_data, size, MetaspaceObj::ConstantPoolType, THREAD) ConstantPool(tags);

}

#ifdef ASSERT

// MetaspaceObj allocation invariant is calloc equivalent memory

// simple verification of this here (JVM_CONSTANT_Invalid == 0 )

static bool tag_array_is_zero_initialized(Array<u1>* tags) {

  assert(tags != NULL, "invariant");

  const int length = tags->length();

  for (int index = 0; index < length; ++index) {

    if (JVM_CONSTANT_Invalid != tags->at(index)) {

      return false;

    }

  }

  return true;

}

#endif

ConstantPool::ConstantPool(Array<u1>* tags) :

  _tags(tags),

  _length(tags->length()) {

    assert(_tags != NULL, "invariant");

    assert(tags->length() == _length, "invariant");

    assert(tag_array_is_zero_initialized(tags), "invariant");

    assert(0 == flags(), "invariant");

    assert(0 == version(), "invariant");

    assert(NULL == _pool_holder, "invariant");

}

void ConstantPool::deallocate_contents(ClassLoaderData* loader_data) {

  if (cache() != NULL) {

    MetadataFactory::free_metadata(loader_data, cache());

    set_cache(NULL);

  }

  MetadataFactory::free_array<Klass*>(loader_data, resolved_klasses());

  set_resolved_klasses(NULL);

  MetadataFactory::free_array<jushort>(loader_data, operands());

  set_operands(NULL);

  release_C_heap_structures();

  // free tag array

  MetadataFactory::free_array<u1>(loader_data, tags());

  set_tags(NULL);

}

void ConstantPool::release_C_heap_structures() {

  // walk constant pool and decrement symbol reference counts

  unreference_symbols();

}

void ConstantPool::metaspace_pointers_do(MetaspaceClosure* it) {

  log_trace(cds)("Iter(ConstantPool): %p", this);

  it->push(&_tags, MetaspaceClosure::_writable);

  it->push(&_cache);

  it->push(&_pool_holder);

  it->push(&_operands);

  it->push(&_resolved_klasses, MetaspaceClosure::_writable);

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

    // The only MSO's embedded in the CP entries are Symbols:

    //   JVM_CONSTANT_String (normal and pseudo)

    //   JVM_CONSTANT_Utf8

    constantTag ctag = tag_at(i);

    if (ctag.is_string() || ctag.is_utf8()) {

      it->push(symbol_at_addr(i));

    }

  }

}

objArrayOop ConstantPool::resolved_references() const {

  return (objArrayOop)_cache->resolved_references();

}

// Called from outside constant pool resolution where a resolved_reference array

// may not be present.

objArrayOop ConstantPool::resolved_references_or_null() const {

  if (_cache == NULL) {

    return NULL;

  } else {

    return (objArrayOop)_cache->resolved_references();

  }

}

// Create resolved_references array and mapping array for original cp indexes

// The ldc bytecode was rewritten to have the resolved reference array index so need a way

// to map it back for resolving and some unlikely miscellaneous uses.

// The objects created by invokedynamic are appended to this list.

void ConstantPool::initialize_resolved_references(ClassLoaderData* loader_data,

                                                  const intStack& reference_map,

                                                  int constant_pool_map_length,

                                                  TRAPS) {

  // Initialized the resolved object cache.

  int map_length = reference_map.length();

  if (map_length > 0) {

    // Only need mapping back to constant pool entries.  The map isn't used for

    // invokedynamic resolved_reference entries.  For invokedynamic entries,

    // the constant pool cache index has the mapping back to both the constant

    // pool and to the resolved reference index.

    if (constant_pool_map_length > 0) {

      Array<u2>* om = MetadataFactory::new_array<u2>(loader_data, constant_pool_map_length, CHECK);

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

        int x = reference_map.at(i);

        assert(x == (int)(jushort) x, "klass index is too big");

        om->at_put(i, (jushort)x);

      }

      set_reference_map(om);

    }

    // Create Java array for holding resolved strings, methodHandles,

    // methodTypes, invokedynamic and invokehandle appendix objects, etc.

    objArrayOop stom = oopFactory::new_objArray(SystemDictionary::Object_klass(), map_length, CHECK);

    Handle refs_handle (THREAD, (oop)stom);  // must handleize.

    set_resolved_references(loader_data->add_handle(refs_handle));

  }

}

void ConstantPool::allocate_resolved_klasses(ClassLoaderData* loader_data, int num_klasses, TRAPS) {

  // A ConstantPool can't possibly have 0xffff valid class entries,

  // because entry #0 must be CONSTANT_Invalid, and each class entry must refer to a UTF8

  // entry for the class's name. So at most we will have 0xfffe class entries.

  // This allows us to use 0xffff (ConstantPool::_temp_resolved_klass_index) to indicate

  // UnresolvedKlass entries that are temporarily created during class redefinition.

  assert(num_klasses < CPKlassSlot::_temp_resolved_klass_index, "sanity");

  assert(resolved_klasses() == NULL, "sanity");

  Array<Klass*>* rk = MetadataFactory::new_array<Klass*>(loader_data, num_klasses, CHECK);

  set_resolved_klasses(rk);

}

void ConstantPool::initialize_unresolved_klasses(ClassLoaderData* loader_data, TRAPS) {

  int len = length();

  int num_klasses = 0;

  for (int i = 1; i <len; i++) {

    switch (tag_at(i).value()) {

    case JVM_CONSTANT_ClassIndex:

      {

        const int class_index = klass_index_at(i);

        unresolved_klass_at_put(i, class_index, num_klasses++);

      }

      break;

#ifndef PRODUCT

    case JVM_CONSTANT_Class:

    case JVM_CONSTANT_UnresolvedClass:

    case JVM_CONSTANT_UnresolvedClassInError:

      // All of these should have been reverted back to ClassIndex before calling

      // this function.

      ShouldNotReachHere();

#endif

    }

  }

  allocate_resolved_klasses(loader_data, num_klasses, THREAD);

}

// Anonymous class support:

void ConstantPool::klass_at_put(int class_index, int name_index, int resolved_klass_index, Klass* k, Symbol* name) {

  assert(is_within_bounds(class_index), "index out of bounds");

  assert(is_within_bounds(name_index), "index out of bounds");

  assert((resolved_klass_index & 0xffff0000) == 0, "must be");

  *int_at_addr(class_index) =

    build_int_from_shorts((jushort)resolved_klass_index, (jushort)name_index);

  symbol_at_put(name_index, name);

  name->increment_refcount();

  Klass** adr = resolved_klasses()->adr_at(resolved_klass_index);

  OrderAccess::release_store(adr, k);

  // The interpreter assumes when the tag is stored, the klass is resolved

  // and the Klass* non-NULL, so we need hardware store ordering here.

  if (k != NULL) {

    release_tag_at_put(class_index, JVM_CONSTANT_Class);

  } else {

    release_tag_at_put(class_index, JVM_CONSTANT_UnresolvedClass);

  }

}

// Anonymous class support:

void ConstantPool::klass_at_put(int class_index, Klass* k) {

  assert(k != NULL, "must be valid klass");

  CPKlassSlot kslot = klass_slot_at(class_index);

  int resolved_klass_index = kslot.resolved_klass_index();

  Klass** adr = resolved_klasses()->adr_at(resolved_klass_index);

  OrderAccess::release_store(adr, k);

  // The interpreter assumes when the tag is stored, the klass is resolved

  // and the Klass* non-NULL, so we need hardware store ordering here.

  release_tag_at_put(class_index, JVM_CONSTANT_Class);

}

#if INCLUDE_CDS_JAVA_HEAP

// Archive the resolved references

void ConstantPool::archive_resolved_references(Thread* THREAD) {

  if (_cache == NULL) {

    return; // nothing to do

  }

  InstanceKlass *ik = pool_holder();

  if (!(ik->is_shared_boot_class() || ik->is_shared_platform_class() ||

        ik->is_shared_app_class())) {

    // Archiving resolved references for classes from non-builtin loaders

    // is not yet supported.

    set_resolved_references(NULL);

    return;

  }

  objArrayOop rr = resolved_references();

  Array<u2>* ref_map = reference_map();

  if (rr != NULL) {

    int ref_map_len = ref_map == NULL ? 0 : ref_map->length();

    int rr_len = rr->length();

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

      oop p = rr->obj_at(i);

      rr->obj_at_put(i, NULL);

      if (p != NULL && i < ref_map_len) {

        int index = object_to_cp_index(i);

        // Skip the entry if the string hash code is 0 since the string

        // is not included in the shared string_table, see StringTable::copy_shared_string.

        if (tag_at(index).is_string() && java_lang_String::hash_code(p) != 0) {

          oop op = StringTable::create_archived_string(p, THREAD);

          // If the String object is not archived (possibly too large),

          // NULL is returned. Also set it in the array, so we won't

          // have a 'bad' reference in the archived resolved_reference

          // array.

          rr->obj_at_put(i, op);

        }

      }

    }

    oop archived = MetaspaceShared::archive_heap_object(rr, THREAD);

    _cache->set_archived_references(archived);

    set_resolved_references(NULL);

  }

}

void ConstantPool::resolve_class_constants(TRAPS) {

  assert(DumpSharedSpaces, "used during dump time only");

  // The _cache may be NULL if the _pool_holder klass fails verification

  // at dump time due to missing dependencies.

  if (cache() == NULL || reference_map() == NULL) {

    return; // nothing to do

  }

  constantPoolHandle cp(THREAD, this);

  for (int index = 1; index < length(); index++) { // Index 0 is unused

    if (tag_at(index).is_string() && !cp->is_pseudo_string_at(index)) {

      int cache_index = cp->cp_to_object_index(index);

      string_at_impl(cp, index, cache_index, CHECK);

    }

  }

}

#endif

// CDS support. Create a new resolved_references array.

void ConstantPool::restore_unshareable_info(TRAPS) {

  assert(is_constantPool(), "ensure C++ vtable is restored");

  assert(on_stack(), "should always be set for shared constant pools");

  assert(is_shared(), "should always be set for shared constant pools");

  assert(_cache != NULL, "constant pool _cache should not be NULL");

  // Only create the new resolved references array if it hasn't been attempted before

  if (resolved_references() != NULL) return;

  // restore the C++ vtable from the shared archive

  restore_vtable();

  if (SystemDictionary::Object_klass_loaded()) {

    ClassLoaderData* loader_data = pool_holder()->class_loader_data();

#if INCLUDE_CDS_JAVA_HEAP

      oop archived = _cache->archived_references();

    } else

#endif

    {

      // No mapped archived resolved reference array

      // Recreate the object array and add to ClassLoaderData.

      int map_length = resolved_reference_length();

      if (map_length > 0) {

        objArrayOop stom = oopFactory::new_objArray(SystemDictionary::Object_klass(), map_length, CHECK);

        Handle refs_handle(THREAD, (oop)stom);  // must handleize.

        set_resolved_references(loader_data->add_handle(refs_handle));

      }

    }

  }

}

void ConstantPool::remove_unshareable_info() {

  // Resolved references are not in the shared archive.

  // Save the length for restoration.  It is not necessarily the same length

  // as reference_map.length() if invokedynamic is saved. It is needed when

  // re-creating the resolved reference array if archived heap data cannot be map

  // at runtime.

  set_resolved_reference_length(

    resolved_references() != NULL ? resolved_references()->length() : 0);

  // If archiving heap objects is not allowed, clear the resolved references.

  // Otherwise, it is cleared after the resolved references array is cached

  // (see archive_resolved_references()).

  if (!MetaspaceShared::is_heap_object_archiving_allowed()) {

    set_resolved_references(NULL);

  }

  // Shared ConstantPools are in the RO region, so the _flags cannot be modified.

  // The _on_stack flag is used to prevent ConstantPools from deallocation during

  // class redefinition. Since shared ConstantPools cannot be deallocated anyway,

  // we always set _on_stack to true to avoid having to change _flags during runtime.

  _flags |= (_on_stack | _is_shared);

  int num_klasses = 0;

  for (int index = 1; index < length(); index++) { // Index 0 is unused

    assert(!tag_at(index).is_unresolved_klass_in_error(), "This must not happen during dump time");

    if (tag_at(index).is_klass()) {

      // This class was resolved as a side effect of executing Java code

      // during dump time. We need to restore it back to an UnresolvedClass,

      // so that the proper class loading and initialization can happen

      // at runtime.

      CPKlassSlot kslot = klass_slot_at(index);

      int resolved_klass_index = kslot.resolved_klass_index();

      int name_index = kslot.name_index();

      assert(tag_at(name_index).is_symbol(), "sanity");

      resolved_klasses()->at_put(resolved_klass_index, NULL);

      tag_at_put(index, JVM_CONSTANT_UnresolvedClass);

      assert(klass_name_at(index) == symbol_at(name_index), "sanity");

    }

  }

  if (cache() != NULL) {

    cache()->remove_unshareable_info();

  }

}

int ConstantPool::cp_to_object_index(int cp_index) {

  // this is harder don't do this so much.

  int i = reference_map()->find(cp_index);

  // We might not find the index for jsr292 call.

  return (i < 0) ? _no_index_sentinel : i;

}

void ConstantPool::string_at_put(int which, int obj_index, oop str) {

  resolved_references()->obj_at_put(obj_index, str);

}

void ConstantPool::trace_class_resolution(const constantPoolHandle& this_cp, Klass* k) {

  ResourceMark rm;

  int line_number = -1;

  const char * source_file = NULL;

  if (JavaThread::current()->has_last_Java_frame()) {

    // try to identify the method which called this function.

    vframeStream vfst(JavaThread::current());

    if (!vfst.at_end()) {

      line_number = vfst.method()->line_number_from_bci(vfst.bci());

      Symbol* s = vfst.method()->method_holder()->source_file_name();

      if (s != NULL) {

        source_file = s->as_C_string();

      }

    }

  }

  if (k != this_cp->pool_holder()) {

    // only print something if the classes are different

    if (source_file != NULL) {

      log_debug(class, resolve)("%s %s %s:%d",

                 this_cp->pool_holder()->external_name(),

                 k->external_name(), source_file, line_number);

    } else {

      log_debug(class, resolve)("%s %s",

                 this_cp->pool_holder()->external_name(),

                 k->external_name());

    }

  }

}

Klass* ConstantPool::klass_at_impl(const constantPoolHandle& this_cp, int which,

                                   bool save_resolution_error, TRAPS) {

  assert(THREAD->is_Java_thread(), "must be a Java thread");

  // A resolved constantPool entry will contain a Klass*, otherwise a Symbol*.

  // It is not safe to rely on the tag bit's here, since we don't have a lock, and

  // the entry and tag is not updated atomicly.

  CPKlassSlot kslot = this_cp->klass_slot_at(which);

  int resolved_klass_index = kslot.resolved_klass_index();

  int name_index = kslot.name_index();

  assert(this_cp->tag_at(name_index).is_symbol(), "sanity");

  Klass* klass = this_cp->resolved_klasses()->at(resolved_klass_index);

  if (klass != NULL) {

    return klass;

  }

  // This tag doesn't change back to unresolved class unless at a safepoint.

  if (this_cp->tag_at(which).is_unresolved_klass_in_error()) {

    // The original attempt to resolve this constant pool entry failed so find the

    // class of the original error and throw another error of the same class

    // (JVMS 5.4.3).

    // If there is a detail message, pass that detail message to the error.

    // The JVMS does not strictly require us to duplicate the same detail message,

    // or any internal exception fields such as cause or stacktrace.  But since the

    // detail message is often a class name or other literal string, we will repeat it

    // if we can find it in the symbol table.

    throw_resolution_error(this_cp, which, CHECK_0);

    ShouldNotReachHere();

  }

  Handle mirror_handle;

  Symbol* name = this_cp->symbol_at(name_index);

  Handle loader (THREAD, this_cp->pool_holder()->class_loader());

  Handle protection_domain (THREAD, this_cp->pool_holder()->protection_domain());

  Klass* k = SystemDictionary::resolve_or_fail(name, loader, protection_domain, true, THREAD);

  if (!HAS_PENDING_EXCEPTION) {

    // preserve the resolved klass from unloading

    mirror_handle = Handle(THREAD, k->java_mirror());

    // Do access check for klasses

    verify_constant_pool_resolve(this_cp, k, THREAD);

  }

  // Failed to resolve class. We must record the errors so that subsequent attempts

  // to resolve this constant pool entry fail with the same error (JVMS 5.4.3).

  if (HAS_PENDING_EXCEPTION) {

    if (save_resolution_error) {

      save_and_throw_exception(this_cp, which, constantTag(JVM_CONSTANT_UnresolvedClass), CHECK_NULL);

      // If CHECK_NULL above doesn't return the exception, that means that

      // some other thread has beaten us and has resolved the class.

      // To preserve old behavior, we return the resolved class.

      klass = this_cp->resolved_klasses()->at(resolved_klass_index);

      assert(klass != NULL, "must be resolved if exception was cleared");

      return klass;

    } else {