/*

 * Copyright 1997-2009 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

#include "incls/_precompiled.incl"

#include "incls/_jvm.cpp.incl"

#include <errno.h>

/*

  NOTE about use of any ctor or function call that can trigger a safepoint/GC:

  such ctors and calls MUST NOT come between an oop declaration/init and its

  usage because if objects are move this may cause various memory stomps, bus

  errors and segfaults. Here is a cookbook for causing so called "naked oop

  failures":

      JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredFields<etc> {

          JVMWrapper("JVM_GetClassDeclaredFields");

          // Object address to be held directly in mirror & not visible to GC

          oop mirror = JNIHandles::resolve_non_null(ofClass);

          // If this ctor can hit a safepoint, moving objects around, then

          ComplexConstructor foo;

          // Boom! mirror may point to JUNK instead of the intended object

          (some dereference of mirror)

          // Here's another call that may block for GC, making mirror stale

          MutexLocker ml(some_lock);

          // And here's an initializer that can result in a stale oop

          // all in one step.

          oop o = call_that_can_throw_exception(TRAPS);

  The solution is to keep the oop declaration BELOW the ctor or function

  call that might cause a GC, do another resolve to reassign the oop, or

  consider use of a Handle instead of an oop so there is immunity from object

  motion. But note that the "QUICK" entries below do not have a handlemark

  and thus can only support use of handles passed in.

*/

static void trace_class_resolution_impl(klassOop to_class, TRAPS) {

  ResourceMark rm;

  int line_number = -1;

  const char * source_file = NULL;

  klassOop caller = NULL;

  JavaThread* jthread = JavaThread::current();

  if (jthread->has_last_Java_frame()) {

    vframeStream vfst(jthread);

    // scan up the stack skipping ClassLoader, AccessController and PrivilegedAction frames

    symbolHandle access_controller = oopFactory::new_symbol_handle("java/security/AccessController", CHECK);

    klassOop access_controller_klass = SystemDictionary::resolve_or_fail(access_controller, false, CHECK);

    symbolHandle privileged_action = oopFactory::new_symbol_handle("java/security/PrivilegedAction", CHECK);

    klassOop privileged_action_klass = SystemDictionary::resolve_or_fail(privileged_action, false, CHECK);

    methodOop last_caller = NULL;

    while (!vfst.at_end()) {

      methodOop m = vfst.method();

      if (!vfst.method()->method_holder()->klass_part()->is_subclass_of(SystemDictionary::classloader_klass())&&

          !vfst.method()->method_holder()->klass_part()->is_subclass_of(access_controller_klass) &&

          !vfst.method()->method_holder()->klass_part()->is_subclass_of(privileged_action_klass)) {

        break;

      }

      last_caller = m;

      vfst.next();

    }

    // if this is called from Class.forName0 and that is called from Class.forName,

    // then print the caller of Class.forName.  If this is Class.loadClass, then print

    // that caller, otherwise keep quiet since this should be picked up elsewhere.

    bool found_it = false;

    if (!vfst.at_end() &&

        instanceKlass::cast(vfst.method()->method_holder())->name() == vmSymbols::java_lang_Class() &&

        vfst.method()->name() == vmSymbols::forName0_name()) {

      vfst.next();

      if (!vfst.at_end() &&

          instanceKlass::cast(vfst.method()->method_holder())->name() == vmSymbols::java_lang_Class() &&

          vfst.method()->name() == vmSymbols::forName_name()) {

        vfst.next();

        found_it = true;

      }

    } else if (last_caller != NULL &&

               instanceKlass::cast(last_caller->method_holder())->name() ==

               vmSymbols::java_lang_ClassLoader() &&

               (last_caller->name() == vmSymbols::loadClassInternal_name() ||

                last_caller->name() == vmSymbols::loadClass_name())) {

      found_it = true;

    }

    if (found_it && !vfst.at_end()) {

      // found the caller

      caller = vfst.method()->method_holder();

      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 (caller != NULL) {

    if (to_class != caller) {

      const char * from = Klass::cast(caller)->external_name();

      const char * to = Klass::cast(to_class)->external_name();

      // print in a single call to reduce interleaving between threads

      if (source_file != NULL) {

        tty->print("RESOLVE %s %s %s:%d (explicit)\n", from, to, source_file, line_number);

      } else {

        tty->print("RESOLVE %s %s (explicit)\n", from, to);

      }

    }

  }

}

static void trace_class_resolution(klassOop to_class) {

  EXCEPTION_MARK;

  trace_class_resolution_impl(to_class, THREAD);

  if (HAS_PENDING_EXCEPTION) {

    CLEAR_PENDING_EXCEPTION;

  }

}

// Wrapper to trace JVM functions

#ifdef ASSERT

  class JVMTraceWrapper : public StackObj {

   public:

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

      if (TraceJVMCalls) {

        va_list ap;

        va_start(ap, format);

        tty->print("JVM ");

        tty->vprint_cr(format, ap);

        va_end(ap);

      }

    }

  };

  Histogram* JVMHistogram;

  volatile jint JVMHistogram_lock = 0;

  class JVMHistogramElement : public HistogramElement {

    public:

     JVMHistogramElement(const char* name);

  };

  JVMHistogramElement::JVMHistogramElement(const char* elementName) {

    _name = elementName;

    uintx count = 0;

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

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

        count +=1;

        if ( (WarnOnStalledSpinLock > 0)

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

          warning("JVMHistogram_lock seems to be stalled");

        }

      }

     }

    if(JVMHistogram == NULL)

      JVMHistogram = new Histogram("JVM Call Counts",100);

    JVMHistogram->add_element(this);

    Atomic::dec(&JVMHistogram_lock);

  }

  #define JVMCountWrapper(arg) \

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

      if (e != NULL) e->increment_count();  // Due to bug in VC++, we need a NULL check here eventhough it should never happen!

  #define JVMWrapper(arg1)                    JVMCountWrapper(arg1); JVMTraceWrapper(arg1)

  #define JVMWrapper2(arg1, arg2)             JVMCountWrapper(arg1); JVMTraceWrapper(arg1, arg2)

  #define JVMWrapper3(arg1, arg2, arg3)       JVMCountWrapper(arg1); JVMTraceWrapper(arg1, arg2, arg3)

  #define JVMWrapper4(arg1, arg2, arg3, arg4) JVMCountWrapper(arg1); JVMTraceWrapper(arg1, arg2, arg3, arg4)

#else

  #define JVMWrapper(arg1)

  #define JVMWrapper2(arg1, arg2)

  #define JVMWrapper3(arg1, arg2, arg3)

  #define JVMWrapper4(arg1, arg2, arg3, arg4)

#endif

// Interface version /////////////////////////////////////////////////////////////////////

JVM_LEAF(jint, JVM_GetInterfaceVersion())

  return JVM_INTERFACE_VERSION;

JVM_END

// java.lang.System //////////////////////////////////////////////////////////////////////

JVM_LEAF(jlong, JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored))

  JVMWrapper("JVM_CurrentTimeMillis");

  return os::javaTimeMillis();

JVM_END

JVM_LEAF(jlong, JVM_NanoTime(JNIEnv *env, jclass ignored))

  JVMWrapper("JVM_NanoTime");

  return os::javaTimeNanos();

JVM_END

JVM_ENTRY(void, JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos,

                               jobject dst, jint dst_pos, jint length))

  JVMWrapper("JVM_ArrayCopy");

  // Check if we have null pointers

  if (src == NULL || dst == NULL) {

    THROW(vmSymbols::java_lang_NullPointerException());

  }

  arrayOop s = arrayOop(JNIHandles::resolve_non_null(src));

  arrayOop d = arrayOop(JNIHandles::resolve_non_null(dst));

  assert(s->is_oop(), "JVM_ArrayCopy: src not an oop");

  assert(d->is_oop(), "JVM_ArrayCopy: dst not an oop");

  // Do copy

  Klass::cast(s->klass())->copy_array(s, src_pos, d, dst_pos, length, thread);

JVM_END

static void set_property(Handle props, const char* key, const char* value, TRAPS) {

  JavaValue r(T_OBJECT);

  // public synchronized Object put(Object key, Object value);

  HandleMark hm(THREAD);

  Handle key_str    = java_lang_String::create_from_platform_dependent_str(key, CHECK);

  Handle value_str  = java_lang_String::create_from_platform_dependent_str((value != NULL ? value : ""), CHECK);

  JavaCalls::call_virtual(&r,

                          props,

                          KlassHandle(THREAD, SystemDictionary::properties_klass()),

                          vmSymbolHandles::put_name(),

                          vmSymbolHandles::object_object_object_signature(),

                          key_str,

                          value_str,

                          THREAD);

}

#define PUTPROP(props, name, value) set_property((props), (name), (value), CHECK_(properties));

JVM_ENTRY(jobject, JVM_InitProperties(JNIEnv *env, jobject properties))

  JVMWrapper("JVM_InitProperties");

  ResourceMark rm;

  Handle props(THREAD, JNIHandles::resolve_non_null(properties));

  // System property list includes both user set via -D option and

  // jvm system specific properties.

  for (SystemProperty* p = Arguments::system_properties(); p != NULL; p = p->next()) {

    PUTPROP(props, p->key(), p->value());

  }

  // Convert the -XX:MaxDirectMemorySize= command line flag

  // to the sun.nio.MaxDirectMemorySize property.

  // Do this after setting user properties to prevent people

  // from setting the value with a -D option, as requested.

  {

    char as_chars[256];

    jio_snprintf(as_chars, sizeof(as_chars), INTX_FORMAT, MaxDirectMemorySize);

    PUTPROP(props, "sun.nio.MaxDirectMemorySize", as_chars);

  }

  // JVM monitoring and management support

  // Add the sun.management.compiler property for the compiler's name

  {

#undef CSIZE

#if defined(_LP64) || defined(_WIN64)

  #define CSIZE "64-Bit "

#else

  #define CSIZE

#endif // 64bit

#ifdef TIERED

    const char* compiler_name = "HotSpot " CSIZE "Tiered Compilers";

#else

#if defined(COMPILER1)

    const char* compiler_name = "HotSpot " CSIZE "Client Compiler";

#elif defined(COMPILER2)

    const char* compiler_name = "HotSpot " CSIZE "Server Compiler";

#else

    const char* compiler_name = "";

#endif // compilers

#endif // TIERED

    if (*compiler_name != '\0' &&

        (Arguments::mode() != Arguments::_int)) {

      PUTPROP(props, "sun.management.compiler", compiler_name);

    }

  }

  return properties;

JVM_END

// java.lang.Runtime /////////////////////////////////////////////////////////////////////////

extern volatile jint vm_created;

JVM_ENTRY_NO_ENV(void, JVM_Exit(jint code))

  if (vm_created != 0 && (code == 0)) {

    // The VM is about to exit. We call back into Java to check whether finalizers should be run

    Universe::run_finalizers_on_exit();

  }

  before_exit(thread);

  vm_exit(code);

JVM_END

JVM_ENTRY_NO_ENV(void, JVM_Halt(jint code))

  before_exit(thread);

  vm_exit(code);

JVM_END

JVM_LEAF(void, JVM_OnExit(void (*func)(void)))

  register_on_exit_function(func);

JVM_END

JVM_ENTRY_NO_ENV(void, JVM_GC(void))

  JVMWrapper("JVM_GC");

  if (!DisableExplicitGC) {

    Universe::heap()->collect(GCCause::_java_lang_system_gc);

  }

JVM_END

JVM_LEAF(jlong, JVM_MaxObjectInspectionAge(void))

  JVMWrapper("JVM_MaxObjectInspectionAge");

  return Universe::heap()->millis_since_last_gc();

JVM_END

JVM_LEAF(void, JVM_TraceInstructions(jboolean on))

  if (PrintJVMWarnings) warning("JVM_TraceInstructions not supported");

JVM_END

JVM_LEAF(void, JVM_TraceMethodCalls(jboolean on))

  if (PrintJVMWarnings) warning("JVM_TraceMethodCalls not supported");

JVM_END

static inline jlong convert_size_t_to_jlong(size_t val) {

  // In the 64-bit vm, a size_t can overflow a jlong (which is signed).

  NOT_LP64 (return (jlong)val;)

  LP64_ONLY(return (jlong)MIN2(val, (size_t)max_jlong);)

}

JVM_ENTRY_NO_ENV(jlong, JVM_TotalMemory(void))

  JVMWrapper("JVM_TotalMemory");

  size_t n = Universe::heap()->capacity();

  return convert_size_t_to_jlong(n);

JVM_END

JVM_ENTRY_NO_ENV(jlong, JVM_FreeMemory(void))

  JVMWrapper("JVM_FreeMemory");

  CollectedHeap* ch = Universe::heap();

  size_t n;

  {

     MutexLocker x(Heap_lock);

     n = ch->capacity() - ch->used();

  }

  return convert_size_t_to_jlong(n);

JVM_END

JVM_ENTRY_NO_ENV(jlong, JVM_MaxMemory(void))

  JVMWrapper("JVM_MaxMemory");

  size_t n = Universe::heap()->max_capacity();

  return convert_size_t_to_jlong(n);

JVM_END

JVM_ENTRY_NO_ENV(jint, JVM_ActiveProcessorCount(void))

  JVMWrapper("JVM_ActiveProcessorCount");

  return os::active_processor_count();

JVM_END

// java.lang.Throwable //////////////////////////////////////////////////////

JVM_ENTRY(void, JVM_FillInStackTrace(JNIEnv *env, jobject receiver))

  JVMWrapper("JVM_FillInStackTrace");

  Handle exception(thread, JNIHandles::resolve_non_null(receiver));

  java_lang_Throwable::fill_in_stack_trace(exception);

JVM_END

JVM_ENTRY(void, JVM_PrintStackTrace(JNIEnv *env, jobject receiver, jobject printable))

  JVMWrapper("JVM_PrintStackTrace");

  // Note: This is no longer used in Merlin, but we still support it for compatibility.

  oop exception = JNIHandles::resolve_non_null(receiver);

  oop stream    = JNIHandles::resolve_non_null(printable);

  java_lang_Throwable::print_stack_trace(exception, stream);

JVM_END

JVM_ENTRY(jint, JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable))

  JVMWrapper("JVM_GetStackTraceDepth");

  oop exception = JNIHandles::resolve(throwable);

  return java_lang_Throwable::get_stack_trace_depth(exception, THREAD);

JVM_END

JVM_ENTRY(jobject, JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index))

  JVMWrapper("JVM_GetStackTraceElement");

  JvmtiVMObjectAllocEventCollector oam; // This ctor (throughout this module) may trigger a safepoint/GC

  oop exception = JNIHandles::resolve(throwable);

  oop element = java_lang_Throwable::get_stack_trace_element(exception, index, CHECK_NULL);

  return JNIHandles::make_local(env, element);

JVM_END

// java.lang.Object ///////////////////////////////////////////////

JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle))

  JVMWrapper("JVM_IHashCode");

  // as implemented in the classic virtual machine; return 0 if object is NULL

  return handle == NULL ? 0 : ObjectSynchronizer::FastHashCode (THREAD, JNIHandles::resolve_non_null(handle)) ;

JVM_END

JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms))

  JVMWrapper("JVM_MonitorWait");

  Handle obj(THREAD, JNIHandles::resolve_non_null(handle));

  assert(obj->is_instance() || obj->is_array(), "JVM_MonitorWait must apply to an object");

  JavaThreadInObjectWaitState jtiows(thread, ms != 0);

  if (JvmtiExport::should_post_monitor_wait()) {

    JvmtiExport::post_monitor_wait((JavaThread *)THREAD, (oop)obj(), ms);

  }

  ObjectSynchronizer::wait(obj, ms, CHECK);

JVM_END

JVM_ENTRY(void, JVM_MonitorNotify(JNIEnv* env, jobject handle))

  JVMWrapper("JVM_MonitorNotify");

  Handle obj(THREAD, JNIHandles::resolve_non_null(handle));

  assert(obj->is_instance() || obj->is_array(), "JVM_MonitorNotify must apply to an object");

  ObjectSynchronizer::notify(obj, CHECK);

JVM_END

JVM_ENTRY(void, JVM_MonitorNotifyAll(JNIEnv* env, jobject handle))

  JVMWrapper("JVM_MonitorNotifyAll");

  Handle obj(THREAD, JNIHandles::resolve_non_null(handle));

  assert(obj->is_instance() || obj->is_array(), "JVM_MonitorNotifyAll must apply to an object");

  ObjectSynchronizer::notifyall(obj, CHECK);

JVM_END

JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle))

  JVMWrapper("JVM_Clone");

  Handle obj(THREAD, JNIHandles::resolve_non_null(handle));

  const KlassHandle klass (THREAD, obj->klass());

  JvmtiVMObjectAllocEventCollector oam;

#ifdef ASSERT

  // Just checking that the cloneable flag is set correct

  if (obj->is_javaArray()) {

    guarantee(klass->is_cloneable(), "all arrays are cloneable");

  } else {

    guarantee(obj->is_instance(), "should be instanceOop");

    bool cloneable = klass->is_subtype_of(SystemDictionary::cloneable_klass());

    guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag");

  }

#endif

  // Check if class of obj supports the Cloneable interface.

  // All arrays are considered to be cloneable (See JLS 20.1.5)

  if (!klass->is_cloneable()) {

    ResourceMark rm(THREAD);

    THROW_MSG_0(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name());

  }

  // Make shallow object copy

  const int size = obj->size();

  oop new_obj = NULL;

  if (obj->is_javaArray()) {

    const int length = ((arrayOop)obj())->length();

    new_obj = CollectedHeap::array_allocate(klass, size, length, CHECK_NULL);

  } else {

    new_obj = CollectedHeap::obj_allocate(klass, size, CHECK_NULL);

  }

  // 4839641 (4840070): We must do an oop-atomic copy, because if another thread

  // is modifying a reference field in the clonee, a non-oop-atomic copy might

  // be suspended in the middle of copying the pointer and end up with parts

  // of two different pointers in the field.  Subsequent dereferences will crash.

  // 4846409: an oop-copy of objects with long or double fields or arrays of same

  // won't copy the longs/doubles atomically in 32-bit vm's, so we copy jlongs instead

  // of oops.  We know objects are aligned on a minimum of an jlong boundary.

  // The same is true of StubRoutines::object_copy and the various oop_copy

  // variants, and of the code generated by the inline_native_clone intrinsic.

  assert(MinObjAlignmentInBytes >= BytesPerLong, "objects misaligned");

  Copy::conjoint_jlongs_atomic((jlong*)obj(), (jlong*)new_obj,

                               (size_t)align_object_size(size) / HeapWordsPerLong);

  // Clear the header

  new_obj->init_mark();

  // Store check (mark entire object and let gc sort it out)

  BarrierSet* bs = Universe::heap()->barrier_set();

  assert(bs->has_write_region_opt(), "Barrier set does not have write_region");

  bs->write_region(MemRegion((HeapWord*)new_obj, size));