/*

 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.

 * Copyright (c) 2012 Red Hat, Inc.

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

#include "classfile/altHashing.hpp"

#include "classfile/classLoader.hpp"

#include "classfile/javaClasses.hpp"

#include "classfile/symbolTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "interpreter/linkResolver.hpp"

#include "utilities/macros.hpp"

#if INCLUDE_ALL_GCS

#include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"

#endif // INCLUDE_ALL_GCS

#include "memory/allocation.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/gcLocker.inline.hpp"

#include "memory/oopFactory.hpp"

#include "memory/universe.inline.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/instanceOop.hpp"

#include "oops/markOop.hpp"

#include "oops/method.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/objArrayOop.hpp"

#include "oops/oop.inline.hpp"

#include "oops/symbol.hpp"

#include "oops/typeArrayKlass.hpp"

#include "oops/typeArrayOop.hpp"

#include "prims/jni.h"

#include "prims/jniCheck.hpp"

#include "prims/jniExport.hpp"

#include "prims/jniFastGetField.hpp"

#include "prims/jvm.h"

#include "prims/jvm_misc.hpp"

#include "prims/jvmtiExport.hpp"

#include "prims/jvmtiThreadState.hpp"

#include "runtime/compilationPolicy.hpp"

#include "runtime/fieldDescriptor.hpp"

#include "runtime/fprofiler.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/interfaceSupport.hpp"

#include "runtime/java.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/jfieldIDWorkaround.hpp"

#include "runtime/reflection.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/signature.hpp"

#include "runtime/thread.inline.hpp"

#include "runtime/vm_operations.hpp"

#include "services/runtimeService.hpp"

#include "trace/tracing.hpp"

#include "utilities/defaultStream.hpp"

#include "utilities/dtrace.hpp"

#include "utilities/events.hpp"

#include "utilities/histogram.hpp"

#ifdef TARGET_OS_FAMILY_linux

# include "os_linux.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_solaris

# include "os_solaris.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_windows

# include "os_windows.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_bsd

# include "os_bsd.inline.hpp"

#endif

static jint CurrentVersion = JNI_VERSION_1_8;

// The DT_RETURN_MARK macros create a scoped object to fire the dtrace

// '-return' probe regardless of the return path is taken out of the function.

// Methods that have multiple return paths use this to avoid having to

// instrument each return path.  Methods that use CHECK or THROW must use this

// since those macros can cause an immedate uninstrumented return.

//

// In order to get the return value, a reference to the variable containing

// the return value must be passed to the contructor of the object, and

// the return value must be set before return (since the mark object has

// a reference to it).

//

// Example:

// DT_RETURN_MARK_DECL(SomeFunc, int);

// JNI_ENTRY(int, SomeFunc, ...)

//   int return_value = 0;

//   DT_RETURN_MARK(SomeFunc, int, (const int&)return_value);

//   foo(CHECK_0)

//   return_value = 5;

//   return return_value;

// JNI_END

#ifndef USDT2

#define DT_RETURN_MARK_DECL(name, type)                                    \

  HS_DTRACE_PROBE_DECL1(hotspot_jni, name##__return, type);                \

  DTRACE_ONLY(                                                             \

    class DTraceReturnProbeMark_##name {                                   \

     public:                                                               \

      const type& _ret_ref;                                                \

      DTraceReturnProbeMark_##name(const type& v) : _ret_ref(v) {}         \

      ~DTraceReturnProbeMark_##name() {                                    \

        HS_DTRACE_PROBE1(hotspot_jni, name##__return, _ret_ref);           \

      }                                                                    \

    }                                                                      \

  )

// Void functions are simpler since there's no return value

#define DT_VOID_RETURN_MARK_DECL(name)                                     \

  HS_DTRACE_PROBE_DECL0(hotspot_jni, name##__return);                      \

  DTRACE_ONLY(                                                             \

    class DTraceReturnProbeMark_##name {                                   \

     public:                                                               \

      ~DTraceReturnProbeMark_##name() {                                    \

        HS_DTRACE_PROBE0(hotspot_jni, name##__return);                     \

      }                                                                    \

    }                                                                      \

  )

#else /* USDT2 */

#define DT_RETURN_MARK_DECL(name, type, probe)                             \

  DTRACE_ONLY(                                                             \

    class DTraceReturnProbeMark_##name {                                   \

     public:                                                               \

      const type& _ret_ref;                                                \

      DTraceReturnProbeMark_##name(const type& v) : _ret_ref(v) {}         \

      ~DTraceReturnProbeMark_##name() {                                    \

        probe;                                                             \

      }                                                                    \

    }                                                                      \

  )

// Void functions are simpler since there's no return value

#define DT_VOID_RETURN_MARK_DECL(name, probe)                              \

  DTRACE_ONLY(                                                             \

    class DTraceReturnProbeMark_##name {                                   \

     public:                                                               \

      ~DTraceReturnProbeMark_##name() {                                    \

        probe;                                                             \

      }                                                                    \

    }                                                                      \

  )

#endif /* USDT2 */

// Place these macros in the function to mark the return.  Non-void

// functions need the type and address of the return value.

#define DT_RETURN_MARK(name, type, ref) \

  DTRACE_ONLY( DTraceReturnProbeMark_##name dtrace_return_mark(ref) )

#define DT_VOID_RETURN_MARK(name) \

  DTRACE_ONLY( DTraceReturnProbeMark_##name dtrace_return_mark )

// Use these to select distinct code for floating-point vs. non-floating point

// situations.  Used from within common macros where we need slightly

// different behavior for Float/Double

#define FP_SELECT_Boolean(intcode, fpcode) intcode

#define FP_SELECT_Byte(intcode, fpcode)    intcode

#define FP_SELECT_Char(intcode, fpcode)    intcode

#define FP_SELECT_Short(intcode, fpcode)   intcode

#define FP_SELECT_Object(intcode, fpcode)  intcode

#define FP_SELECT_Int(intcode, fpcode)     intcode

#define FP_SELECT_Long(intcode, fpcode)    intcode

#define FP_SELECT_Float(intcode, fpcode)   fpcode

#define FP_SELECT_Double(intcode, fpcode)  fpcode

#define FP_SELECT(TypeName, intcode, fpcode) \

  FP_SELECT_##TypeName(intcode, fpcode)

#define COMMA ,

// Choose DT_RETURN_MARK macros  based on the type: float/double -> void

// (dtrace doesn't do FP yet)

#ifndef USDT2

#define DT_RETURN_MARK_DECL_FOR(TypeName, name, type) \

  FP_SELECT(TypeName, \

    DT_RETURN_MARK_DECL(name, type), DT_VOID_RETURN_MARK_DECL(name) )

#else /* USDT2 */

#define DT_RETURN_MARK_DECL_FOR(TypeName, name, type, probe)    \

  FP_SELECT(TypeName, \

    DT_RETURN_MARK_DECL(name, type, probe), DT_VOID_RETURN_MARK_DECL(name, probe) )

#endif /* USDT2 */

#define DT_RETURN_MARK_FOR(TypeName, name, type, ref) \

  FP_SELECT(TypeName, \

    DT_RETURN_MARK(name, type, ref), DT_VOID_RETURN_MARK(name) )

// out-of-line helpers for class jfieldIDWorkaround:

bool jfieldIDWorkaround::is_valid_jfieldID(Klass* k, jfieldID id) {

  if (jfieldIDWorkaround::is_instance_jfieldID(k, id)) {

    uintptr_t as_uint = (uintptr_t) id;

    intptr_t offset = raw_instance_offset(id);

    if (is_checked_jfieldID(id)) {

      if (!klass_hash_ok(k, id)) {

        return false;

      }

    }

    return InstanceKlass::cast(k)->contains_field_offset(offset);

  } else {

    JNIid* result = (JNIid*) id;

#ifdef ASSERT

    return result != NULL && result->is_static_field_id();

#else

    return result != NULL;

#endif

  }

}

intptr_t jfieldIDWorkaround::encode_klass_hash(Klass* k, intptr_t offset) {

  if (offset <= small_offset_mask) {

    Klass* field_klass = k;

    Klass* super_klass = field_klass->super();

    // With compressed oops the most super class with nonstatic fields would

    // be the owner of fields embedded in the header.

    while (InstanceKlass::cast(super_klass)->has_nonstatic_fields() &&

           InstanceKlass::cast(super_klass)->contains_field_offset(offset)) {

      field_klass = super_klass;   // super contains the field also

      super_klass = field_klass->super();

    }

    debug_only(No_Safepoint_Verifier nosafepoint;)

    uintptr_t klass_hash = field_klass->identity_hash();

    return ((klass_hash & klass_mask) << klass_shift) | checked_mask_in_place;

  } else {

#if 0

    #ifndef PRODUCT

    {

      ResourceMark rm;

      warning("VerifyJNIFields: long offset %d in %s", offset, k->external_name());

    }

    #endif

#endif

    return 0;

  }

}

bool jfieldIDWorkaround::klass_hash_ok(Klass* k, jfieldID id) {

  uintptr_t as_uint = (uintptr_t) id;

  intptr_t klass_hash = (as_uint >> klass_shift) & klass_mask;

  do {

    debug_only(No_Safepoint_Verifier nosafepoint;)

    // Could use a non-blocking query for identity_hash here...

    if ((k->identity_hash() & klass_mask) == klass_hash)

      return true;

    k = k->super();

  } while (k != NULL);

  return false;

}

void jfieldIDWorkaround::verify_instance_jfieldID(Klass* k, jfieldID id) {

  guarantee(jfieldIDWorkaround::is_instance_jfieldID(k, id), "must be an instance field" );

  uintptr_t as_uint = (uintptr_t) id;

  intptr_t offset = raw_instance_offset(id);

  if (VerifyJNIFields) {

    if (is_checked_jfieldID(id)) {

      guarantee(klass_hash_ok(k, id),

    "Bug in native code: jfieldID class must match object");

    } else {

#if 0

      #ifndef PRODUCT

      if (Verbose) {

  ResourceMark rm;

  warning("VerifyJNIFields: unverified offset %d for %s", offset, k->external_name());

      }

      #endif

#endif

    }

  }

  guarantee(InstanceKlass::cast(k)->contains_field_offset(offset),

      "Bug in native code: jfieldID offset must address interior of object");

}

// Pick a reasonable higher bound for local capacity requested

// for EnsureLocalCapacity and PushLocalFrame.  We don't want it too

// high because a test (or very unusual application) may try to allocate

// that many handles and run out of swap space.  An implementation is

// permitted to allocate more handles than the ensured capacity, so this

// value is set high enough to prevent compatibility problems.

const int MAX_REASONABLE_LOCAL_CAPACITY = 4*K;

// Wrapper to trace JNI functions

#ifdef ASSERT

  Histogram* JNIHistogram;

  static volatile jint JNIHistogram_lock = 0;

  class JNITraceWrapper : public StackObj {

   public:

    JNITraceWrapper(const char* format, ...) {

      if (TraceJNICalls) {

        va_list ap;

        va_start(ap, format);

        tty->print("JNI ");

        tty->vprint_cr(format, ap);

        va_end(ap);

      }

    }

  };

  class JNIHistogramElement : public HistogramElement {

    public:

     JNIHistogramElement(const char* name);

  };

  JNIHistogramElement::JNIHistogramElement(const char* elementName) {

    _name = elementName;

    uintx count = 0;

    while (Atomic::cmpxchg(1, &JNIHistogram_lock, 0) != 0) {

      while (OrderAccess::load_acquire(&JNIHistogram_lock) != 0) {

        count +=1;

        if ( (WarnOnStalledSpinLock > 0)

          && (count % WarnOnStalledSpinLock == 0)) {

          warning("JNIHistogram_lock seems to be stalled");

        }

      }

     }

    if(JNIHistogram == NULL)

      JNIHistogram = new Histogram("JNI Call Counts",100);

    JNIHistogram->add_element(this);

    Atomic::dec(&JNIHistogram_lock);

  }

  #define JNICountWrapper(arg)                                     \

     static JNIHistogramElement* e = new JNIHistogramElement(arg); \

      /* There is a MT-race condition in VC++. So we need to make sure that that e has been initialized */ \

     if (e != NULL) e->increment_count()

  #define JNIWrapper(arg) JNICountWrapper(arg); JNITraceWrapper(arg)

#else

  #define JNIWrapper(arg)

#endif

// Implementation of JNI entries

#ifndef USDT2

DT_RETURN_MARK_DECL(DefineClass, jclass);

#else /* USDT2 */

DT_RETURN_MARK_DECL(DefineClass, jclass

                    , HOTSPOT_JNI_DEFINECLASS_RETURN(_ret_ref));

#endif /* USDT2 */

JNI_ENTRY(jclass, jni_DefineClass(JNIEnv *env, const char *name, jobject loaderRef,

                                  const jbyte *buf, jsize bufLen))

  JNIWrapper("DefineClass");

#ifndef USDT2

  DTRACE_PROBE5(hotspot_jni, DefineClass__entry,

    env, name, loaderRef, buf, bufLen);

#else /* USDT2 */

  HOTSPOT_JNI_DEFINECLASS_ENTRY(

    env, (char*) name, loaderRef, (char*) buf, bufLen);

#endif /* USDT2 */

  jclass cls = NULL;

  DT_RETURN_MARK(DefineClass, jclass, (const jclass&)cls);

  TempNewSymbol class_name = NULL;

  // Since exceptions can be thrown, class initialization can take place

  // if name is NULL no check for class name in .class stream has to be made.

  if (name != NULL) {

    const int str_len = (int)strlen(name);

    if (str_len > Symbol::max_length()) {

      // It's impossible to create this class;  the name cannot fit

      // into the constant pool.

      THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name);

    }

    class_name = SymbolTable::new_symbol(name, CHECK_NULL);

  }

  ResourceMark rm(THREAD);

  ClassFileStream st((u1*) buf, bufLen, NULL);

  Handle class_loader (THREAD, JNIHandles::resolve(loaderRef));

  if (UsePerfData && !class_loader.is_null()) {

    // check whether the current caller thread holds the lock or not.

    // If not, increment the corresponding counter

    if (ObjectSynchronizer::

        query_lock_ownership((JavaThread*)THREAD, class_loader) !=

        ObjectSynchronizer::owner_self) {

      ClassLoader::sync_JNIDefineClassLockFreeCounter()->inc();

    }

  }

  Klass* k = SystemDictionary::resolve_from_stream(class_name, class_loader,

                                                     Handle(), &st, true,

                                                     CHECK_NULL);

  if (TraceClassResolution && k != NULL) {

    trace_class_resolution(k);

  }

  cls = (jclass)JNIHandles::make_local(

    env, k->java_mirror());

  return cls;

JNI_END

static bool first_time_FindClass = true;

#ifndef USDT2

DT_RETURN_MARK_DECL(FindClass, jclass);

#else /* USDT2 */

DT_RETURN_MARK_DECL(FindClass, jclass

                    , HOTSPOT_JNI_FINDCLASS_RETURN(_ret_ref));

#endif /* USDT2 */

JNI_ENTRY(jclass, jni_FindClass(JNIEnv *env, const char *name))

  JNIWrapper("FindClass");

#ifndef USDT2

  DTRACE_PROBE2(hotspot_jni, FindClass__entry, env, name);

#else /* USDT2 */

  HOTSPOT_JNI_FINDCLASS_ENTRY(env, (char *)name);

#endif /* USDT2 */

  jclass result = NULL;

  DT_RETURN_MARK(FindClass, jclass, (const jclass&)result);

  // Remember if we are the first invocation of jni_FindClass

  bool first_time = first_time_FindClass;

  first_time_FindClass = false;

  // Sanity check the name:  it cannot be null or larger than the maximum size

  // name we can fit in the constant pool.

  if (name == NULL || (int)strlen(name) > Symbol::max_length()) {

    THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name);

  }

  //%note jni_3

  Handle loader;

  Handle protection_domain;

  // Find calling class

  instanceKlassHandle k (THREAD, thread->security_get_caller_class(0));

  if (k.not_null()) {

    loader = Handle(THREAD, k->class_loader());

    // Special handling to make sure JNI_OnLoad and JNI_OnUnload are executed

    // in the correct class context.

    if (loader.is_null() &&

        k->name() == vmSymbols::java_lang_ClassLoader_NativeLibrary()) {

      JavaValue result(T_OBJECT);

      JavaCalls::call_static(&result, k,

                                      vmSymbols::getFromClass_name(),

                                      vmSymbols::void_class_signature(),

                                      thread);

      if (HAS_PENDING_EXCEPTION) {

        Handle ex(thread, thread->pending_exception());

        CLEAR_PENDING_EXCEPTION;

        THROW_HANDLE_0(ex);

      }

      oop mirror = (oop) result.get_jobject();

      loader = Handle(THREAD,

        InstanceKlass::cast(java_lang_Class::as_Klass(mirror))->class_loader());

      protection_domain = Handle(THREAD,

        InstanceKlass::cast(java_lang_Class::as_Klass(mirror))->protection_domain());

    }

  } else {

    // We call ClassLoader.getSystemClassLoader to obtain the system class loader.

    loader = Handle(THREAD, SystemDictionary::java_system_loader());

  }

  TempNewSymbol sym = SymbolTable::new_symbol(name, CHECK_NULL);

  result = find_class_from_class_loader(env, sym, true, loader,

                                        protection_domain, true, thread);

  if (TraceClassResolution && result != NULL) {

    trace_class_resolution(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(result)));

  }

  // If we were the first invocation of jni_FindClass, we enable compilation again

  // rather than just allowing invocation counter to overflow and decay.

  // Controlled by flag DelayCompilationDuringStartup.

  if (first_time && !CompileTheWorld)

    CompilationPolicy::completed_vm_startup();

  return result;

JNI_END

#ifndef USDT2

DT_RETURN_MARK_DECL(FromReflectedMethod, jmethodID);

#else /* USDT2 */

DT_RETURN_MARK_DECL(FromReflectedMethod, jmethodID

                    , HOTSPOT_JNI_FROMREFLECTEDMETHOD_RETURN((uintptr_t)_ret_ref));

#endif /* USDT2 */

JNI_ENTRY(jmethodID, jni_FromReflectedMethod(JNIEnv *env, jobject method))

  JNIWrapper("FromReflectedMethod");

#ifndef USDT2