/*

 * Copyright (c) 1997, 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/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/heapInspection.hpp"

#include "memory/metadataFactory.hpp"

#include "memory/oopFactory.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) {

  // Tags are RW but comment below applies to tags also.

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

  int size = ConstantPool::size(length);

  // CDS considerations:

  // Allocate read-write but may be able to move to read-only at dumping time

  // if all the klasses are resolved.  The only other field that is writable is

  // the resolved_references array, which is recreated at startup time.

  // But that could be moved to InstanceKlass (although a pain to access from

  // assembly code).  Maybe it could be moved to the cpCache which is RW.

  return new (loader_data, size, false, 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) {

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

  set_cache(NULL);

  MetadataFactory::free_array<u2>(loader_data, reference_map());

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

}

objArrayOop ConstantPool::resolved_references() const {

  return (objArrayOop)JNIHandles::resolve(_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));

  }

}

// CDS support. Create a new resolved_references array.

void ConstantPool::restore_unshareable_info(TRAPS) {

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

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

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

      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.

  set_resolved_reference_length(

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

  set_resolved_references(NULL);

}

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, KlassHandle 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(classresolve)("%s %s %s:%d",

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

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

    } else {

      log_debug(classresolve)("%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.

  CPSlot entry = this_cp->slot_at(which);

  if (entry.is_resolved()) {

    assert(entry.get_klass()->is_klass(), "must be");

    // Already resolved - return entry.

    return entry.get_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 = entry.get_symbol();

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

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

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

  KlassHandle k (THREAD, kk);

  if (!HAS_PENDING_EXCEPTION) {

    // preserve the resolved klass from unloading

    mirror_handle = Handle(THREAD, kk->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.

      entry = this_cp->resolved_klass_at(which);

      assert(entry.is_resolved(), "must be resolved if exception was cleared");

      assert(entry.get_klass()->is_klass(), "must be resolved to a klass");

      return entry.get_klass();

    } else {

      return NULL;  // return the pending exception

    }

  }

  // Make this class loader depend upon the class loader owning the class reference

  ClassLoaderData* this_key = this_cp->pool_holder()->class_loader_data();

  this_key->record_dependency(k(), CHECK_NULL); // Can throw OOM

  // logging for classresolve tag.

  trace_class_resolution(this_cp, k);

  this_cp->klass_at_put(which, k());

  entry = this_cp->resolved_klass_at(which);

  assert(entry.is_resolved() && entry.get_klass()->is_klass(), "must be resolved at this point");

  return entry.get_klass();

}

// Does not update ConstantPool* - to avoid any exception throwing. Used

// by compiler and exception handling.  Also used to avoid classloads for

// instanceof operations. Returns NULL if the class has not been loaded or

// if the verification of constant pool failed

Klass* ConstantPool::klass_at_if_loaded(const constantPoolHandle& this_cp, int which) {

  CPSlot entry = this_cp->slot_at(which);

  if (entry.is_resolved()) {

    assert(entry.get_klass()->is_klass(), "must be");

    return entry.get_klass();

  } else {

    assert(entry.is_unresolved(), "must be either symbol or klass");

    Thread *thread = Thread::current();

    Symbol* name = entry.get_symbol();

    oop loader = this_cp->pool_holder()->class_loader();

    oop protection_domain = this_cp->pool_holder()->protection_domain();

    Handle h_prot (thread, protection_domain);

    Handle h_loader (thread, loader);

    Klass* k = SystemDictionary::find(name, h_loader, h_prot, thread);

    if (k != NULL) {

      // Make sure that resolving is legal

      EXCEPTION_MARK;

      KlassHandle klass(THREAD, k);

      // return NULL if verification fails

      verify_constant_pool_resolve(this_cp, klass, THREAD);

      if (HAS_PENDING_EXCEPTION) {

        CLEAR_PENDING_EXCEPTION;

        return NULL;

      }

      return klass();

    } else {

      return k;

    }

  }

}

Klass* ConstantPool::klass_ref_at_if_loaded(const constantPoolHandle& this_cp, int which) {

  return klass_at_if_loaded(this_cp, this_cp->klass_ref_index_at(which));

}

Method* ConstantPool::method_at_if_loaded(const constantPoolHandle& cpool,

                                                   int which) {

  if (cpool->cache() == NULL)  return NULL;  // nothing to load yet

  int cache_index = decode_cpcache_index(which, true);

  if (!(cache_index >= 0 && cache_index < cpool->cache()->length())) {

    // FIXME: should be an assert

    if (PrintMiscellaneous && (Verbose||WizardMode)) {

      tty->print_cr("bad operand %d in:", which); cpool->print();

    }

    return NULL;

  }

  ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);

  return e->method_if_resolved(cpool);

}

bool ConstantPool::has_appendix_at_if_loaded(const constantPoolHandle& cpool, int which) {

  if (cpool->cache() == NULL)  return false;  // nothing to load yet

  int cache_index = decode_cpcache_index(which, true);

  ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);

  return e->has_appendix();

}

oop ConstantPool::appendix_at_if_loaded(const constantPoolHandle& cpool, int which) {

  if (cpool->cache() == NULL)  return NULL;  // nothing to load yet

  int cache_index = decode_cpcache_index(which, true);

  ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);

  return e->appendix_if_resolved(cpool);

}

bool ConstantPool::has_method_type_at_if_loaded(const constantPoolHandle& cpool, int which) {

  if (cpool->cache() == NULL)  return false;  // nothing to load yet

  int cache_index = decode_cpcache_index(which, true);

  ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);

  return e->has_method_type();

}

oop ConstantPool::method_type_at_if_loaded(const constantPoolHandle& cpool, int which) {

  if (cpool->cache() == NULL)  return NULL;  // nothing to load yet

  int cache_index = decode_cpcache_index(which, true);

  ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);

  return e->method_type_if_resolved(cpool);

}

Symbol* ConstantPool::impl_name_ref_at(int which, bool uncached) {

  int name_index = name_ref_index_at(impl_name_and_type_ref_index_at(which, uncached));

  return symbol_at(name_index);

}

Symbol* ConstantPool::impl_signature_ref_at(int which, bool uncached) {

  int signature_index = signature_ref_index_at(impl_name_and_type_ref_index_at(which, uncached));

  return symbol_at(signature_index);

}

int ConstantPool::impl_name_and_type_ref_index_at(int which, bool uncached) {

  int i = which;

  if (!uncached && cache() != NULL) {

    if (ConstantPool::is_invokedynamic_index(which)) {

      // Invokedynamic index is index into resolved_references

      int pool_index = invokedynamic_cp_cache_entry_at(which)->constant_pool_index();

      pool_index = invoke_dynamic_name_and_type_ref_index_at(pool_index);

      assert(tag_at(pool_index).is_name_and_type(), "");

      return pool_index;

    }

    // change byte-ordering and go via cache

    i = remap_instruction_operand_from_cache(which);

  } else {

    if (tag_at(which).is_invoke_dynamic()) {

      int pool_index = invoke_dynamic_name_and_type_ref_index_at(which);

      assert(tag_at(pool_index).is_name_and_type(), "");

      return pool_index;

    }

  }

  assert(tag_at(i).is_field_or_method(), "Corrupted constant pool");

  assert(!tag_at(i).is_invoke_dynamic(), "Must be handled above");

  jint ref_index = *int_at_addr(i);

  return extract_high_short_from_int(ref_index);

}

int ConstantPool::impl_klass_ref_index_at(int which, bool uncached) {

  guarantee(!ConstantPool::is_invokedynamic_index(which),

            "an invokedynamic instruction does not have a klass");

  int i = which;

  if (!uncached && cache() != NULL) {

    // change byte-ordering and go via cache

    i = remap_instruction_operand_from_cache(which);

  }

  assert(tag_at(i).is_field_or_method(), "Corrupted constant pool");

  jint ref_index = *int_at_addr(i);

  return extract_low_short_from_int(ref_index);

}

int ConstantPool::remap_instruction_operand_from_cache(int operand) {

  int cpc_index = operand;

  DEBUG_ONLY(cpc_index -= CPCACHE_INDEX_TAG);

  assert((int)(u2)cpc_index == cpc_index, "clean u2");

  int member_index = cache()->entry_at(cpc_index)->constant_pool_index();

  return member_index;

}

void ConstantPool::verify_constant_pool_resolve(const constantPoolHandle& this_cp, KlassHandle k, TRAPS) {

 if (k->is_instance_klass() || k->is_objArray_klass()) {

    instanceKlassHandle holder (THREAD, this_cp->pool_holder());

    Klass* elem = k->is_instance_klass() ? k() : ObjArrayKlass::cast(k())->bottom_klass();

    KlassHandle element (THREAD, elem);

    // The element type could be a typeArray - we only need the access check if it is

    // an reference to another class

    if (element->is_instance_klass()) {

      LinkResolver::check_klass_accessability(holder, element, CHECK);

    }

  }

}

int ConstantPool::name_ref_index_at(int which_nt) {

  jint ref_index = name_and_type_at(which_nt);

  return extract_low_short_from_int(ref_index);

}

int ConstantPool::signature_ref_index_at(int which_nt) {

  jint ref_index = name_and_type_at(which_nt);

  return extract_high_short_from_int(ref_index);

}

Klass* ConstantPool::klass_ref_at(int which, TRAPS) {

  return klass_at(klass_ref_index_at(which), THREAD);

}

Symbol* ConstantPool::klass_name_at(int which) const {

  assert(tag_at(which).is_unresolved_klass() || tag_at(which).is_klass(),

         "Corrupted constant pool");

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

  CPSlot entry = slot_at(which);

  if (entry.is_resolved()) {

    // Already resolved - return entry's name.

    assert(entry.get_klass()->is_klass(), "must be");

    return entry.get_klass()->name();

  } else {

    assert(entry.is_unresolved(), "must be either symbol or klass");

    return entry.get_symbol();