/*

 * Copyright (c) 1997, 2018, 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 "jni.h"

#include "jvm.h"

#include "ci/ciReplay.hpp"

#include "classfile/altHashing.hpp"

#include "classfile/classFileStream.hpp"

#include "classfile/classLoader.hpp"

#include "classfile/javaClasses.hpp"

#include "classfile/javaClasses.inline.hpp"

#include "classfile/modules.hpp"

#include "classfile/symbolTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "interpreter/linkResolver.hpp"

#include "memory/allocation.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/oopFactory.hpp"

#include "memory/resourceArea.hpp"

#include "memory/universe.hpp"

#include "oops/access.inline.hpp"

#include "oops/arrayOop.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.inline.hpp"

#include "oops/oop.inline.hpp"

#include "oops/symbol.hpp"

#include "oops/typeArrayKlass.hpp"

#include "oops/typeArrayOop.inline.hpp"

#include "prims/jniCheck.hpp"

#include "prims/jniExport.hpp"

#include "prims/jniFastGetField.hpp"

#include "prims/jvm_misc.hpp"

#include "prims/jvmtiExport.hpp"

#include "prims/jvmtiThreadState.hpp"

#include "runtime/atomic.hpp"

#include "runtime/compilationPolicy.hpp"

#include "runtime/fieldDescriptor.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/interfaceSupport.inline.hpp"

#include "runtime/java.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/jfieldIDWorkaround.hpp"

#include "runtime/jniHandles.inline.hpp"

#include "runtime/orderAccess.inline.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/memTracker.hpp"

#include "services/runtimeService.hpp"

#include "trace/traceMacros.hpp"

#include "trace/tracing.hpp"

#include "utilities/defaultStream.hpp"

#include "utilities/dtrace.hpp"

#include "utilities/events.hpp"

#include "utilities/histogram.hpp"

#include "utilities/internalVMTests.hpp"

#include "utilities/macros.hpp"

#include "utilities/vmError.hpp"

#if INCLUDE_JVMCI

#include "jvmci/jvmciCompiler.hpp"

#include "jvmci/jvmciRuntime.hpp"

#endif

static jint CurrentVersion = JNI_VERSION_10;

#ifdef _WIN32

extern LONG WINAPI topLevelExceptionFilter(_EXCEPTION_POINTERS* );

#endif

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

#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;                                                             \

      }                                                                    \

    }                                                                      \

  )

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

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

// (dtrace doesn't do FP yet)

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

#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(NoSafepointVerifier 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(NoSafepointVerifier 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");

}

// Wrapper to trace JNI functions

#ifdef ASSERT

  Histogram* JNIHistogram;

  static volatile int JNIHistogram_lock = 0;

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

#else

  #define JNIWrapper(arg)

#endif

// Implementation of JNI entries

DT_RETURN_MARK_DECL(DefineClass, jclass

                    , HOTSPOT_JNI_DEFINECLASS_RETURN(_ret_ref));

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

                                  const jbyte *buf, jsize bufLen))

  JNIWrapper("DefineClass");

  HOTSPOT_JNI_DEFINECLASS_ENTRY(

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

  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.

      Exceptions::fthrow(THREAD_AND_LOCATION,

                         vmSymbols::java_lang_NoClassDefFoundError(),

                         "Class name exceeds maximum length of %d: %s",

                         Symbol::max_length(),

                         name);

      return 0;

    }

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

  }

  ResourceMark rm(THREAD);

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

  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,

                                                   CHECK_NULL);

  if (log_is_enabled(Debug, class, resolve) && 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;

DT_RETURN_MARK_DECL(FindClass, jclass

                    , HOTSPOT_JNI_FINDCLASS_RETURN(_ret_ref));

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

  JNIWrapper("FindClass");

  HOTSPOT_JNI_FINDCLASS_ENTRY(env, (char *)name);

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

    THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), "No class name given");

  }

  if ((int)strlen(name) > Symbol::max_length()) {

    Exceptions::fthrow(THREAD_AND_LOCATION,

                       vmSymbols::java_lang_NoClassDefFoundError(),

                       "Class name exceeds maximum length of %d: %s",

                       Symbol::max_length(),

                       name);

    return 0;

  }

  //%note jni_3

  Handle protection_domain;

  // Find calling class

  Klass* k = thread->security_get_caller_class(0);

  // default to the system loader when no context

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

  if (k != NULL) {

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

    // in the correct class context.

    if (k->class_loader() == NULL &&

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

      JavaValue result(T_OBJECT);

      JavaCalls::call_static(&result, k,

                             vmSymbols::getFromClass_name(),

                             vmSymbols::void_class_signature(),

                             CHECK_NULL);

      // When invoked from JNI_OnLoad, NativeLibrary::getFromClass returns

      // a non-NULL Class object.  When invoked from JNI_OnUnload,

      // it will return NULL to indicate no context.

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

      if (mirror != NULL) {

        Klass* fromClass = java_lang_Class::as_Klass(mirror);

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

        protection_domain = Handle(THREAD, fromClass->protection_domain());

      }

    } else {

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

    }

  }

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

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

                                        protection_domain, true, thread);

  if (log_is_enabled(Debug, class, resolve) && 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

DT_RETURN_MARK_DECL(FromReflectedMethod, jmethodID

                    , HOTSPOT_JNI_FROMREFLECTEDMETHOD_RETURN((uintptr_t)_ret_ref));

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

  JNIWrapper("FromReflectedMethod");

  HOTSPOT_JNI_FROMREFLECTEDMETHOD_ENTRY(env, method);

  jmethodID ret = NULL;

  DT_RETURN_MARK(FromReflectedMethod, jmethodID, (const jmethodID&)ret);

  // method is a handle to a java.lang.reflect.Method object

  oop reflected  = JNIHandles::resolve_non_null(method);

  oop mirror     = NULL;

  int slot       = 0;

  if (reflected->klass() == SystemDictionary::reflect_Constructor_klass()) {

    mirror = java_lang_reflect_Constructor::clazz(reflected);

    slot   = java_lang_reflect_Constructor::slot(reflected);

  } else {

    assert(reflected->klass() == SystemDictionary::reflect_Method_klass(), "wrong type");

    mirror = java_lang_reflect_Method::clazz(reflected);

    slot   = java_lang_reflect_Method::slot(reflected);

  }

  Klass* k1 = java_lang_Class::as_Klass(mirror);

  // Make sure class is initialized before handing id's out to methods

  k1->initialize(CHECK_NULL);

  Method* m = InstanceKlass::cast(k1)->method_with_idnum(slot);

  ret = m==NULL? NULL : m->jmethod_id();  // return NULL if reflected method deleted

  return ret;

JNI_END

DT_RETURN_MARK_DECL(FromReflectedField, jfieldID

                    , HOTSPOT_JNI_FROMREFLECTEDFIELD_RETURN((uintptr_t)_ret_ref));

JNI_ENTRY(jfieldID, jni_FromReflectedField(JNIEnv *env, jobject field))

  JNIWrapper("FromReflectedField");

  HOTSPOT_JNI_FROMREFLECTEDFIELD_ENTRY(env, field);

  jfieldID ret = NULL;

  DT_RETURN_MARK(FromReflectedField, jfieldID, (const jfieldID&)ret);

  // field is a handle to a java.lang.reflect.Field object

  oop reflected   = JNIHandles::resolve_non_null(field);

  oop mirror      = java_lang_reflect_Field::clazz(reflected);

  Klass* k1       = java_lang_Class::as_Klass(mirror);

  int slot        = java_lang_reflect_Field::slot(reflected);

  int modifiers   = java_lang_reflect_Field::modifiers(reflected);

  // Make sure class is initialized before handing id's out to fields

  k1->initialize(CHECK_NULL);

  // First check if this is a static field

  if (modifiers & JVM_ACC_STATIC) {

    intptr_t offset = InstanceKlass::cast(k1)->field_offset( slot );

    JNIid* id = InstanceKlass::cast(k1)->jni_id_for(offset);

    assert(id != NULL, "corrupt Field object");

    debug_only(id->set_is_static_field_id();)

    // A jfieldID for a static field is a JNIid specifying the field holder and the offset within the Klass*