/*

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

#include "classfile/symbolTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "interpreter/linkResolver.hpp"

#include "memory/metadataFactory.hpp"

#include "memory/oopFactory.hpp"

#include "oops/constantPool.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/objArrayKlass.hpp"

#include "prims/jvmtiRedefineClasses.hpp"

#include "runtime/fieldType.hpp"

#include "runtime/init.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/signature.hpp"

#include "runtime/vframe.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, THREAD) ConstantPool(tags);

}

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

  set_length(tags->length());

  set_tags(NULL);

  set_cache(NULL);

  set_reference_map(NULL);

  set_resolved_references(NULL);

  set_operands(NULL);

  set_pool_holder(NULL);

  set_flags(0);

  // only set to non-zero if constant pool is merged by RedefineClasses

  set_orig_length(0);

  set_lock(new Monitor(Monitor::nonleaf + 2, "A constant pool lock"));

  // all fields are initialized; needed for GC

  set_on_stack(false);

  // initialize tag array

  int length = tags->length();

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

    tags->at_put(index, JVM_CONSTANT_Invalid);

  }

  set_tags(tags);

}

void ConstantPool::deallocate_contents(ClassLoaderData* loader_data) {

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

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

  delete _lock;

  set_lock(NULL);

}

void ConstantPool::set_flag_at(FlagBit fb) {

  const int MAX_STATE_CHANGES = 2;

  for (int i = MAX_STATE_CHANGES + 10; i > 0; i--) {

    int oflags = _flags;

    int nflags = oflags | (1 << (int)fb);

    if (Atomic::cmpxchg(nflags, &_flags, oflags) == oflags)

      return;

  }

  assert(false, "failed to cmpxchg flags");

  _flags |= (1 << (int)fb);     // better than nothing

}

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,

                                                  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.  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, 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) {

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

    }

    // Also need to recreate the mutex.  Make sure this matches the constructor

    set_lock(new Monitor(Monitor::nonleaf + 2, "A constant pool lock"));

  }

}

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

  set_lock(NULL);

}

int ConstantPool::cp_to_object_index(int cp_index) {

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

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

    if (reference_map()->at(i) == cp_index) return i;

    // Zero entry is divider between constant pool indices for strings,

    // method handles and method types. After that the index is a constant

    // pool cache index for invokedynamic.  Stop when zero (which can never

    // be a constant pool index)

    if (reference_map()->at(i) == 0) break;

  }

  // We might not find the index.

  return _no_index_sentinel;

}

Klass* ConstantPool::klass_at_impl(constantPoolHandle this_oop, int which, TRAPS) {

  // 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_oop->slot_at(which);

  if (entry.is_resolved()) {

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

    // Already resolved - return entry.

    return entry.get_klass();

  }

  // Acquire lock on constant oop while doing update. After we get the lock, we check if another object

  // already has updated the object

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

  bool do_resolve = false;

  bool in_error = false;

  // Create a handle for the mirror. This will preserve the resolved class

  // until the loader_data is registered.

  Handle mirror_handle;

  Symbol* name = NULL;

  Handle       loader;

  {  MonitorLockerEx ml(this_oop->lock());

    if (this_oop->tag_at(which).is_unresolved_klass()) {

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

        in_error = true;

      } else {

        do_resolve = true;

        name   = this_oop->unresolved_klass_at(which);

        loader = Handle(THREAD, InstanceKlass::cast(this_oop->pool_holder())->class_loader());

      }

    }

  } // unlocking constantPool

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

  // original error and throw it again (JVMS 5.4.3).

  if (in_error) {

    Symbol* error = SystemDictionary::find_resolution_error(this_oop, which);

    guarantee(error != (Symbol*)NULL, "tag mismatch with resolution error table");

    ResourceMark rm;

    // exception text will be the class name

    const char* className = this_oop->unresolved_klass_at(which)->as_C_string();

    THROW_MSG_0(error, className);

  }

  if (do_resolve) {

    // this_oop must be unlocked during resolve_or_fail

    oop protection_domain = Klass::cast(this_oop->pool_holder())->protection_domain();

    Handle h_prot (THREAD, protection_domain);

    Klass* k_oop = SystemDictionary::resolve_or_fail(name, loader, h_prot, true, THREAD);

    KlassHandle k;

    if (!HAS_PENDING_EXCEPTION) {

      k = KlassHandle(THREAD, k_oop);

      // preserve the resolved klass.

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

      // Do access check for klasses

      verify_constant_pool_resolve(this_oop, 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) {

      ResourceMark rm;

      Symbol* error = PENDING_EXCEPTION->klass()->name();

      bool throw_orig_error = false;

      {

        MonitorLockerEx ml(this_oop->lock());

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

        if (this_oop->tag_at(which).is_klass()) {

          CLEAR_PENDING_EXCEPTION;

          entry = this_oop->resolved_klass_at(which);

          return entry.get_klass();

        }

        if (!PENDING_EXCEPTION->

              is_a(SystemDictionary::LinkageError_klass())) {

          // Just throw the exception and don't prevent these classes from

          // being loaded due to virtual machine errors like StackOverflow

          // and OutOfMemoryError, etc, or if the thread was hit by stop()

          // Needs clarification to section 5.4.3 of the VM spec (see 6308271)

        }

        else if (!this_oop->tag_at(which).is_unresolved_klass_in_error()) {

          SystemDictionary::add_resolution_error(this_oop, which, error);

          this_oop->tag_at_put(which, JVM_CONSTANT_UnresolvedClassInError);

        } else {

          // some other thread has put the class in error state.

          error = SystemDictionary::find_resolution_error(this_oop, which);

          assert(error != NULL, "checking");

          throw_orig_error = true;

        }

      } // unlocked

      if (throw_orig_error) {

        CLEAR_PENDING_EXCEPTION;

        ResourceMark rm;

        const char* className = this_oop->unresolved_klass_at(which)->as_C_string();

        THROW_MSG_0(error, className);

      }

      return 0;

    }

    if (TraceClassResolution && !k()->oop_is_array()) {

      // skip resolving the constant pool so that this code get's

      // called the next time some bytecodes refer to this class.

      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 = InstanceKlass::cast(vfst.method()->method_holder())->source_file_name();

          if (s != NULL) {

            source_file = s->as_C_string();

          }

        }

      }

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

        // only print something if the classes are different

        if (source_file != NULL) {

          tty->print("RESOLVE %s %s %s:%d\n",

                     InstanceKlass::cast(this_oop->pool_holder())->external_name(),

                     InstanceKlass::cast(k())->external_name(), source_file, line_number);

        } else {

          tty->print("RESOLVE %s %s\n",

                     InstanceKlass::cast(this_oop->pool_holder())->external_name(),

                     InstanceKlass::cast(k())->external_name());

        }

      }

      return k();

    } else {

      MonitorLockerEx ml(this_oop->lock());

      // Only updated constant pool - if it is resolved.

      do_resolve = this_oop->tag_at(which).is_unresolved_klass();

      if (do_resolve) {

        ClassLoaderData* this_key = InstanceKlass::cast(this_oop->pool_holder())->class_loader_data();

        if (!this_key->is_the_null_class_loader_data()) {

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

        }

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

      }

    }

  }

  entry = this_oop->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(constantPoolHandle this_oop, int which) {

  CPSlot entry = this_oop->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 = InstanceKlass::cast(this_oop->pool_holder())->class_loader();

    oop protection_domain = Klass::cast(this_oop->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_oop, klass, THREAD);

      if (HAS_PENDING_EXCEPTION) {

        CLEAR_PENDING_EXCEPTION;

        return NULL;

      }

      return klass();

    } else {

      return k;

    }

  }

}

Klass* ConstantPool::klass_ref_at_if_loaded(constantPoolHandle this_oop, int which) {

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

}

// This is an interface for the compiler that allows accessing non-resolved entries

// in the constant pool - but still performs the validations tests. Must be used

// in a pre-parse of the compiler - to determine what it can do and not do.

// Note: We cannot update the ConstantPool from the vm_thread.

Klass* ConstantPool::klass_ref_at_if_loaded_check(constantPoolHandle this_oop, int index, TRAPS) {

  int which = this_oop->klass_ref_index_at(index);

  CPSlot entry = this_oop->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");

    Symbol*  name  = entry.get_symbol();

    oop loader = InstanceKlass::cast(this_oop->pool_holder())->class_loader();

    oop protection_domain = Klass::cast(this_oop->pool_holder())->protection_domain();

    Handle h_loader(THREAD, loader);

    Handle h_prot  (THREAD, protection_domain);

    KlassHandle k(THREAD, SystemDictionary::find(name, h_loader, h_prot, THREAD));

    // Do access check for klasses

    if( k.not_null() ) verify_constant_pool_resolve(this_oop, k, CHECK_NULL);

    return k();

  }

}

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

}

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