/*

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

#include "classfile/javaClasses.hpp"

#include "classfile/symbolTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "interpreter/linkResolver.hpp"

#ifndef SERIALGC

#include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"

#endif // SERIALGC

#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/methodOop.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/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/vm_operations.hpp"

#include "services/runtimeService.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"

# include "thread_linux.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_solaris

# include "os_solaris.inline.hpp"

# include "thread_solaris.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_windows

# include "os_windows.inline.hpp"

# include "thread_windows.inline.hpp"

#endif

static jint CurrentVersion = JNI_VERSION_1_6;

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

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

      }                                                                    \

    }                                                                      \

  )

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

#define DT_RETURN_MARK_DECL_FOR(TypeName, name, type) \

  FP_SELECT(TypeName, \

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

#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(klassOop 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(klassOop k, intptr_t offset) {

  if (offset <= small_offset_mask) {

    klassOop field_klass = k;

    klassOop super_klass = Klass::cast(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 = Klass::cast(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, Klass::cast(k)->external_name());

    }

    #endif

#endif

    return 0;

  }

}

bool jfieldIDWorkaround::klass_hash_ok(klassOop 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 = Klass::cast(k)->super();

  } while (k != NULL);

  return false;

}

void jfieldIDWorkaround::verify_instance_jfieldID(klassOop 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, Klass::cast(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

DT_RETURN_MARK_DECL(DefineClass, jclass);

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

                                  const jbyte *buf, jsize bufLen))

  JNIWrapper("DefineClass");

  DTRACE_PROBE5(hotspot_jni, DefineClass__entry,

    env, name, loaderRef, buf, bufLen);

  jclass cls = NULL;

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

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

    }

  }

  TempNewSymbol class_name = SymbolTable::new_symbol(name, THREAD);

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

    }

  }

  klassOop 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, Klass::cast(k)->java_mirror());

  return cls;

JNI_END

static bool first_time_FindClass = true;

DT_RETURN_MARK_DECL(FindClass, jclass);

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

  JNIWrapper("FindClass");

  DTRACE_PROBE2(hotspot_jni, FindClass__entry, env, 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 || (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_klassOop(mirror))->class_loader());

      protection_domain = Handle(THREAD,

        instanceKlass::cast(java_lang_Class::as_klassOop(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_klassOop(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);

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

  JNIWrapper("FromReflectedMethod");

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

  }

  klassOop k     = java_lang_Class::as_klassOop(mirror);

  KlassHandle k1(THREAD, k);

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

  Klass::cast(k1())->initialize(CHECK_NULL);

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

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

  JNIWrapper("FromReflectedField");

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

  klassOop k      = java_lang_Class::as_klassOop(mirror);

  int slot        = java_lang_reflect_Field::slot(reflected);

  int modifiers   = java_lang_reflect_Field::modifiers(reflected);

  KlassHandle k1(THREAD, k);

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

  Klass::cast(k1())->initialize(CHECK_NULL);

  // First check if this is a static field

  if (modifiers & JVM_ACC_STATIC) {

    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 klassOop

    ret = jfieldIDWorkaround::to_static_jfieldID(id);

    return ret;

  }

  // The slot is the index of the field description in the field-array

  // The jfieldID is the offset of the field within the object

  // It may also have hash bits for k, if VerifyJNIFields is turned on.

  assert(instanceKlass::cast(k1())->contains_field_offset(offset), "stay within object");

  ret = jfieldIDWorkaround::to_instance_jfieldID(k1(), offset);

  return ret;

JNI_END

DT_RETURN_MARK_DECL(ToReflectedMethod, jobject);

JNI_ENTRY(jobject, jni_ToReflectedMethod(JNIEnv *env, jclass cls, jmethodID method_id, jboolean isStatic))

  JNIWrapper("ToReflectedMethod");

  DTRACE_PROBE4(hotspot_jni, ToReflectedMethod__entry, env, cls, method_id, isStatic);

  jobject ret = NULL;

  DT_RETURN_MARK(ToReflectedMethod, jobject, (const jobject&)ret);