/*

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

#include "classfile/symbolTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "interpreter/linkResolver.hpp"

#include "memory/oopFactory.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/objArrayKlass.hpp"

#include "runtime/fieldType.hpp"

#include "runtime/init.hpp"

#include "runtime/signature.hpp"

#include "runtime/vframe.hpp"

  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

}

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

    // Already resolved - return 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;

  Symbol* name = NULL;

  Handle       loader;

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

      }

    }

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

    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;

      bool throw_orig_error = false;

      {

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

        }

        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;

    }

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

          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",

        } else {

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

        }

      }

      return k();

    } else {

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

}

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

  CPSlot entry = this_oop->slot_at(which);

  } else {

    Thread *thread = Thread::current();

    Symbol* name = entry.get_symbol();

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

    Handle h_prot (thread, protection_domain);

    Handle h_loader (thread, loader);

    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;

    }

  }

}

  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.

  int which = this_oop->klass_ref_index_at(index);

  CPSlot entry = this_oop->slot_at(which);

  } else {

    Symbol*  name  = entry.get_symbol();

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

  }

}

                                                   int which) {

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

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

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

}

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

  return e->has_appendix();

}

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

}

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

  return symbol_at(name_index);

}

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

  return symbol_at(signature_index);

}

  int i = which;

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

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

}

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