/*

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

#include "classfile/symbolTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "interpreter/linkResolver.hpp"

#include "memory/oopFactory.hpp"

#include "memory/universe.inline.hpp"

#include "oops/constantPoolOop.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/oop.inline.hpp"

#include "runtime/fieldType.hpp"

#include "runtime/init.hpp"

#include "runtime/signature.hpp"

#include "runtime/vframe.hpp"

void constantPoolOopDesc::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

}

klassOop constantPoolOopDesc::klass_at_impl(constantPoolHandle this_oop, int which, TRAPS) {

  // A resolved constantPool entry will contain a klassOop, otherwise a symbolOop.

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

  oop entry = *(this_oop->obj_at_addr(which));

  if (entry->is_klass()) {

    // Already resolved - return entry.

    return (klassOop)entry;

  }

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

  symbolHandle name;

  Handle       loader;

  { ObjectLocker ol(this_oop, THREAD);

    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   = symbolHandle(THREAD, 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) {

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

    guarantee(error != (symbolOop)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);

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

    KlassHandle k;

    if (!HAS_PENDING_EXCEPTION) {

      k = KlassHandle(THREAD, k_oop);

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

      symbolHandle error(PENDING_EXCEPTION->klass()->klass_part()->name());

      bool throw_orig_error = false;

      {

        ObjectLocker ol (this_oop, THREAD);

        // 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 (klassOop)entry;

        }

        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 = symbolHandle(SystemDictionary::find_resolution_error(this_oop, which));

          assert(!error.is_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()->klass_part()->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());

          symbolOop 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 {

      ObjectLocker ol (this_oop, THREAD);

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

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

      if (do_resolve) {

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

      }

    }

  }

  entry = this_oop->resolved_klass_at(which);

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

  return (klassOop)entry;

}

// Does not update constantPoolOop - 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

klassOop constantPoolOopDesc::klass_at_if_loaded(constantPoolHandle this_oop, int which) {

  oop entry = *this_oop->obj_at_addr(which);

  if (entry->is_klass()) {

    return (klassOop)entry;

  } else {

    assert(entry->is_symbol(), "must be either symbol or klass");

    Thread *thread = Thread::current();

    symbolHandle name (thread, (symbolOop)entry);

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

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

    }

  }

}

klassOop constantPoolOopDesc::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.

klassOop constantPoolOopDesc::klass_ref_at_if_loaded_check(constantPoolHandle this_oop, int index, TRAPS) {

  int which = this_oop->klass_ref_index_at(index);

  oop entry = *this_oop->obj_at_addr(which);

  if (entry->is_klass()) {

    return (klassOop)entry;

  } else {

    assert(entry->is_symbol(), "must be either symbol or klass");

    symbolHandle name (THREAD, (symbolOop)entry);

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

  }

}

symbolOop constantPoolOopDesc::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);

}

symbolOop constantPoolOopDesc::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 constantPoolOopDesc::impl_name_and_type_ref_index_at(int which, bool uncached) {

  int i = which;

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

    if (constantPoolCacheOopDesc::is_secondary_index(which)) {

      // Invokedynamic index.

      int pool_index = cache()->main_entry_at(which)->constant_pool_index();

      if (!AllowTransitionalJSR292 || tag_at(pool_index).is_invoke_dynamic())

        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 (AllowTransitionalJSR292 && tag_at(which).is_name_and_type())

      // invokedynamic index is a simple name-and-type

      return which;

    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 constantPoolOopDesc::impl_klass_ref_index_at(int which, bool uncached) {

  guarantee(!constantPoolCacheOopDesc::is_secondary_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 constantPoolOopDesc::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 constantPoolOopDesc::verify_constant_pool_resolve(constantPoolHandle this_oop, KlassHandle k, TRAPS) {

 if (k->oop_is_instance() || k->oop_is_objArray()) {

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

    klassOop elem_oop = k->oop_is_instance() ? k() : objArrayKlass::cast(k())->bottom_klass();

    KlassHandle element (THREAD, elem_oop);

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

    // an reference to another class

    if (element->oop_is_instance()) {

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

    }

  }

}

int constantPoolOopDesc::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 constantPoolOopDesc::signature_ref_index_at(int which_nt) {

  jint ref_index = name_and_type_at(which_nt);

  return extract_high_short_from_int(ref_index);

}

klassOop constantPoolOopDesc::klass_ref_at(int which, TRAPS) {

  return klass_at(klass_ref_index_at(which), CHECK_NULL);

}

symbolOop constantPoolOopDesc::klass_name_at(int which) {

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

         "Corrupted constant pool");

  // A resolved constantPool entry will contain a klassOop, otherwise a symbolOop.

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

  oop entry = *(obj_at_addr(which));

  if (entry->is_klass()) {

    // Already resolved - return entry's name.

    return klassOop(entry)->klass_part()->name();

  } else {

    assert(entry->is_symbol(), "must be either symbol or klass");

    return (symbolOop)entry;

  }

}

symbolOop constantPoolOopDesc::klass_ref_at_noresolve(int which) {

  jint ref_index = klass_ref_index_at(which);

  return klass_at_noresolve(ref_index);

}

symbolOop constantPoolOopDesc::uncached_klass_ref_at_noresolve(int which) {

  jint ref_index = uncached_klass_ref_index_at(which);

  return klass_at_noresolve(ref_index);

}

char* constantPoolOopDesc::string_at_noresolve(int which) {

  // Test entry type in case string is resolved while in here.

  oop entry = *(obj_at_addr(which));

  if (entry->is_symbol()) {

    return ((symbolOop)entry)->as_C_string();

  } else if (java_lang_String::is_instance(entry)) {

    return java_lang_String::as_utf8_string(entry);

  } else {

    return (char*)"<pseudo-string>";

  }

}

BasicType constantPoolOopDesc::basic_type_for_signature_at(int which) {

  return FieldType::basic_type(symbol_at(which));

}

void constantPoolOopDesc::resolve_string_constants_impl(constantPoolHandle this_oop, TRAPS) {

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

    if (this_oop->tag_at(index).is_unresolved_string()) {

      this_oop->string_at(index, CHECK);

    }

  }

}

// A resolved constant value in the CP cache is represented as a non-null

// value.  As a special case, this value can be a 'systemObjArray'

// which masks an exception object to throw.

// This allows a MethodHandle constant reference to throw a consistent

// exception every time, if it fails to resolve.

static oop decode_exception_from_f1(oop result_oop, TRAPS) {

  if (result_oop->klass() != Universe::systemObjArrayKlassObj())

    return result_oop;

  // Special cases here:  Masked null, saved exception.

  objArrayOop sys_array = (objArrayOop) result_oop;

  assert(sys_array->length() == 1, "bad system array");

  if (sys_array->length() == 1) {

    THROW_OOP_(sys_array->obj_at(0), NULL);

  }

  return NULL;

}

oop constantPoolOopDesc::resolve_constant_at_impl(constantPoolHandle this_oop, int index, int cache_index, TRAPS) {

  oop result_oop = NULL;

  Handle throw_exception;

  if (cache_index == _possible_index_sentinel) {

    // It is possible that this constant is one which is cached in the CP cache.

    // We'll do a linear search.  This should be OK because this usage is rare.

    assert(index > 0, "valid index");

    constantPoolCacheOop cache = this_oop()->cache();

    for (int i = 0, len = cache->length(); i < len; i++) {

      ConstantPoolCacheEntry* cpc_entry = cache->entry_at(i);

      if (!cpc_entry->is_secondary_entry() && cpc_entry->constant_pool_index() == index) {

        // Switch the query to use this CPC entry.

        cache_index = i;

        index = _no_index_sentinel;

        break;

      }

    }

    if (cache_index == _possible_index_sentinel)

      cache_index = _no_index_sentinel;  // not found

  }

  assert(cache_index == _no_index_sentinel || cache_index >= 0, "");

  assert(index == _no_index_sentinel || index >= 0, "");

  if (cache_index >= 0) {

    assert(index == _no_index_sentinel, "only one kind of index at a time");

    ConstantPoolCacheEntry* cpc_entry = this_oop->cache()->entry_at(cache_index);

    result_oop = cpc_entry->f1();

    if (result_oop != NULL) {

      return decode_exception_from_f1(result_oop, THREAD);

      // That was easy...

    }

    index = cpc_entry->constant_pool_index();

  }

  jvalue prim_value;  // temp used only in a few cases below

  int tag_value = this_oop->tag_at(index).value();

  switch (tag_value) {

  case JVM_CONSTANT_UnresolvedClass:

  case JVM_CONSTANT_UnresolvedClassInError:

  case JVM_CONSTANT_Class:

    {

      klassOop resolved = klass_at_impl(this_oop, index, CHECK_NULL);

      // ldc wants the java mirror.

      result_oop = resolved->klass_part()->java_mirror();

      break;

    }

  case JVM_CONSTANT_String:

  case JVM_CONSTANT_UnresolvedString:

    if (this_oop->is_pseudo_string_at(index)) {

      result_oop = this_oop->pseudo_string_at(index);

      break;

    }

    result_oop = string_at_impl(this_oop, index, CHECK_NULL);

    break;

  case JVM_CONSTANT_Object:

    result_oop = this_oop->object_at(index);

    break;

  case JVM_CONSTANT_MethodHandle:

    {

      int ref_kind                 = this_oop->method_handle_ref_kind_at(index);

      int callee_index             = this_oop->method_handle_klass_index_at(index);

      symbolHandle name(THREAD,      this_oop->method_handle_name_ref_at(index));

      symbolHandle signature(THREAD, this_oop->method_handle_signature_ref_at(index));

      if (PrintMiscellaneous)

        tty->print_cr("resolve JVM_CONSTANT_MethodHandle:%d [%d/%d/%d] %s.%s",

                      ref_kind, index, this_oop->method_handle_index_at(index),

                      callee_index, name->as_C_string(), signature->as_C_string());

      KlassHandle callee;

      { klassOop k = klass_at_impl(this_oop, callee_index, CHECK_NULL);

        callee = KlassHandle(THREAD, k);

      }

      KlassHandle klass(THREAD, this_oop->pool_holder());

      Handle value = SystemDictionary::link_method_handle_constant(klass, ref_kind,