/* hotspot jni systemtap tapset.
   Copyright (C) 2009, Red Hat Inc.

This file is part of IcedTea.

IcedTea is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

IcedTea 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 for more details.

You should have received a copy of the GNU General Public License
along with IcedTea; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
*/

/*
 Currently only works with full path in process probes below.
 When things don't seem to work look if the correct
 jre/lib/[arch]/[client|server]/libjvm.so is used
 and exists under @prefix@/.
 This version of hotspot.stp has been configured to instrument the
 libjvm.so for arch @INSTALL_ARCH_DIR@ installed at:
 @ABS_CLIENT_LIBJVM_SO@
 @ABS_SERVER_LIBJVM_SO@
 
 Each entry probe defines the jni probe name and a full probestr
 which consists of the probe name and between brackets all argument
 names and values. Each return probe defines the jni probe name and
 a retstr (which might be the empty string for void methods).
 */

/* hotspot.jni.AllocObject
 * Allocate object without calling any constructors.
 *
 * env - JNIEnv pointer.
 * clazz - jclass pointer.
 */
probe hotspot.jni.AllocObject =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("AllocObject__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("AllocObject__entry")
{
  name = "AllocObject"
  env = $arg1
  clazz = $arg2
  probestr = sprintf("%s(env=0x%x,clazz=0x%x)", name, env, clazz)
}

/* hotspot.jni.AllocObject.return
 * Allocate object without calling any constructors. Return.
 *
 * ret - jobject reference to allocated object or NULL
 */
probe hotspot.jni.AllocObject.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("AllocObject__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("AllocObject__return")
{
  name = "AllocObject"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.AttachCurrentThreadAsDaemon
 * Attach the current thread as daemon.
 *
 * vm - JavaVM pointer.
 * penv - pointer to JNIEnv pointer.
 * args - pointer to JavaVMAttachArgs struct.
 */
probe hotspot.jni.AttachCurrentThreadAsDaemon =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("AttachCurrentThreadAsDaemon__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("AttachCurrentThreadAsDaemon__entry")
{
  name = "AttachCurrentThreadAsDaemon"
  vm = $arg1
  penv = $arg2
  args = $arg3
  probestr = sprintf("%s(vm=0x%x,penv=0x%x,args=0x%x)", name, vm, penv, args)
}

/* hotspot.jni.AttachCurrentThreadAsDaemon.return
 * Attach the current thread as daemon. Return.
 *
 * ret - Zero on success, negative on error.
 */
probe hotspot.jni.AttachCurrentThreadAsDaemon.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("AttachCurrentThreadAsDaemon__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("AttachCurrentThreadAsDaemon__return")
{
  name = "AttachCurrentThreadAsDaemon"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.AttachCurrentThread
 * Attach the current thread.
 *
 * vm - JavaVM pointer.
 * penv - pointer to JNIEnv pointer.
 * args - pointer to JavaVMAttachArgs struct.
 */
probe hotspot.jni.AttachCurrentThread =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("AttachCurrentThread__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("AttachCurrentThread__entry")
{
  name = "AttachCurrentThread"
  vm = $arg1
  penv = $arg2
  args = $arg3
  probestr = sprintf("%s(vm=0x%x,penv=0x%x,args=0x%x)", name, vm, penv, args)
}

/* hotspot.jni.AttachCurrentThread.return
 * Attach the current thread. Return.
 *
 * ret - Zero on success, negative on error.
 */
probe hotspot.jni.AttachCurrentThread.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("AttachCurrentThread__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("AttachCurrentThread__return")
{
  name = "AttachCurrentThread"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallBooleanMethodA
 * Call virtual method returning a boolean using an array as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallBooleanMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallBooleanMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallBooleanMethodA__entry")
{
  name = "CallBooleanMethodA"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallBooleanMethodA.return
 * Call virtual method returning a boolean using an array as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallBooleanMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallBooleanMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallBooleanMethodA__return")
{
  name = "CallBooleanMethodA"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallBooleanMethod
 * Call virtual method returning a boolean.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallBooleanMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallBooleanMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallBooleanMethod__entry")
{
  name = "CallBooleanMethod"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallBooleanMethod.return
 * Call virtual method returning a boolean. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallBooleanMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallBooleanMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallBooleanMethod__return")
{
  name = "CallBooleanMethod"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallBooleanMethodV
 * Call virtual method returning a boolean using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallBooleanMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallBooleanMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallBooleanMethodV__entry")
{
  name = "CallBooleanMethodV"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallBooleanMethodV.return
 * Call virtual method returning a boolean using va_list as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallBooleanMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallBooleanMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallBooleanMethodV__return")
{
  name = "CallBooleanMethodV"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallByteMethodA
 * Call virtual method returning a byte using an array as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallByteMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallByteMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallByteMethodA__entry")
{
  name = "CallByteMethodA"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallByteMethodA.return
 * Call virtual method returning a byte using an array as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallByteMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallByteMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallByteMethodA__return")
{
  name = "CallByteMethodA"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallByteMethod
 * Call virtual method returning a byte.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallByteMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallByteMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallByteMethod__entry")
{
  name = "CallByteMethod"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallByteMethod.return
 * Call virtual method returning a byte. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallByteMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallByteMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallByteMethod__return")
{
  name = "CallByteMethod"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallByteMethodV
 * Call virtual method returning a byte using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallByteMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallByteMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallByteMethodV__entry")
{
  name = "CallByteMethodV"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallByteMethodV.return
 * Call virtual method returning a byte using va_list as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallByteMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallByteMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallByteMethodV__return")
{
  name = "CallByteMethodV"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallCharMethodA
 * Call virtual method returning a char using an array as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallCharMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallCharMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallCharMethodA__entry")
{
  name = "CallCharMethodA"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallCharMethodA.return
 * Call virtual method returning a char using an array as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallCharMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallCharMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallCharMethodA__return")
{
  name = "CallCharMethodA"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallCharMethod
 * Call virtual method returning a char.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallCharMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallCharMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallCharMethod__entry")
{
  name = "CallCharMethod"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallCharMethod.return
 * Call virtual method returning a char. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallCharMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallCharMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallCharMethod__return")
{
  name = "CallCharMethod"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallCharMethodV
 * Call virtual method returning a char using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallCharMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallCharMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallCharMethodV__entry")
{
  name = "CallCharMethodV"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallCharMethodV.return
 * Call virtual method returning a char using va_list as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallCharMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallCharMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallCharMethodV__return")
{
  name = "CallCharMethodV"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallDoubleMethodA
 * Call virtual method returning a double using an array as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallDoubleMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallDoubleMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallDoubleMethodA__entry")
{
  name = "CallDoubleMethodA"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallDoubleMethodA.return
 * Call virtual method returning a double using an array as arguments. Return.
 */
probe hotspot.jni.CallDoubleMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallDoubleMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallDoubleMethodA__return")
{
  name = "CallDoubleMethodA"
  retstr = ""
}

/* hotspot.jni.CallDoubleMethod
 * Call virtual method returning a double.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallDoubleMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallDoubleMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallDoubleMethod__entry")
{
  name = "CallDoubleMethod"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallDoubleMethod.return
 * Call virtual method returning a double. Return.
 */
probe hotspot.jni.CallDoubleMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallDoubleMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallDoubleMethod__return")
{
  name = "CallDoubleMethod"
  retstr = ""
}

/* hotspot.jni.CallDoubleMethodV
 * Call virtual method returning a double using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallDoubleMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallDoubleMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallDoubleMethodV__entry")
{
  name = "CallDoubleMethodV"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallDoubleMethodV.return
 * Call virtual method returning a double using va_list as arguments. Return.
 */
probe hotspot.jni.CallDoubleMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallDoubleMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallDoubleMethodV__return")
{
  name = "CallDoubleMethodV"
  retstr = ""
}

/* hotspot.jni.CallFloatMethodA
 * Call virtual method returning a float using an array as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallFloatMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallFloatMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallFloatMethodA__entry")
{
  name = "CallFloatMethodA"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallFloatMethodA.return
 * Call virtual method returning a float using an array as arguments. Return.
 */
probe hotspot.jni.CallFloatMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallFloatMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallFloatMethodA__return")
{
  name = "CallFloatMethodA"
  retstr = ""
}

/* hotspot.jni.CallFloatMethod
 * Call virtual method returning a float.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallFloatMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallFloatMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallFloatMethod__entry")
{
  name = "CallFloatMethod"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallFloatMethod.return
 * Call virtual method returning a float. Return.
 */
probe hotspot.jni.CallFloatMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallFloatMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallFloatMethod__return")
{
  name = "CallFloatMethod"
  retstr = ""
}

/* hotspot.jni.CallFloatMethodV
 * Call virtual method returning a float using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallFloatMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallFloatMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallFloatMethodV__entry")
{
  name = "CallFloatMethodV"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallFloatMethodV.return
 * Call virtual method returning a float using va_list as arguments. Return.
 */
probe hotspot.jni.CallFloatMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallFloatMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallFloatMethodV__return")
{
  name = "CallFloatMethodV"
  retstr = ""
}

/* hotspot.jni.CallIntMethodA
 * Call virtual method returning a int using an array as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallIntMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallIntMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallIntMethodA__entry")
{
  name = "CallIntMethodA"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallIntMethodA.return
 * Call virtual method returning a int using an array as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallIntMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallIntMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallIntMethodA__return")
{
  name = "CallIntMethodA"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallIntMethod
 * Call virtual method returning a int.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallIntMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallIntMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallIntMethod__entry")
{
  name = "CallIntMethod"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallIntMethod.return
 * Call virtual method returning a int. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallIntMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallIntMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallIntMethod__return")
{
  name = "CallIntMethod"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallIntMethodV
 * Call virtual method returning a int using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallIntMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallIntMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallIntMethodV__entry")
{
  name = "CallIntMethodV"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallIntMethodV.return
 * Call virtual method returning a int using va_list as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallIntMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallIntMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallIntMethodV__return")
{
  name = "CallIntMethodV"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallLongMethodA
 * Call virtual method returning a long using an array as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallLongMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallLongMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallLongMethodA__entry")
{
  name = "CallLongMethodA"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallLongMethodA.return
 * Call virtual method returning a long using an array as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallLongMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallLongMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallLongMethodA__return")
{
  name = "CallLongMethodA"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallLongMethod
 * Call virtual method returning a long.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallLongMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallLongMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallLongMethod__entry")
{
  name = "CallLongMethod"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallLongMethod.return
 * Call virtual method returning a long. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallLongMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallLongMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallLongMethod__return")
{
  name = "CallLongMethod"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallLongMethodV
 * Call virtual method returning a long using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallLongMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallLongMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallLongMethodV__entry")
{
  name = "CallLongMethodV"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallLongMethodV.return
 * Call virtual method returning a long using va_list as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallLongMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallLongMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallLongMethodV__return")
{
  name = "CallLongMethodV"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallObjectMethodA
 * Call virtual method returning a object using array as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallObjectMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallObjectMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallObjectMethodA__entry")
{
  name = "CallObjectMethodA"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallObjectMethodA.return
 * Call virtual method returning a object using array as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallObjectMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallObjectMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallObjectMethodA__return")
{
  name = "CallObjectMethodA"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.CallObjectMethod
 * Call virtual method returning a object.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallObjectMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallObjectMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallObjectMethod__entry")
{
  name = "CallObjectMethod"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallObjectMethod.return
 * Call virtual method returning a object. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallObjectMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallObjectMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallObjectMethod__return")
{
  name = "CallObjectMethod"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.CallObjectMethodV
 * Call virtual method returning a object using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallObjectMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallObjectMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallObjectMethodV__entry")
{
  name = "CallObjectMethodV"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallObjectMethodV.return
 * Call virtual method returning a object using va_list as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallObjectMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallObjectMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallObjectMethodV__return")
{
  name = "CallObjectMethodV"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.CallShortMethodA
 * Call virtual method returning a short using array as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallShortMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallShortMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallShortMethodA__entry")
{
  name = "CallShortMethodA"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallShortMethodA.return
 * Call virtual method returning a short using array as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallShortMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallShortMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallShortMethodA__return")
{
  name = "CallShortMethodA"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallShortMethod
 * Call virtual method returning a short.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallShortMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallShortMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallShortMethod__entry")
{
  name = "CallShortMethod"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallShortMethod.return
 * Call virtual method returning a short. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallShortMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallShortMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallShortMethod__return")
{
  name = "CallShortMethod"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallShortMethodV
 * Call virtual method returning a short using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallShortMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallShortMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallShortMethodV__entry")
{
  name = "CallShortMethodV"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallShortMethodV.return
 * Call virtual method returning a short using va_list as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallShortMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallShortMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallShortMethodV__return")
{
  name = "CallShortMethodV"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallVoidMethodA
 * Call virtual method returning void using array as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallVoidMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallVoidMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallVoidMethodA__entry")
{
  name = "CallVoidMethodA"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallVoidMethodA.return
 * Call virtual method returning void using array as arguments. Return.
 */
probe hotspot.jni.CallVoidMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallVoidMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallVoidMethodA__return")
{
  name = "CallVoidMethodA"
  retstr = ""
}

/* hotspot.jni.CallVoidMethod
 * Call virtual method returning void.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallVoidMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallVoidMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallVoidMethod__entry")
{
  name = "CallVoidMethod"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallVoidMethod.return
 * Call virtual method returning void. Return.
 */
probe hotspot.jni.CallVoidMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallVoidMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallVoidMethod__return")
{
  name = "CallVoidMethod"
  retstr = ""
}

/* hotspot.jni.CallVoidMethodV
 * Call virtual method returning void using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallVoidMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallVoidMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallVoidMethodV__entry")
{
  name = "CallVoidMethodV"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallVoidMethodV.return
 * Call virtual method returning void using va_list as arguments. Return.
 */
probe hotspot.jni.CallVoidMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallVoidMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallVoidMethodV__return")
{
  name = "CallVoidMethodV"
  retstr = ""
}

/* hotspot.jni.CallNonvirtualBooleanMethodA
 * Call non-virtual method returning a boolean using an array as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualBooleanMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualBooleanMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualBooleanMethodA__entry")
{
  name = "CallNonvirtualBooleanMethodA"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualBooleanMethodA.return
 * Call non-virtual method returning a boolean using an array as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallNonvirtualBooleanMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualBooleanMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualBooleanMethodA__return")
{
  name = "CallNonvirtualBooleanMethodA"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallNonvirtualBooleanMethod
 * Call non-virtual method returning a boolean.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualBooleanMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualBooleanMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualBooleanMethod__entry")
{
  name = "CallNonvirtualBooleanMethod"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualBooleanMethod.return
 * Call non-virtual method returning a boolean. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallNonvirtualBooleanMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualBooleanMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualBooleanMethod__return")
{
  name = "CallNonvirtualBooleanMethod"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallNonvirtualBooleanMethodV
 * Call non-virtual method returning a boolean using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualBooleanMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualBooleanMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualBooleanMethodV__entry")
{
  name = "CallNonvirtualBooleanMethodV"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualBooleanMethodV.return
 * Call non-virtual method returning a boolean using va_list as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallNonvirtualBooleanMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualBooleanMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualBooleanMethodV__return")
{
  name = "CallNonvirtualBooleanMethodV"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallNonvirtualByteMethodA
 * Call non-virtual method returning a byte using an array as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualByteMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualByteMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualByteMethodA__entry")
{
  name = "CallNonvirtualByteMethodA"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualByteMethodA.return
 * Call non-virtual method returning a byte using an array as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallNonvirtualByteMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualByteMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualByteMethodA__return")
{
  name = "CallNonvirtualByteMethodA"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallNonvirtualByteMethod
 * Call non-virtual method returning a byte.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualByteMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualByteMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualByteMethod__entry")
{
  name = "CallNonvirtualByteMethod"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualByteMethod.return
 * Call non-virtual method returning a byte. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallNonvirtualByteMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualByteMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualByteMethod__return")
{
  name = "CallNonvirtualByteMethod"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallNonvirtualByteMethodV
 * Call non-virtual method returning a byte using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualByteMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualByteMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualByteMethodV__entry")
{
  name = "CallNonvirtualByteMethodV"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualByteMethodV.return
 * Call non-virtual method returning a byte using va_list as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallNonvirtualByteMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualByteMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualByteMethodV__return")
{
  name = "CallNonvirtualByteMethodV"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallNonvirtualCharMethodA
 * Call non-virtual method returning a char using an array as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualCharMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualCharMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualCharMethodA__entry")
{
  name = "CallNonvirtualCharMethodA"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualCharMethodA.return
 * Call non-virtual method returning a char using an array as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallNonvirtualCharMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualCharMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualCharMethodA__return")
{
  name = "CallNonvirtualCharMethodA"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallNonvirtualCharMethod
 * Call non-virtual method returning a char.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualCharMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualCharMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualCharMethod__entry")
{
  name = "CallNonvirtualCharMethod"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualCharMethod.return
 * Call non-virtual method returning a char. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallNonvirtualCharMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualCharMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualCharMethod__return")
{
  name = "CallNonvirtualCharMethod"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallNonvirtualCharMethodV
 * Call non-virtual method returning a char using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualCharMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualCharMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualCharMethodV__entry")
{
  name = "CallNonvirtualCharMethodV"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualCharMethodV.return
 * Call non-virtual method returning a char using va_list as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallNonvirtualCharMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualCharMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualCharMethodV__return")
{
  name = "CallNonvirtualCharMethodV"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallNonvirtualDoubleMethodA
 * Call non-virtual method returning a double using an array as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualDoubleMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualDoubleMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualDoubleMethodA__entry")
{
  name = "CallNonvirtualDoubleMethodA"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualDoubleMethodA.return
 * Call non-virtual method returning a double using an array as arguments. Return.
 */
probe hotspot.jni.CallNonvirtualDoubleMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualDoubleMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualDoubleMethodA__return")
{
  name = "CallNonvirtualDoubleMethodA"
  retstr = ""
}

/* hotspot.jni.CallNonvirtualDoubleMethod
 * Call non-virtual method returning a double.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualDoubleMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualDoubleMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualDoubleMethod__entry")
{
  name = "CallNonvirtualDoubleMethod"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualDoubleMethod.return
 * Call non-virtual method returning a double. Return.
 */
probe hotspot.jni.CallNonvirtualDoubleMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualDoubleMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualDoubleMethod__return")
{
  name = "CallNonvirtualDoubleMethod"
  retstr = ""
}

/* hotspot.jni.CallNonvirtualDoubleMethodV
 * Call non-virtual method returning a double using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualDoubleMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualDoubleMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualDoubleMethodV__entry")
{
  name = "CallNonvirtualDoubleMethodV"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualDoubleMethodV.return
 * Call non-virtual method returning a double using va_list as arguments. Return.
 */
probe hotspot.jni.CallNonvirtualDoubleMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualDoubleMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualDoubleMethodV__return")
{
  name = "CallNonvirtualDoubleMethodV"
  retstr = ""
}

/* hotspot.jni.CallNonvirtualFloatMethodA
 * Call non-virtual method returning a float using an array as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualFloatMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualFloatMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualFloatMethodA__entry")
{
  name = "CallNonvirtualFloatMethodA"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualFloatMethodA.return
 * Call non-virtual method returning a float using an array as arguments. Return.
 */
probe hotspot.jni.CallNonvirtualFloatMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualFloatMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualFloatMethodA__return")
{
  name = "CallNonvirtualFloatMethodA"
  retstr = ""
}

/* hotspot.jni.CallNonvirtualFloatMethod
 * Call non-virtual method returning a float.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualFloatMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualFloatMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualFloatMethod__entry")
{
  name = "CallNonvirtualFloatMethod"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualFloatMethod.return
 * Call non-virtual method returning a float. Return.
 */
probe hotspot.jni.CallNonvirtualFloatMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualFloatMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualFloatMethod__return")
{
  name = "CallNonvirtualFloatMethod"
  retstr = ""
}

/* hotspot.jni.CallNonvirtualFloatMethodV
 * Call non-virtual method returning a float using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualFloatMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualFloatMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualFloatMethodV__entry")
{
  name = "CallNonvirtualFloatMethodV"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualFloatMethodV.return
 * Call non-virtual method returning a float using va_list as arguments. Return.
 */
probe hotspot.jni.CallNonvirtualFloatMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualFloatMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualFloatMethodV__return")
{
  name = "CallNonvirtualFloatMethodV"
  retstr = ""
}

/* hotspot.jni.CallNonvirtualIntMethodA
 * Call non-virtual method returning a int using an array as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualIntMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualIntMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualIntMethodA__entry")
{
  name = "CallNonvirtualIntMethodA"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualIntMethodA.return
 * Call non-virtual method returning a int using an array as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallNonvirtualIntMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualIntMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualIntMethodA__return")
{
  name = "CallNonvirtualIntMethodA"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallNonvirtualIntMethod
 * Call non-virtual method returning a int.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualIntMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualIntMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualIntMethod__entry")
{
  name = "CallNonvirtualIntMethod"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualIntMethod.return
 * Call non-virtual method returning a int. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallNonvirtualIntMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualIntMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualIntMethod__return")
{
  name = "CallNonvirtualIntMethod"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallNonvirtualIntMethodV
 * Call non-virtual method returning a int using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualIntMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualIntMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualIntMethodV__entry")
{
  name = "CallNonvirtualIntMethodV"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualIntMethodV.return
 * Call non-virtual method returning a int using va_list as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallNonvirtualIntMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualIntMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualIntMethodV__return")
{
  name = "CallNonvirtualIntMethodV"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallNonvirtualLongMethodA
 * Call non-virtual method returning a long using an array as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualLongMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualLongMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualLongMethodA__entry")
{
  name = "CallNonvirtualLongMethodA"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualLongMethodA.return
 * Call non-virtual method returning a long using an array as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallNonvirtualLongMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualLongMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualLongMethodA__return")
{
  name = "CallNonvirtualLongMethodA"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallNonvirtualLongMethod
 * Call non-virtual method returning a long.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualLongMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualLongMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualLongMethod__entry")
{
  name = "CallNonvirtualLongMethod"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualLongMethod.return
 * Call non-virtual method returning a long. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallNonvirtualLongMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualLongMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualLongMethod__return")
{
  name = "CallNonvirtualLongMethod"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallNonvirtualLongMethodV
 * Call non-virtual method returning a long using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualLongMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualLongMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualLongMethodV__entry")
{
  name = "CallNonvirtualLongMethodV"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualLongMethodV.return
 * Call non-virtual method returning a long using va_list as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallNonvirtualLongMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualLongMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualLongMethodV__return")
{
  name = "CallNonvirtualLongMethodV"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallNonvirtualObjectMethodA
 * Call non-virtual method returning a object using array as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualObjectMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualObjectMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualObjectMethodA__entry")
{
  name = "CallNonvirtualObjectMethodA"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualObjectMethodA.return
 * Call non-virtual method returning a object using array as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallNonvirtualObjectMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualObjectMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualObjectMethodA__return")
{
  name = "CallNonvirtualObjectMethodA"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.CallNonvirtualObjectMethod
 * Call non-virtual method returning a object.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualObjectMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualObjectMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualObjectMethod__entry")
{
  name = "CallNonvirtualObjectMethod"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualObjectMethod.return
 * Call non-virtual method returning a object. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallNonvirtualObjectMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualObjectMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualObjectMethod__return")
{
  name = "CallNonvirtualObjectMethod"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.CallNonvirtualObjectMethodV
 * Call non-virtual method returning a object using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualObjectMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualObjectMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualObjectMethodV__entry")
{
  name = "CallNonvirtualObjectMethodV"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualObjectMethodV.return
 * Call non-virtual method returning a object using va_list as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallNonvirtualObjectMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualObjectMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualObjectMethodV__return")
{
  name = "CallNonvirtualObjectMethodV"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.CallNonvirtualShortMethodA
 * Call non-virtual method returning a short using array as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualShortMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualShortMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualShortMethodA__entry")
{
  name = "CallNonvirtualShortMethodA"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualShortMethodA.return
 * Call non-virtual method returning a short using array as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallNonvirtualShortMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualShortMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualShortMethodA__return")
{
  name = "CallNonvirtualShortMethodA"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallNonvirtualShortMethod
 * Call non-virtual method returning a short.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualShortMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualShortMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualShortMethod__entry")
{
  name = "CallNonvirtualShortMethod"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualShortMethod.return
 * Call non-virtual method returning a short. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallNonvirtualShortMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualShortMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualShortMethod__return")
{
  name = "CallNonvirtualShortMethod"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallNonvirtualShortMethodV
 * Call non-virtual method returning a short using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualShortMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualShortMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualShortMethodV__entry")
{
  name = "CallNonvirtualShortMethodV"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualShortMethodV.return
 * Call non-virtual method returning a short using va_list as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallNonvirtualShortMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualShortMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualShortMethodV__return")
{
  name = "CallNonvirtualShortMethodV"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallNonvirtualVoidMethodA
 * Call non-virtual method returning void using array as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualVoidMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualVoidMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualVoidMethodA__entry")
{
  name = "CallNonvirtualVoidMethodA"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualVoidMethodA.return
 * Call non-virtual method returning void using array as arguments. Return.
 */
probe hotspot.jni.CallNonvirtualVoidMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualVoidMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualVoidMethodA__return")
{
  name = "CallNonvirtualVoidMethodA"
  retstr = ""
}

/* hotspot.jni.CallNonvirtualVoidMethod
 * Call non-virtual method returning void.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualVoidMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualVoidMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualVoidMethod__entry")
{
  name = "CallNonvirtualVoidMethod"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualVoidMethod.return
 * Call non-virtual method returning void. Return.
 */
probe hotspot.jni.CallNonvirtualVoidMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualVoidMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualVoidMethod__return")
{
  name = "CallNonvirtualVoidMethod"
  retstr = ""
}

/* hotspot.jni.CallNonvirtualVoidMethodV
 * Call non-virtual method returning void using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallNonvirtualVoidMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualVoidMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualVoidMethodV__entry")
{
  name = "CallNonvirtualVoidMethodV"
  env = $arg1
  obj = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,methodid=0x%x)", name, env, obj, methodid)
}

/* hotspot.jni.CallNonvirtualVoidMethodV.return
 * Call non-virtual method returning void using va_list as arguments. Return.
 */
probe hotspot.jni.CallNonvirtualVoidMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallNonvirtualVoidMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallNonvirtualVoidMethodV__return")
{
  name = "CallNonvirtualVoidMethodV"
  retstr = ""
}

/* hotspot.jni.CallStaticBooleanMethodA
 * Call static method returning a boolean using an array as arguments.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticBooleanMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticBooleanMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticBooleanMethodA__entry")
{
  name = "CallStaticBooleanMethodA"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticBooleanMethodA.return
 * Call static method returning a boolean using an array as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallStaticBooleanMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticBooleanMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticBooleanMethodA__return")
{
  name = "CallStaticBooleanMethodA"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallStaticBooleanMethod
 * Call static method returning a boolean.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticBooleanMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticBooleanMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticBooleanMethod__entry")
{
  name = "CallStaticBooleanMethod"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticBooleanMethod.return
 * Call static method returning a boolean. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallStaticBooleanMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticBooleanMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticBooleanMethod__return")
{
  name = "CallStaticBooleanMethod"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallStaticBooleanMethodV
 * Call static method returning a boolean using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticBooleanMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticBooleanMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticBooleanMethodV__entry")
{
  name = "CallStaticBooleanMethodV"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticBooleanMethodV.return
 * Call static method returning a boolean using va_list as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallStaticBooleanMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticBooleanMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticBooleanMethodV__return")
{
  name = "CallStaticBooleanMethodV"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallStaticByteMethodA
 * Call static method returning a byte using an array as arguments.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticByteMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticByteMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticByteMethodA__entry")
{
  name = "CallStaticByteMethodA"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticByteMethodA.return
 * Call static method returning a byte using an array as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallStaticByteMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticByteMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticByteMethodA__return")
{
  name = "CallStaticByteMethodA"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallStaticByteMethod
 * Call static method returning a byte.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticByteMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticByteMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticByteMethod__entry")
{
  name = "CallStaticByteMethod"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticByteMethod.return
 * Call static method returning a byte. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallStaticByteMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticByteMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticByteMethod__return")
{
  name = "CallStaticByteMethod"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallStaticByteMethodV
 * Call static method returning a byte using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticByteMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticByteMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticByteMethodV__entry")
{
  name = "CallStaticByteMethodV"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticByteMethodV.return
 * Call static method returning a byte using va_list as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallStaticByteMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticByteMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticByteMethodV__return")
{
  name = "CallStaticByteMethodV"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallStaticCharMethodA
 * Call static method returning a char using an array as arguments.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticCharMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticCharMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticCharMethodA__entry")
{
  name = "CallStaticCharMethodA"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticCharMethodA.return
 * Call static method returning a char using an array as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallStaticCharMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticCharMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticCharMethodA__return")
{
  name = "CallStaticCharMethodA"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallStaticCharMethod
 * Call static method returning a char.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticCharMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticCharMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticCharMethod__entry")
{
  name = "CallStaticCharMethod"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticCharMethod.return
 * Call static method returning a char. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallStaticCharMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticCharMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticCharMethod__return")
{
  name = "CallStaticCharMethod"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallStaticCharMethodV
 * Call static method returning a char using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticCharMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticCharMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticCharMethodV__entry")
{
  name = "CallStaticCharMethodV"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticCharMethodV.return
 * Call static method returning a char using va_list as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallStaticCharMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticCharMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticCharMethodV__return")
{
  name = "CallStaticCharMethodV"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallStaticDoubleMethodA
 * Call static method returning a double using an array as arguments.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticDoubleMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticDoubleMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticDoubleMethodA__entry")
{
  name = "CallStaticDoubleMethodA"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticDoubleMethodA.return
 * Call static method returning a double using an array as arguments. Return.
 */
probe hotspot.jni.CallStaticDoubleMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticDoubleMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticDoubleMethodA__return")
{
  name = "CallStaticDoubleMethodA"
  retstr = ""
}

/* hotspot.jni.CallStaticDoubleMethod
 * Call static method returning a double.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticDoubleMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticDoubleMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticDoubleMethod__entry")
{
  name = "CallStaticDoubleMethod"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticDoubleMethod.return
 * Call static method returning a double. Return.
 */
probe hotspot.jni.CallStaticDoubleMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticDoubleMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticDoubleMethod__return")
{
  name = "CallStaticDoubleMethod"
  retstr = ""
}

/* hotspot.jni.CallStaticDoubleMethodV
 * Call static method returning a double using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticDoubleMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticDoubleMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticDoubleMethodV__entry")
{
  name = "CallStaticDoubleMethodV"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticDoubleMethodV.return
 * Call static method returning a double using va_list as arguments. Return.
 */
probe hotspot.jni.CallStaticDoubleMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticDoubleMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticDoubleMethodV__return")
{
  name = "CallStaticDoubleMethodV"
  retstr = ""
}

/* hotspot.jni.CallStaticFloatMethodA
 * Call static method returning a float using an array as arguments.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticFloatMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticFloatMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticFloatMethodA__entry")
{
  name = "CallStaticFloatMethodA"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticFloatMethodA.return
 * Call static method returning a float using an array as arguments. Return.
 */
probe hotspot.jni.CallStaticFloatMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticFloatMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticFloatMethodA__return")
{
  name = "CallStaticFloatMethodA"
  retstr = ""
}

/* hotspot.jni.CallStaticFloatMethod
 * Call static method returning a float.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticFloatMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticFloatMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticFloatMethod__entry")
{
  name = "CallStaticFloatMethod"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticFloatMethod.return
 * Call static method returning a float. Return.
 */
probe hotspot.jni.CallStaticFloatMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticFloatMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticFloatMethod__return")
{
  name = "CallStaticFloatMethod"
  retstr = ""
}

/* hotspot.jni.CallStaticFloatMethodV
 * Call static method returning a float using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticFloatMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticFloatMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticFloatMethodV__entry")
{
  name = "CallStaticFloatMethodV"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticFloatMethodV.return
 * Call static method returning a float using va_list as arguments. Return.
 */
probe hotspot.jni.CallStaticFloatMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticFloatMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticFloatMethodV__return")
{
  name = "CallStaticFloatMethodV"
  retstr = ""
}

/* hotspot.jni.CallStaticIntMethodA
 * Call static method returning a int using an array as arguments.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticIntMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticIntMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticIntMethodA__entry")
{
  name = "CallStaticIntMethodA"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticIntMethodA.return
 * Call static method returning a int using an array as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallStaticIntMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticIntMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticIntMethodA__return")
{
  name = "CallStaticIntMethodA"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallStaticIntMethod
 * Call static method returning a int.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticIntMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticIntMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticIntMethod__entry")
{
  name = "CallStaticIntMethod"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticIntMethod.return
 * Call static method returning a int. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallStaticIntMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticIntMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticIntMethod__return")
{
  name = "CallStaticIntMethod"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallStaticIntMethodV
 * Call static method returning a int using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticIntMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticIntMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticIntMethodV__entry")
{
  name = "CallStaticIntMethodV"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticIntMethodV.return
 * Call static method returning a int using va_list as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallStaticIntMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticIntMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticIntMethodV__return")
{
  name = "CallStaticIntMethodV"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallStaticLongMethodA
 * Call static method returning a long using an array as arguments.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticLongMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticLongMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticLongMethodA__entry")
{
  name = "CallStaticLongMethodA"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticLongMethodA.return
 * Call static method returning a long using an array as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallStaticLongMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticLongMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticLongMethodA__return")
{
  name = "CallStaticLongMethodA"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallStaticLongMethod
 * Call static method returning a long.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticLongMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticLongMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticLongMethod__entry")
{
  name = "CallStaticLongMethod"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticLongMethod.return
 * Call static method returning a long. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallStaticLongMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticLongMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticLongMethod__return")
{
  name = "CallStaticLongMethod"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallStaticLongMethodV
 * Call static method returning a long using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticLongMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticLongMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticLongMethodV__entry")
{
  name = "CallStaticLongMethodV"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticLongMethodV.return
 * Call static method returning a long using va_list as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallStaticLongMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticLongMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticLongMethodV__return")
{
  name = "CallStaticLongMethodV"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallStaticObjectMethodA
 * Call static method returning a object using array as arguments.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticObjectMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticObjectMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticObjectMethodA__entry")
{
  name = "CallStaticObjectMethodA"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticObjectMethodA.return
 * Call static method returning a object using array as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallStaticObjectMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticObjectMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticObjectMethodA__return")
{
  name = "CallStaticObjectMethodA"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.CallStaticObjectMethod
 * Call static method returning a object.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticObjectMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticObjectMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticObjectMethod__entry")
{
  name = "CallStaticObjectMethod"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticObjectMethod.return
 * Call static method returning a object. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallStaticObjectMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticObjectMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticObjectMethod__return")
{
  name = "CallStaticObjectMethod"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.CallStaticObjectMethodV
 * Call static method returning a object using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticObjectMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticObjectMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticObjectMethodV__entry")
{
  name = "CallStaticObjectMethodV"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticObjectMethodV.return
 * Call static method returning a object using va_list as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallStaticObjectMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticObjectMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticObjectMethodV__return")
{
  name = "CallStaticObjectMethodV"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.CallStaticShortMethodA
 * Call static method returning a short using array as arguments.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticShortMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticShortMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticShortMethodA__entry")
{
  name = "CallStaticShortMethodA"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticShortMethodA.return
 * Call static method returning a short using array as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallStaticShortMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticShortMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticShortMethodA__return")
{
  name = "CallStaticShortMethodA"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallStaticShortMethod
 * Call static method returning a short.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticShortMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticShortMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticShortMethod__entry")
{
  name = "CallStaticShortMethod"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticShortMethod.return
 * Call static method returning a short. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallStaticShortMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticShortMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticShortMethod__return")
{
  name = "CallStaticShortMethod"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallStaticShortMethodV
 * Call static method returning a short using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticShortMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticShortMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticShortMethodV__entry")
{
  name = "CallStaticShortMethodV"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticShortMethodV.return
 * Call static method returning a short using va_list as arguments. Return.
 *
 * ret - The result of the method call.
 */
probe hotspot.jni.CallStaticShortMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticShortMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticShortMethodV__return")
{
  name = "CallStaticShortMethodV"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.CallStaticVoidMethodA
 * Call static method returning void using array as arguments.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticVoidMethodA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticVoidMethodA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticVoidMethodA__entry")
{
  name = "CallStaticVoidMethodA"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticVoidMethodA.return
 * Call static method returning void using array as arguments. Return.
 */
probe hotspot.jni.CallStaticVoidMethodA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticVoidMethodA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticVoidMethodA__return")
{
  name = "CallStaticVoidMethodA"
  retstr = ""
}

/* hotspot.jni.CallStaticVoidMethod
 * Call static method returning void.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticVoidMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticVoidMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticVoidMethod__entry")
{
  name = "CallStaticVoidMethod"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticVoidMethod.return
 * Call static method returning void. Return.
 */
probe hotspot.jni.CallStaticVoidMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticVoidMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticVoidMethod__return")
{
  name = "CallStaticVoidMethod"
  retstr = ""
}

/* hotspot.jni.CallStaticVoidMethodV
 * Call static method returning void using va_list as arguments.
 *
 * env - JNIEnv pointer.
 * clazz - jclass reference.
 * methodid - ID of the method to call.
 */
probe hotspot.jni.CallStaticVoidMethodV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticVoidMethodV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticVoidMethodV__entry")
{
  name = "CallStaticVoidMethodV"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.CallStaticVoidMethodV.return
 * Call static method returning void using va_list as arguments. Return.
 */
probe hotspot.jni.CallStaticVoidMethodV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CallStaticVoidMethodV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CallStaticVoidMethodV__return")
{
  name = "CallStaticVoidMethodV"
  retstr = ""
}

/* hotspot.jni.CreateJavaVM
 * Creates a java virtual machine instance.
 *
 * vm - pointer to a JavaVM pointer.
 * penv - pointer to JNIEnv pointer.
 * args - pointer to JavaVMInitArgs struct.
 */
probe hotspot.jni.CreateJavaVM =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CreateJavaVM__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CreateJavaVM__entry")
{
  name = "CreateJavaVM"
  vm = $arg1
  penv = $arg2
  args = $arg3
  probestr = sprintf("%s(vm=0x%x,penv=0x%x,args=0x%x)", name, vm, penv, args)
}

/* hotspot.jni.CreateJavaVM.return
 * Creates a java virtual machine instance. Return.
 *
 * ret - Zero on success, negative on error.
 */
probe hotspot.jni.CreateJavaVM.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("CreateJavaVM__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("CreateJavaVM__return")
{
  name = "CreateJavaVM"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.DefineClass
 * Defines a java.lang.Class instance from byte code array.
 *
 * env - JNIEnv pointer.
 * clazz - Name of class.
 * loader - jobject of ClassLoader.
 * buf - Pointer to jbyte array.
 * buflen - Size of jbyte array.
 */
probe hotspot.jni.DefineClass =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("DefineClass__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("DefineClass__entry")
{
  name = "DefineClass"
  env = $arg1
  clazz = user_string($arg2)
  loader = $arg3
  buf = $arg4
  buflen = $arg5
  probestr = sprintf("%s(env=0x%x,clazz='%s',loader=0x%x,buf=0x%x,buflen=%d)", name, env, clazz, loader, buf, buflen)
}

/* hotspot.jni.DefineClass.return
 * Defines a java.lang.Class instance from byte code array. Return.
 *
 * ret - jclass or NULL on error.
 */
probe hotspot.jni.DefineClass.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("DefineClass__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("DefineClass__return")
{
  name = "DefineClass"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.DeleteGlobalRef
 * Delete a global jobject reference.
 *
 * env - JNIEnv pointer.
 * gref - jobject reference to free.
 */
probe hotspot.jni.DeleteGlobalRef =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("DeleteGlobalRef__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("DeleteGlobalRef__entry")
{
  name = "DeleteGlobalRef"
  env = $arg1
  gref = $arg2
  probestr = sprintf("%s(env=0x%x,gref=0x%x)", name, env, gref)
}

/* hotspot.jni.DeleteGlobalRef.return
 * Delete a global jobject reference. Return.
 */
probe hotspot.jni.DeleteGlobalRef.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("DeleteGlobalRef__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("DeleteGlobalRef__return")
{
  name = "DeleteGlobalRef"
  retstr = ""
}

/* hotspot.jni.DeleteLocalRef
 * Delete a local jobject reference.
 *
 * env - JNIEnv pointer.
 * lref - jobject reference to free.
 */
probe hotspot.jni.DeleteLocalRef =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("DeleteLocalRef__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("DeleteLocalRef__entry")
{
  name = "DeleteLocalRef"
  env = $arg1
  lref = $arg2
  probestr = sprintf("%s(env=0x%x,lref=0x%x)", name, env, lref)
}

/* hotspot.jni.DeleteLocalRef.return
 * Delete a local jobject reference. Return.
 */
probe hotspot.jni.DeleteLocalRef.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("DeleteLocalRef__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("DeleteLocalRef__return")
{
  name = "DeleteLocalRef"
  retstr = ""
}

/* hotspot.jni.DeleteWeakGlobalRef
 * Delete a weak global jobject reference.
 *
 * env - JNIEnv pointer.
 * wref - jobject reference to free.
 */
probe hotspot.jni.DeleteWeakGlobalRef =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("DeleteWeakGlobalRef__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("DeleteWeakGlobalRef__entry")
{
  name = "DeleteWeakGlobalRef"
  env = $arg1
  wref = $arg2
  probestr = sprintf("%s(env=0x%x,wref=0x%x)", name, env, wref)
}

/* hotspot.jni.DeleteWeakGlobalRef.return
 * Delete a weak global jobject reference. Return.
 */
probe hotspot.jni.DeleteWeakGlobalRef.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("DeleteWeakGlobalRef__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("DeleteWeakGlobalRef__return")
{
  name = "DeleteWeakGlobalRef"
  retstr = ""
}

/* hotspot.jni.DestroyJavaVM
 * Destroys the given java virtual machine instance.
 *
 * vm - JavaVM pointer.
 */
probe hotspot.jni.DestroyJavaVM =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("DestroyJavaVM__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("DestroyJavaVM__entry")
{
  name = "DestroyJavaVM"
  vm = $arg1
  probestr = sprintf("%s(vm=0x%x)", name, vm)
}

/* hotspot.jni.DestroyJavaVM.return
 * Destroys the given java virtual machine instance. Return.
 *
 * ret - Zero on success, negative on failure.
 */
probe hotspot.jni.DestroyJavaVM.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("DestroyJavaVM__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("DestroyJavaVM__return")
{
  name = "DestroyJavaVM"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.DetachCurrentThread
 * Detaches current thread.
 *
 * vm - JavaVM pointer.
 */
probe hotspot.jni.DetachCurrentThread =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("DetachCurrentThread__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("DetachCurrentThread__entry")
{
  name = "DetachCurrentThread"
  vm = $arg1
  probestr = sprintf("%s(vm=0x%x)", name, vm)
}

/* hotspot.jni.DetachCurrentThread.return
 * Detaches current thread. Return.
 *
 * ret - Zero on success, negative on failure.
 */
probe hotspot.jni.DetachCurrentThread.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("DetachCurrentThread__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("DetachCurrentThread__return")
{
  name = "DetachCurrentThread"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.EnsureLocalCapacity
 * Make sure capacity local references can be created.
 *
 * env - JNIEnv pointer.
 * capacity - Number of desired local references.
 */
probe hotspot.jni.EnsureLocalCapacity =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("EnsureLocalCapacity__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("EnsureLocalCapacity__entry")
{
  name = "EnsureLocalCapacity"
  env = $arg1
  capacity = $arg2
  probestr = sprintf("%s(env=0x%x,capacity=%d)", name, env, capacity)
}

/* hotspot.jni.EnsureLocalCapacity.return
 * Make sure capacity local references can be created. Return.
 *
 * ret - Returns zero on success, negative otherwise.
 */
probe hotspot.jni.EnsureLocalCapacity.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("EnsureLocalCapacity__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("EnsureLocalCapacity__return")
{
  name = "EnsureLocalCapacity"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.ExceptionCheck
 * Check whether there is a pending exception.
 *
 * env - JNIEnv pointer.
 */
probe hotspot.jni.ExceptionCheck =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ExceptionCheck__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ExceptionCheck__entry")
{
  name = "ExceptionCheck"
  env = $arg1
  probestr = sprintf("%s(env=0x%x)", name, env)
}

/* hotspot.jni.ExceptionCheck.return
 * Check whether there is a pending exception. Return.
 *
 * ret - One if there is a pending exception, zero if not.
 */
probe hotspot.jni.ExceptionCheck.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ExceptionCheck__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ExceptionCheck__return")
{
  name = "ExceptionCheck"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.ExceptionClear
 * Clear any pending exception.
 *
 * env - JNIEnv pointer.
 */
probe hotspot.jni.ExceptionClear =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ExceptionClear__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ExceptionClear__entry")
{
  name = "ExceptionClear"
  env = $arg1
  probestr = sprintf("%s(env=0x%x)", name, env)
}

/* hotspot.jni.ExceptionClear.return
 * Clear any pending exception. Return.
 */
probe hotspot.jni.ExceptionClear.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ExceptionClear__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ExceptionClear__return")
{
  name = "ExceptionClear"
  retstr = ""
}

/* hotspot.jni.ExceptionDescribe
 * Print any pending exception plus backtrace, clearing exception.
 *
 * env - JNIEnv pointer.
 */
probe hotspot.jni.ExceptionDescribe =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ExceptionDescribe__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ExceptionDescribe__entry")
{
  name = "ExceptionDescribe"
  env = $arg1
  probestr = sprintf("%s(env=0x%x)", name, env)
}

/* hotspot.jni.ExceptionDescribe.return
 * Print any pending exception plus backtrace, clearing exception. Return.
 */
probe hotspot.jni.ExceptionDescribe.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ExceptionDescribe__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ExceptionDescribe__return")
{
  name = "ExceptionDescribe"
  retstr = ""
}

/* hotspot.jni.ExceptionOccurred
 * Returns any pending exception.
 *
 * env - JNIEnv pointer.
 */
probe hotspot.jni.ExceptionOccurred =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ExceptionOccurred__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ExceptionOccurred__entry")
{
  name = "ExceptionOccurred"
  env = $arg1
  probestr = sprintf("%s(env=0x%x)", name, env)
}

/* hotspot.jni.ExceptionOccurred.return
 * Returns any pending exception. Return.
 *
 * ret - Pending jthrowable or NULL when no exception pending.
 */
probe hotspot.jni.ExceptionOccurred.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ExceptionOccurred__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ExceptionOccurred__return")
{
  name = "ExceptionOccurred"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.FatalError
 * Abort JVM because of fatal error.
 *
 * env - JNIEnv pointer.
 * msg - Fatal exception message.
 */
probe hotspot.jni.FatalError =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("FatalError__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("FatalError__entry")
{
  name = "FatalError"
  env = $arg1
  msg = user_string($arg2)
  probestr = sprintf("%s(env=0x%x,msg='%s')", name, env, msg)
}

/* hotspot.jni.FindClass
 * Finds the named class.
 *
 * env - JNIEnv pointer.
 * clazz - Class descriptor.
 */
probe hotspot.jni.FindClass =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("FindClass__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("FindClass__entry")
{
  name = "FindClass"
  env = $arg1
  clazz = user_string($arg2)
  probestr = sprintf("%s(env=0x%x,clazz='%s')", name, env, clazz)
}

/* hotspot.jni.FindClass.return
 * Finds the named class. Return.
 *
 * ret - jclass pointer or NULL when class cannot be found.
 */
probe hotspot.jni.FindClass.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("FindClass__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("FindClass__return")
{
  name = "FindClass"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.FromReflectedField
 * Returns a jfieldID from a Field instance.
 *
 * env - JNIEnv pointer.
 * field - jobject field.
 */
probe hotspot.jni.FromReflectedField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("FromReflectedField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("FromReflectedField__entry")
{
  name = "FromReflectedField"
  env = $arg1
  field = $arg2
  probestr = sprintf("%s(env=0x%x,field=0x%x)", name, env, field)
}

/* hotspot.jni.FromReflectedField.return
 * Returns a jfieldID from a Field instance. Return.
 *
 * ret - jfieldID or NULL on error.
 */
probe hotspot.jni.FromReflectedField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("FromReflectedField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("FromReflectedField__return")
{
  name = "FromReflectedField"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.FromReflectedMethod
 * Returns a jmethodID from a Method instance.
 *
 * env - JNIEnv pointer.
 * method - jobject method.
 */
probe hotspot.jni.FromReflectedMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("FromReflectedMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("FromReflectedMethod__entry")
{
  name = "FromReflectedMethod"
  env = $arg1
  method = $arg2
  probestr = sprintf("%s(env=0x%x,method=0x%x)", name, env, method)
}

/* hotspot.jni.FromReflectedMethod.return
 * Returns a jmethodID from a Method instance. Return.
 *
 * ret - jmethodID or NULL on error.
 */
probe hotspot.jni.FromReflectedMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("FromReflectedMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("FromReflectedMethod__return")
{
  name = "FromReflectedMethod"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.GetArrayLength
 * Gets the length of an array.
 *
 * env - JNIEnv pointer.
 * array - jarray.
 */
probe hotspot.jni.GetArrayLength =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetArrayLength__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetArrayLength__entry")
{
  name = "GetArrayLength"
  env = $arg1
  array = $arg2
  probestr = sprintf("%s(env=0x%x,array=0x%x)", name, env, array)
}

/* hotspot.jni.GetArrayLength.return
 * Gets the length of an array. Return.
 *
 * ret - Length of the jarray.
 */
probe hotspot.jni.GetArrayLength.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetArrayLength__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetArrayLength__return")
{
  name = "GetArrayLength"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.GetBooleanArrayElements
 * Returns jboolean array elements.
 *
 * env - JNIEnv pointer.
 * array - jbooleanArray.
 * iscopy - Pointer to jboolean.
 */
probe hotspot.jni.GetBooleanArrayElements =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetBooleanArrayElements__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetBooleanArrayElements__entry")
{
  name = "GetBooleanArrayElements"
  env = $arg1
  array = $arg2
  iscopy = $arg3
  probestr = sprintf("%s(env=0x%x,array=0x%x,iscopy=0x%x)", name, env, array, iscopy)
}

/* hotspot.jni.GetBooleanArrayElements.return
 * Returns jboolean array elements. Return.
 *
 * ret - Pointer to jboolean array.
 */
probe hotspot.jni.GetBooleanArrayElements.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetBooleanArrayElements__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetBooleanArrayElements__return")
{
  name = "GetBooleanArrayElements"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.GetBooleanArrayRegion
 * Copies a region out of a jboolean array elements.
 *
 * env - JNIEnv pointer.
 * array - jbooleanArray to copy from.
 * start - Starting index.
 * len - Number of elements to copy.
 * buf - Native jboolean array pointer to copy into.
 */
probe hotspot.jni.GetBooleanArrayRegion =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetBooleanArrayRegion__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetBooleanArrayRegion__entry")
{
  name = "GetBooleanArrayRegion"
  env = $arg1
  array = $arg2
  start = $arg3
  len = $arg4
  buf = $arg5
  probestr = sprintf("%s(env=0x%x,array=0x%x,start=%d,len=%d,buf=0x%x)", name, env, array, start, len, buf)
}

/* hotspot.jni.GetBooleanArrayRegion.return
 * Copies a region out of a jboolean array elements. Return.
 */
probe hotspot.jni.GetBooleanArrayRegion.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetBooleanArrayRegion__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetBooleanArrayRegion__return")
{
  name = "GetBooleanArrayRegion"
  retstr = ""
}

/* hotspot.jni.GetBooleanField
 * Get non-static jboolean field value.
 * NEEDS: -XX:-UseFastJNIAccessors
 *
 * env - JNIEnv pointer.
 * obj - jobject.
 * field - jfieldID.
 */
probe hotspot.jni.GetBooleanField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetBooleanField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetBooleanField__entry")
{
  name = "GetBooleanField"
  env = $arg1
  obj = $arg2
  field = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,field=0x%x)", name, env, obj, field)
}

/* hotspot.jni.GetBooleanField.return
 * Get non-static jboolean field value. Return.
 * NEEDS: -XX:-UseFastJNIAccessors
 *
 * ret - jboolean value.
 */
probe hotspot.jni.GetBooleanField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetBooleanField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetBooleanField__return")
{
  name = "GetBooleanField"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.GetByteArrayElements
 * Returns jbyte array elements.
 *
 * env - JNIEnv pointer.
 * array - jbyteArray.
 * iscopy - Pointer to jboolean.
 */
probe hotspot.jni.GetByteArrayElements =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetByteArrayElements__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetByteArrayElements__entry")
{
  name = "GetByteArrayElements"
  env = $arg1
  array = $arg2
  iscopy = $arg3
  probestr = sprintf("%s(env=0x%x,array=0x%x,iscopy=0x%x)", name, env, array, iscopy)
}

/* hotspot.jni.GetByteArrayElements.return
 * Returns jbyte array elements. Return.
 *
 * ret - Pointer to jbyte array.
 */
probe hotspot.jni.GetByteArrayElements.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetByteArrayElements__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetByteArrayElements__return")
{
  name = "GetByteArrayElements"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.GetByteArrayRegion
 * Copies a region out of a jbyte array elements.
 *
 * env - JNIEnv pointer.
 * array - jbyteArray to copy from.
 * start - Starting index.
 * len - Number of elements to copy.
 * buf - Native jbyte array pointer to copy into.
 */
probe hotspot.jni.GetByteArrayRegion =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetByteArrayRegion__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetByteArrayRegion__entry")
{
  name = "GetByteArrayRegion"
  env = $arg1
  array = $arg2
  start = $arg3
  len = $arg4
  buf = $arg5
  probestr = sprintf("%s(env=0x%x,array=0x%x,start=%d,len=%d,buf=0x%x)", name, env, array, start, len, buf)
}

/* hotspot.jni.GetByteArrayRegion.return
 * Copies a region out of a jbyte array elements. Return.
 */
probe hotspot.jni.GetByteArrayRegion.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetByteArrayRegion__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetByteArrayRegion__return")
{
  name = "GetByteArrayRegion"
  retstr = ""
}

/* hotspot.jni.GetByteField
 * Get non-static jbyte field value.
 * NEEDS: -XX:-UseFastJNIAccessors
 *
 * env - JNIEnv pointer.
 * obj - jobject.
 * field - jfieldID.
 */
probe hotspot.jni.GetByteField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetByteField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetByteField__entry")
{
  name = "GetByteField"
  env = $arg1
  obj = $arg2
  field = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,field=0x%x)", name, env, obj, field)
}

/* hotspot.jni.GetByteField.return
 * Get non-static jbyte field value. Return.
 * NEEDS: -XX:-UseFastJNIAccessors
 *
 * ret - jbyte value.
 */
probe hotspot.jni.GetByteField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetByteField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetByteField__return")
{
  name = "GetByteField"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.GetCharArrayElements
 * Returns jchar array elements.
 *
 * env - JNIEnv pointer.
 * array - jcharArray.
 * iscopy - Pointer to jboolean.
 */
probe hotspot.jni.GetCharArrayElements =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetCharArrayElements__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetCharArrayElements__entry")
{
  name = "GetCharArrayElements"
  env = $arg1
  array = $arg2
  iscopy = $arg3
  probestr = sprintf("%s(env=0x%x,array=0x%x,iscopy=0x%x)", name, env, array, iscopy)
}

/* hotspot.jni.GetCharArrayElements.return
 * Returns jchar array elements. Return.
 *
 * ret - Pointer to jchar array.
 */
probe hotspot.jni.GetCharArrayElements.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetCharArrayElements__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetCharArrayElements__return")
{
  name = "GetCharArrayElements"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.GetCharArrayRegion
 * Copies a region out of a jchar array elements.
 *
 * env - JNIEnv pointer.
 * array - jcharArray to copy from.
 * start - Starting index.
 * len - Number of elements to copy.
 * buf - Native jchar array pointer to copy into.
 */
probe hotspot.jni.GetCharArrayRegion =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetCharArrayRegion__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetCharArrayRegion__entry")
{
  name = "GetCharArrayRegion"
  env = $arg1
  array = $arg2
  start = $arg3
  len = $arg4
  buf = $arg5
  probestr = sprintf("%s(env=0x%x,array=0x%x,start=%d,len=%d,buf=0x%x)", name, env, array, start, len, buf)
}

/* hotspot.jni.GetCharArrayRegion.return
 * Copies a region out of a jchar array elements. Return.
 */
probe hotspot.jni.GetCharArrayRegion.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetCharArrayRegion__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetCharArrayRegion__return")
{
  name = "GetCharArrayRegion"
  retstr = ""
}

/* hotspot.jni.GetCharField
 * Get non-static jchar field value.
 * NEEDS: -XX:-UseFastJNIAccessors
 *
 * env - JNIEnv pointer.
 * obj - jobject.
 * field - jfieldID.
 */
probe hotspot.jni.GetCharField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetCharField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetCharField__entry")
{
  name = "GetCharField"
  env = $arg1
  obj = $arg2
  field = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,field=0x%x)", name, env, obj, field)
}

/* hotspot.jni.GetCharField.return
 * Get non-static jchar field value. Return.
 * NEEDS: -XX:-UseFastJNIAccessors
 *
 * ret - jchar value.
 */
probe hotspot.jni.GetCharField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetCharField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetCharField__return")
{
  name = "GetCharField"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.GetCreatedJavaVMs
 * Return all created Java Virtual Machines.
 *
 * vmbuf - Pointer to JavaVM pointer.
 * buflen - Max number of vms returned.
 * nvms - Pointer to where the number of created JavaVMs will be returned.
 */
probe hotspot.jni.GetCreatedJavaVMs =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetCreatedJavaVMs__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetCreatedJavaVMs__entry")
{
  name = "GetCreatedJavaVMs"
  vmbuf = $arg1
  buflen = $arg2
  nvms = $arg3
  probestr = sprintf("%s(vmbuf=0x%x,buflen=%d,nvms=0x%x)", name, vmbuf, buflen, nvms)
}

/* hotspot.jni.GetCreatedJavaVMs.return
 * Return all created Java Virtual Machines. Return.
 *
 * ret - Zero on success, negative on error.
 */
probe hotspot.jni.GetCreatedJavaVMs.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetCreatedJavaVMs__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetCreatedJavaVMs__return")
{
  name = "GetCreatedJavaVMs"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.GetDefaultJavaVMInitArgs
 * Returns default vm configuration.
 *
 * vm_args - JDK1_1InitArgs pointer
 */
probe hotspot.jni.GetDefaultJavaVMInitArgs =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetDefaultJavaVMInitArgs__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetDefaultJavaVMInitArgs__entry")
{
  name = "GetDefaultJavaVMInitArgs"
  vm_args = $arg1
  probestr = sprintf("%s(vm_args=0x%x)", name, vm_args)
}

/* hotspot.jni.GetDefaultJavaVMInitArgs.return
 * Returns default vm configuration. Return.
 *
 * ret - Zero if JDK1_1InitArgs version field supporter, negative otherwise.
 */
probe hotspot.jni.GetDefaultJavaVMInitArgs.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetDefaultJavaVMInitArgs__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetDefaultJavaVMInitArgs__return")
{
  name = "GetDefaultJavaVMInitArgs"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.GetDirectBufferAddress
 * Returns starting memory address of given Buffer.
 *
 * env - JNIEnv pointer.
 * buf - java.nio.Buffer jobject.
 */
probe hotspot.jni.GetDirectBufferAddress =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetDirectBufferAddress__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetDirectBufferAddress__entry")
{
  name = "GetDirectBufferAddress"
  env = $arg1
  buf = $arg2
  probestr = sprintf("%s(env=0x%x,buf=0x%x)", name, env, buf)
}

/* hotspot.jni.GetDirectBufferAddress.return
 * Returns starting memory address of given Buffer. Return.
 *
 * ret - Address or NULL on error.
 */
probe hotspot.jni.GetDirectBufferAddress.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetDirectBufferAddress__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetDirectBufferAddress__return")
{
  name = "GetDirectBufferAddress"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.GetDirectBufferCapacity
 * Returns size of memory region of given Buffer.
 *
 * env - JNIEnv pointer.
 * buf - java.nio.Buffer jobject.
 */
probe hotspot.jni.GetDirectBufferCapacity =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetDirectBufferCapacity__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetDirectBufferCapacity__entry")
{
  name = "GetDirectBufferCapacity"
  env = $arg1
  buf = $arg2
  probestr = sprintf("%s(env=0x%x,buf=0x%x)", name, env, buf)
}

/* hotspot.jni.GetDirectBufferCapacity.return
 * Returns size of memory region of given Buffer. Return.
 *
 * ret - Capacity of buffer or -1 on error.
 */
probe hotspot.jni.GetDirectBufferCapacity.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetDirectBufferCapacity__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetDirectBufferCapacity__return")
{
  name = "GetDirectBufferCapacity"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.GetDoubleArrayElements
 * Returns jdouble array elements.
 *
 * env - JNIEnv pointer.
 * array - jdoubleArray.
 * iscopy - Pointer to jboolean.
 */
probe hotspot.jni.GetDoubleArrayElements =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetDoubleArrayElements__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetDoubleArrayElements__entry")
{
  name = "GetDoubleArrayElements"
  env = $arg1
  array = $arg2
  iscopy = $arg3
  probestr = sprintf("%s(env=0x%x,array=0x%x,iscopy=0x%x)", name, env, array, iscopy)
}

/* hotspot.jni.GetDoubleArrayElements.return
 * Returns jdouble array elements. Return.
 *
 * ret - Pointer to jdouble array.
 */
probe hotspot.jni.GetDoubleArrayElements.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetDoubleArrayElements__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetDoubleArrayElements__return")
{
  name = "GetDoubleArrayElements"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.GetDoubleArrayRegion
 * Copies a region out of a jdouble array elements.
 *
 * env - JNIEnv pointer.
 * array - jdoubleArray to copy from.
 * start - Starting index.
 * len - Number of elements to copy.
 * buf - Native jdouble array pointer to copy into.
 */
probe hotspot.jni.GetDoubleArrayRegion =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetDoubleArrayRegion__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetDoubleArrayRegion__entry")
{
  name = "GetDoubleArrayRegion"
  env = $arg1
  array = $arg2
  start = $arg3
  len = $arg4
  buf = $arg5
  probestr = sprintf("%s(env=0x%x,array=0x%x,start=%d,len=%d,buf=0x%x)", name, env, array, start, len, buf)
}

/* hotspot.jni.GetDoubleArrayRegion.return
 * Copies a region out of a jdouble array elements. Return.
 */
probe hotspot.jni.GetDoubleArrayRegion.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetDoubleArrayRegion__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetDoubleArrayRegion__return")
{
  name = "GetDoubleArrayRegion"
  retstr = ""
}

/* hotspot.jni.GetDoubleField
 * Get non-static jdouble field value.
 * NEEDS: -XX:-UseFastJNIAccessors
 *
 * env - JNIEnv pointer.
 * obj - jobject.
 * field - jfieldID.
 */
probe hotspot.jni.GetDoubleField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetDoubleField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetDoubleField__entry")
{
  name = "GetDoubleField"
  env = $arg1
  obj = $arg2
  field = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,field=0x%x)", name, env, obj, field)
}

/* hotspot.jni.GetDoubleField.return
 * Get non-static jdouble field value. Return.
 * NEEDS: -XX:-UseFastJNIAccessors
 */
probe hotspot.jni.GetDoubleField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetDoubleField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetDoubleField__return")
{
  name = "GetDoubleField"
  retstr = ""
}

/* hotspot.jni.GetEnv
 * Returns JNIEnv for current thread if attached and jni version supported.
 *
 * vm - JavaVM pointer.
 * penv - Pointer to JNIEnv pointer.
 * version - JNI version requested.
 */
probe hotspot.jni.GetEnv =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetEnv__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetEnv__entry")
{
  name = "GetEnv"
  vm = $arg1
  penv = $arg2
  version = $arg3
  probestr = sprintf("%s(vm=0x%x,penv=0x%x,version=0x%x)", name, vm, penv, version)
}

/* hotspot.jni.GetEnv.return
 * Returns JNIEnv for current thread if attached and jni version supported. Return.
 *
 * ret - ro on success, negative on error.
 */
probe hotspot.jni.GetEnv.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetEnv__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetEnv__return")
{
  name = "GetEnv"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.GetFieldID
 * Get jfieldID of a non-static field of a jclass.
 *
 * env - JNIEnv pointer.
 * clazz - jclass object.
 * field - UTF-8 field name.
 * sig - UTF-8 signature of the field.
 */
probe hotspot.jni.GetFieldID =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetFieldID__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetFieldID__entry")
{
  name = "GetFieldID"
  env = $arg1
  clazz = $arg2
  field = user_string($arg3)
  sig = user_string($arg4)
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,field='%s',sig='%s')", name, env, clazz, field, sig)
}

/* hotspot.jni.GetFieldID.return
 * Get jfieldID of a non-static field of a jclass. Return.
 *
 * ret - jfieldID or NULL on failure.
 */
probe hotspot.jni.GetFieldID.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetFieldID__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetFieldID__return")
{
  name = "GetFieldID"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.GetFloatArrayElements
 * Returns jfloat array elements.
 *
 * env - JNIEnv pointer.
 * array - jfloatArray.
 * iscopy - Pointer to jboolean.
 */
probe hotspot.jni.GetFloatArrayElements =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetFloatArrayElements__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetFloatArrayElements__entry")
{
  name = "GetFloatArrayElements"
  env = $arg1
  array = $arg2
  iscopy = $arg3
  probestr = sprintf("%s(env=0x%x,array=0x%x,iscopy=0x%x)", name, env, array, iscopy)
}

/* hotspot.jni.GetFloatArrayElements.return
 * Returns jfloat array elements. Return.
 *
 * ret - Pointer to jfloat array.
 */
probe hotspot.jni.GetFloatArrayElements.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetFloatArrayElements__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetFloatArrayElements__return")
{
  name = "GetFloatArrayElements"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.GetFloatArrayRegion
 * Copies a region out of a jfloat array elements.
 *
 * env - JNIEnv pointer.
 * array - jfloatArray to copy from.
 * start - Starting index.
 * len - Number of elements to copy.
 * buf - Native jfloat array pointer to copy into.
 */
probe hotspot.jni.GetFloatArrayRegion =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetFloatArrayRegion__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetFloatArrayRegion__entry")
{
  name = "GetFloatArrayRegion"
  env = $arg1
  array = $arg2
  start = $arg3
  len = $arg4
  buf = $arg5
  probestr = sprintf("%s(env=0x%x,array=0x%x,start=%d,len=%d,buf=0x%x)", name, env, array, start, len, buf)
}

/* hotspot.jni.GetFloatArrayRegion.return
 * Copies a region out of a jfloat array elements. Return.
 */
probe hotspot.jni.GetFloatArrayRegion.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetFloatArrayRegion__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetFloatArrayRegion__return")
{
  name = "GetFloatArrayRegion"
  retstr = ""
}

/* hotspot.jni.GetFloatField
 * Get non-static jfloat field value.
 * NEEDS: -XX:-UseFastJNIAccessors
 *
 * env - JNIEnv pointer.
 * obj - jobject.
 * field - jfieldID.
 */
probe hotspot.jni.GetFloatField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetFloatField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetFloatField__entry")
{
  name = "GetFloatField"
  env = $arg1
  obj = $arg2
  field = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,field=0x%x)", name, env, obj, field)
}

/* hotspot.jni.GetFloatField.return
 * Get non-static jfloat field value. Return.
 * NEEDS: -XX:-UseFastJNIAccessors
 */
probe hotspot.jni.GetFloatField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetFloatField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetFloatField__return")
{
  name = "GetFloatField"
  retstr = ""
}

/* hotspot.jni.GetIntArrayElements
 * Returns jint array elements.
 *
 * env - JNIEnv pointer.
 * array - jintArray.
 * iscopy - Pointer to jboolean.
 */
probe hotspot.jni.GetIntArrayElements =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetIntArrayElements__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetIntArrayElements__entry")
{
  name = "GetIntArrayElements"
  env = $arg1
  array = $arg2
  iscopy = $arg3
  probestr = sprintf("%s(env=0x%x,array=0x%x,iscopy=0x%x)", name, env, array, iscopy)
}

/* hotspot.jni.GetIntArrayElements.return
 * Returns jint array elements. Return.
 *
 * ret - Pointer to jint array.
 */
probe hotspot.jni.GetIntArrayElements.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetIntArrayElements__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetIntArrayElements__return")
{
  name = "GetIntArrayElements"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.GetIntArrayRegion
 * Copies a region out of a jint array elements.
 *
 * env - JNIEnv pointer.
 * array - jintArray to copy from.
 * start - Starting index.
 * len - Number of elements to copy.
 * buf - Native jint array pointer to copy into.
 */
probe hotspot.jni.GetIntArrayRegion =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetIntArrayRegion__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetIntArrayRegion__entry")
{
  name = "GetIntArrayRegion"
  env = $arg1
  array = $arg2
  start = $arg3
  len = $arg4
  buf = $arg5
  probestr = sprintf("%s(env=0x%x,array=0x%x,start=%d,len=%d,buf=0x%x)", name, env, array, start, len, buf)
}

/* hotspot.jni.GetIntArrayRegion.return
 * Copies a region out of a jint array elements. Return.
 */
probe hotspot.jni.GetIntArrayRegion.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetIntArrayRegion__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetIntArrayRegion__return")
{
  name = "GetIntArrayRegion"
  retstr = ""
}

/* hotspot.jni.GetIntField
 * Get non-static jint field value.
 * NEEDS: -XX:-UseFastJNIAccessors
 *
 * env - JNIEnv pointer.
 * obj - jobject.
 * field - jfieldID.
 */
probe hotspot.jni.GetIntField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetIntField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetIntField__entry")
{
  name = "GetIntField"
  env = $arg1
  obj = $arg2
  field = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,field=0x%x)", name, env, obj, field)
}

/* hotspot.jni.GetIntField.return
 * Get non-static jint field value. Return.
 * NEEDS: -XX:-UseFastJNIAccessors
 *
 * ret - jint value.
 */
probe hotspot.jni.GetIntField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetIntField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetIntField__return")
{
  name = "GetIntField"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.GetJavaVM
 * Get the JavaVM struct associated with the current JNIEnv.
 *
 * env - JNIEnv pointer.
 * pvm - Pointer to JavaVM pointer.
 */
probe hotspot.jni.GetJavaVM =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetJavaVM__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetJavaVM__entry")
{
  name = "GetJavaVM"
  env = $arg1
  pvm = $arg2
  probestr = sprintf("%s(env=0x%x,pvm=0x%x)", name, env, pvm)
}

/* hotspot.jni.GetJavaVM.return
 * Get the JavaVM struct associated with the current JNIEnv. Return.
 *
 * ret - Zero on success, negative on failure.
 */
probe hotspot.jni.GetJavaVM.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetJavaVM__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetJavaVM__return")
{
  name = "GetJavaVM"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.GetLongArrayElements
 * Returns jlong array elements.
 *
 * env - JNIEnv pointer.
 * array - jlongArray.
 * iscopy - Pointer to jboolean.
 */
probe hotspot.jni.GetLongArrayElements =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetLongArrayElements__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetLongArrayElements__entry")
{
  name = "GetLongArrayElements"
  env = $arg1
  array = $arg2
  iscopy = $arg3
  probestr = sprintf("%s(env=0x%x,array=0x%x,iscopy=0x%x)", name, env, array, iscopy)
}

/* hotspot.jni.GetLongArrayElements.return
 * Returns jlong array elements. Return.
 *
 * ret - Pointer to jlong array.
 */
probe hotspot.jni.GetLongArrayElements.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetLongArrayElements__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetLongArrayElements__return")
{
  name = "GetLongArrayElements"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.GetLongArrayRegion
 * Copies a region out of a jlong array elements.
 *
 * env - JNIEnv pointer.
 * array - jlongArray to copy from.
 * start - Starting index.
 * len - Number of elements to copy.
 * buf - Native jlong array pointer to copy into.
 */
probe hotspot.jni.GetLongArrayRegion =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetLongArrayRegion__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetLongArrayRegion__entry")
{
  name = "GetLongArrayRegion"
  env = $arg1
  array = $arg2
  start = $arg3
  len = $arg4
  buf = $arg5
  probestr = sprintf("%s(env=0x%x,array=0x%x,start=%d,len=%d,buf=0x%x)", name, env, array, start, len, buf)
}

/* hotspot.jni.GetLongArrayRegion.return
 * Copies a region out of a jlong array elements. Return.
 */
probe hotspot.jni.GetLongArrayRegion.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetLongArrayRegion__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetLongArrayRegion__return")
{
  name = "GetLongArrayRegion"
  retstr = ""
}

/* hotspot.jni.GetLongField
 * Get non-static jlong field value.
 * NEEDS: -XX:-UseFastJNIAccessors
 *
 * env - JNIEnv pointer.
 * obj - jobject.
 * field - jfieldID.
 */
probe hotspot.jni.GetLongField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetLongField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetLongField__entry")
{
  name = "GetLongField"
  env = $arg1
  obj = $arg2
  field = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,field=0x%x)", name, env, obj, field)
}

/* hotspot.jni.GetLongField.return
 * Get non-static jlong field value. Return.
 * NEEDS: -XX:-UseFastJNIAccessors
 *
 * ret - jlong value.
 */
probe hotspot.jni.GetLongField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetLongField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetLongField__return")
{
  name = "GetLongField"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.GetMethodID
 * Returns jmethodID of requested method.
 *
 * env - JINEnv pointer.
 * clazz - jclass pointer.
 * method - Name of the method.
 * sig - Signature of the method.
 */
probe hotspot.jni.GetMethodID =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetMethodID__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetMethodID__entry")
{
  name = "GetMethodID"
  env = $arg1
  clazz = $arg2
  method = user_string($arg3)
  sig = user_string($arg4)
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,method='%s',sig='%s')", name, env, clazz, method, sig)
}

/* hotspot.jni.GetMethodID.return
 * Returns jmethodID of requested method. Return.
 *
 * ret - jmethodID of the requested method or NULL on failure.
 */
probe hotspot.jni.GetMethodID.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetMethodID__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetMethodID__return")
{
  name = "GetMethodID"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.GetObjectArrayElement
 * Get Object element from array.
 *
 * env - JNIEnv pointer.
 * array - jobjectArray.
 * index - Element index.
 */
probe hotspot.jni.GetObjectArrayElement =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetObjectArrayElement__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetObjectArrayElement__entry")
{
  name = "GetObjectArrayElement"
  env = $arg1
  array = $arg2
  index = $arg3
  probestr = sprintf("%s(env=0x%x,array=0x%x,index=%d)", name, env, array, index)
}

/* hotspot.jni.GetObjectArrayElement.return
 * Get Object element from array. Return.
 *
 * ret - jobject or NULL on failure.
 */
probe hotspot.jni.GetObjectArrayElement.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetObjectArrayElement__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetObjectArrayElement__return")
{
  name = "GetObjectArrayElement"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.GetObjectClass
 * Returns the class of a given object.
 *
 * env - JNIEnv pointer.
 * obj - jobject pointer.
 */
probe hotspot.jni.GetObjectClass =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetObjectClass__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetObjectClass__entry")
{
  name = "GetObjectClass"
  env = $arg1
  obj = $arg2
  probestr = sprintf("%s(env=0x%x,obj=0x%x)", name, env, obj)
}

/* hotspot.jni.GetObjectClass.return
 * Returns the class of a given object. Return.
 *
 * ret - jclass of the given jobject.
 */
probe hotspot.jni.GetObjectClass.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetObjectClass__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetObjectClass__return")
{
  name = "GetObjectClass"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.GetObjectField
 * Get non-static jobject field value.
 *
 * env - JNIEnv pointer.
 * obj - jobject.
 * field - jfieldID.
 */
probe hotspot.jni.GetObjectField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetObjectField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetObjectField__entry")
{
  name = "GetObjectField"
  env = $arg1
  obj = $arg2
  field = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,field=0x%x)", name, env, obj, field)
}

/* hotspot.jni.GetObjectField.return
 * Get non-static jobject field value. Return.
 *
 * ret - jobject value.
 */
probe hotspot.jni.GetObjectField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetObjectField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetObjectField__return")
{
  name = "GetObjectField"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.GetObjectRefType
 * Whether a jobject is a local, global or weak reference.
 *
 * env - JNIEnv pointer.
 * obj - jobject.
 */
probe hotspot.jni.GetObjectRefType =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetObjectRefType__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetObjectRefType__entry")
{
  name = "GetObjectRefType"
  env = $arg1
  obj = $arg2
  probestr = sprintf("%s(env=0x%x,obj=0x%x)", name, env, obj)
}

/* hotspot.jni.GetObjectRefType.return
 * Whether a jobject is a local, global or weak reference. Return.
 *
 * ret - 0 for invalid, 1 for local, 2 for global or 3 for weak references.
 */
probe hotspot.jni.GetObjectRefType.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetObjectRefType__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetObjectRefType__return")
{
  name = "GetObjectRefType"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.GetPrimitiveArrayCritical
 * Get pointer to primitive array elements.
 *
 * env - JNIEnv pointer.
 * array - jarray.
 * iscopy - Pointer to jboolean.
 */
probe hotspot.jni.GetPrimitiveArrayCritical =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetPrimitiveArrayCritical__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetPrimitiveArrayCritical__entry")
{
  name = "GetPrimitiveArrayCritical"
  env = $arg1
  array = $arg2
  iscopy = $arg3
  probestr = sprintf("%s(env=0x%x,array=0x%x,iscopy=0x%x)", name, env, array, iscopy)
}

/* hotspot.jni.GetPrimitiveArrayCritical.return
 * Get pointer to primitive array elements. Return.
 *
 * ret - Address of jarray elements or NULL on error.
 */
probe hotspot.jni.GetPrimitiveArrayCritical.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetPrimitiveArrayCritical__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetPrimitiveArrayCritical__return")
{
  name = "GetPrimitiveArrayCritical"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.GetShortArrayElements
 * Returns jshort array elements.
 *
 * env - JNIEnv pointer.
 * array - jshortArray.
 * iscopy - Pointer to jboolean.
 */
probe hotspot.jni.GetShortArrayElements =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetShortArrayElements__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetShortArrayElements__entry")
{
  name = "GetShortArrayElements"
  env = $arg1
  array = $arg2
  iscopy = $arg3
  probestr = sprintf("%s(env=0x%x,array=0x%x,iscopy=0x%x)", name, env, array, iscopy)
}

/* hotspot.jni.GetShortArrayElements.return
 * Returns jshort array elements. Return.
 *
 * ret - Pointer to jshort array.
 */
probe hotspot.jni.GetShortArrayElements.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetShortArrayElements__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetShortArrayElements__return")
{
  name = "GetShortArrayElements"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.GetShortArrayRegion
 * Copies a region out of a jshort array elements.
 *
 * env - JNIEnv pointer.
 * array - jshortArray to copy from.
 * start - Starting index.
 * len - Number of elements to copy.
 * buf - Native jshort array pointer to copy into.
 */
probe hotspot.jni.GetShortArrayRegion =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetShortArrayRegion__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetShortArrayRegion__entry")
{
  name = "GetShortArrayRegion"
  env = $arg1
  array = $arg2
  start = $arg3
  len = $arg4
  buf = $arg5
  probestr = sprintf("%s(env=0x%x,array=0x%x,start=%d,len=%d,buf=0x%x)", name, env, array, start, len, buf)
}

/* hotspot.jni.GetShortArrayRegion.return
 * Copies a region out of a jshort array elements. Return.
 */
probe hotspot.jni.GetShortArrayRegion.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetShortArrayRegion__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetShortArrayRegion__return")
{
  name = "GetShortArrayRegion"
  retstr = ""
}

/* hotspot.jni.GetShortField
 * Get non-static jshort field value.
 * NEEDS: -XX:-UseFastJNIAccessors
 *
 * env - JNIEnv pointer.
 * obj - jobject.
 * field - jfieldID.
 */
probe hotspot.jni.GetShortField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetShortField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetShortField__entry")
{
  name = "GetShortField"
  env = $arg1
  obj = $arg2
  field = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,field=0x%x)", name, env, obj, field)
}

/* hotspot.jni.GetShortField.return
 * Get non-static jshort field value. Return.
 * NEEDS: -XX:-UseFastJNIAccessors
 *
 * ret - jshort value.
 */
probe hotspot.jni.GetShortField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetShortField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetShortField__return")
{
  name = "GetShortField"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.GetStaticBooleanField
 * Get static jboolean field value.
 *
 * env - JNIEnv pointer.
 * clazz - jclass.
 * field - jfieldID.
 */
probe hotspot.jni.GetStaticBooleanField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStaticBooleanField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStaticBooleanField__entry")
{
  name = "GetStaticBooleanField"
  env = $arg1
  clazz = $arg2
  field = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,field=0x%x)", name, env, clazz, field)
}

/* hotspot.jni.GetStaticBooleanField.return
 * Get static jboolean field value. Return.
 *
 * ret - jboolean value.
 */
probe hotspot.jni.GetStaticBooleanField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStaticBooleanField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStaticBooleanField__return")
{
  name = "GetStaticBooleanField"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.GetStaticByteField
 * Get static jbyte field value.
 *
 * env - JNIEnv pointer.
 * clazz - jclass.
 * field - jfieldID.
 */
probe hotspot.jni.GetStaticByteField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStaticByteField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStaticByteField__entry")
{
  name = "GetStaticByteField"
  env = $arg1
  clazz = $arg2
  field = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,field=0x%x)", name, env, clazz, field)
}

/* hotspot.jni.GetStaticByteField.return
 * Get static jbyte field value. Return.
 *
 * ret - jbyte value.
 */
probe hotspot.jni.GetStaticByteField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStaticByteField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStaticByteField__return")
{
  name = "GetStaticByteField"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.GetStaticCharField
 * Get static jchar field value.
 *
 * env - JNIEnv pointer.
 * clazz - jclass.
 * field - jfieldID.
 */
probe hotspot.jni.GetStaticCharField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStaticCharField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStaticCharField__entry")
{
  name = "GetStaticCharField"
  env = $arg1
  clazz = $arg2
  field = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,field=0x%x)", name, env, clazz, field)
}

/* hotspot.jni.GetStaticCharField.return
 * Get static jchar field value. Return.
 *
 * ret - jchar value.
 */
probe hotspot.jni.GetStaticCharField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStaticCharField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStaticCharField__return")
{
  name = "GetStaticCharField"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.GetStaticDoubleField
 * Get static jdouble field value.
 *
 * env - JNIEnv pointer.
 * clazz - jclass.
 * field - jfieldID.
 */
probe hotspot.jni.GetStaticDoubleField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStaticDoubleField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStaticDoubleField__entry")
{
  name = "GetStaticDoubleField"
  env = $arg1
  clazz = $arg2
  field = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,field=0x%x)", name, env, clazz, field)
}

/* hotspot.jni.GetStaticDoubleField.return
 * Get static jdouble field value. Return.
 */
probe hotspot.jni.GetStaticDoubleField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStaticDoubleField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStaticDoubleField__return")
{
  name = "GetStaticDoubleField"
  retstr = ""
}

/* hotspot.jni.GetStaticFieldID
 * Get jfieldID of a static field of a jclass.
 *
 * env - JNIEnv pointer.
 * clazz - jclass object.
 * field - UTF-8 field name.
 * sig - UTF-8 signature of the field.
 */
probe hotspot.jni.GetStaticFieldID =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStaticFieldID__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStaticFieldID__entry")
{
  name = "GetStaticFieldID"
  env = $arg1
  clazz = $arg2
  field = user_string($arg3)
  sig = user_string($arg4)
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,field='%s',sig='%s')", name, env, clazz, field, sig)
}

/* hotspot.jni.GetStaticFieldID.return
 * Get jfieldID of a static field of a jclass. Return.
 *
 * ret - jfieldID or NULL on failure.
 */
probe hotspot.jni.GetStaticFieldID.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStaticFieldID__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStaticFieldID__return")
{
  name = "GetStaticFieldID"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.GetStaticFloatField
 * Get static jfloat field value.
 *
 * env - JNIEnv pointer.
 * clazz - jclass.
 * field - jfieldID.
 */
probe hotspot.jni.GetStaticFloatField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStaticFloatField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStaticFloatField__entry")
{
  name = "GetStaticFloatField"
  env = $arg1
  clazz = $arg2
  field = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,field=0x%x)", name, env, clazz, field)
}

/* hotspot.jni.GetStaticFloatField.return
 * Get static jfloat field value. Return.
 */
probe hotspot.jni.GetStaticFloatField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStaticFloatField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStaticFloatField__return")
{
  name = "GetStaticFloatField"
  retstr = ""
}

/* hotspot.jni.GetStaticIntField
 * Get static jint field value.
 *
 * env - JNIEnv pointer.
 * clazz - jclass.
 * field - jfieldID.
 */
probe hotspot.jni.GetStaticIntField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStaticIntField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStaticIntField__entry")
{
  name = "GetStaticIntField"
  env = $arg1
  clazz = $arg2
  field = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,field=0x%x)", name, env, clazz, field)
}

/* hotspot.jni.GetStaticIntField.return
 * Get static jint field value. Return.
 *
 * ret - jint value.
 */
probe hotspot.jni.GetStaticIntField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStaticIntField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStaticIntField__return")
{
  name = "GetStaticIntField"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.GetStaticLongField
 * Get static jlong field value.
 *
 * env - JNIEnv pointer.
 * clazz - jclass.
 * field - jfieldID.
 */
probe hotspot.jni.GetStaticLongField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStaticLongField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStaticLongField__entry")
{
  name = "GetStaticLongField"
  env = $arg1
  clazz = $arg2
  field = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,field=0x%x)", name, env, clazz, field)
}

/* hotspot.jni.GetStaticLongField.return
 * Get static jlong field value. Return.
 *
 * ret - jlong value.
 */
probe hotspot.jni.GetStaticLongField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStaticLongField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStaticLongField__return")
{
  name = "GetStaticLongField"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.GetStaticMethodID
 * Returns jmethodID of requested static method.
 *
 * env - JINEnv pointer.
 * clazz - jclass pointer.
 * method - Name of the method.
 * sig - Signature of the method.
 */
probe hotspot.jni.GetStaticMethodID =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStaticMethodID__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStaticMethodID__entry")
{
  name = "GetStaticMethodID"
  env = $arg1
  clazz = $arg2
  method = user_string($arg3)
  sig = user_string($arg4)
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,method='%s',sig='%s')", name, env, clazz, method, sig)
}

/* hotspot.jni.GetStaticMethodID.return
 * Returns jmethodID of requested static method. Return.
 *
 * ret - jmethodID of the requested method or NULL on failure.
 */
probe hotspot.jni.GetStaticMethodID.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStaticMethodID__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStaticMethodID__return")
{
  name = "GetStaticMethodID"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.GetStaticObjectField
 * Get static jobject field value.
 *
 * env - JNIEnv pointer.
 * clazz - jclass.
 * field - jfieldID.
 */
probe hotspot.jni.GetStaticObjectField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStaticObjectField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStaticObjectField__entry")
{
  name = "GetStaticObjectField"
  env = $arg1
  clazz = $arg2
  field = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,field=0x%x)", name, env, clazz, field)
}

/* hotspot.jni.GetStaticObjectField.return
 * Get static jobject field value. Return.
 *
 * ret - jobject value.
 */
probe hotspot.jni.GetStaticObjectField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStaticObjectField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStaticObjectField__return")
{
  name = "GetStaticObjectField"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.GetStaticShortField
 * Get static jshort field value.
 *
 * env - JNIEnv pointer.
 * clazz - jclass.
 * field - jfieldID.
 */
probe hotspot.jni.GetStaticShortField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStaticShortField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStaticShortField__entry")
{
  name = "GetStaticShortField"
  env = $arg1
  clazz = $arg2
  field = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,field=0x%x)", name, env, clazz, field)
}

/* hotspot.jni.GetStaticShortField.return
 * Get static jshort field value. Return.
 *
 * ret - jshort value.
 */
probe hotspot.jni.GetStaticShortField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStaticShortField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStaticShortField__return")
{
  name = "GetStaticShortField"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.GetStringChars
 * Get unicode jchar array of jstring.
 *
 * env - JNIEnv pointer.
 * str - jstring.
 * iscopy - Pointer to jboolean.
 */
probe hotspot.jni.GetStringChars =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStringChars__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStringChars__entry")
{
  name = "GetStringChars"
  env = $arg1
  str = $arg2
  iscopy = $arg3
  probestr = sprintf("%s(env=0x%x,str=0x%x,iscopy=0x%x)", name, env, str, iscopy)
}

/* hotspot.jni.GetStringChars.return
 * Get unicode jchar array of jstring. Return.
 *
 * ret - Pointer to jchar array.
 */
probe hotspot.jni.GetStringChars.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStringChars__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStringChars__return")
{
  name = "GetStringChars"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.GetStringCritical
 * Get critical unicode jchar array of jstring.
 *
 * env - JNIEnv pointer.
 * str - jstring.
 * iscopy - Pointer to jboolean.
 */
probe hotspot.jni.GetStringCritical =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStringCritical__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStringCritical__entry")
{
  name = "GetStringCritical"
  env = $arg1
  str = $arg2
  iscopy = $arg3
  probestr = sprintf("%s(env=0x%x,str=0x%x,iscopy=0x%x)", name, env, str, iscopy)
}

/* hotspot.jni.GetStringCritical.return
 * Get critical unicode jchar array of jstring. Return.
 *
 * ret - Pointer to jchar array.
 */
probe hotspot.jni.GetStringCritical.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStringCritical__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStringCritical__return")
{
  name = "GetStringCritical"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.GetStringLength
 * Returns number of unicode jchars in jstring.
 *
 * env - JNIEnv pointer.
 * str - jstring.
 */
probe hotspot.jni.GetStringLength =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStringLength__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStringLength__entry")
{
  name = "GetStringLength"
  env = $arg1
  str = $arg2
  probestr = sprintf("%s(env=0x%x,str=0x%x)", name, env, str)
}

/* hotspot.jni.GetStringLength.return
 * Returns number of unicode jchars in jstring. Return.
 *
 * ret - Length of string.
 */
probe hotspot.jni.GetStringLength.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStringLength__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStringLength__return")
{
  name = "GetStringLength"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.GetStringRegion
 * Retrieves jchar unicode characters from jstring.
 *
 * env - JNIEnv pointer.
 * str - jstring.
 * start - Starting character to copy.
 * len - Number of jchars to copy.
 * buf - Pointer to jchar buffer to copy unicode characters in.
 */
probe hotspot.jni.GetStringRegion =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStringRegion__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStringRegion__entry")
{
  name = "GetStringRegion"
  env = $arg1
  str = $arg2
  start = $arg3
  len = $arg4
  buf = $arg5
  probestr = sprintf("%s(env=0x%x,str=0x%x,start=%d,len=%d,buf=0x%x)", name, env, str, start, len, buf)
}

/* hotspot.jni.GetStringRegion.return
 * Retrieves jchar unicode characters from jstring. Return.
 */
probe hotspot.jni.GetStringRegion.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStringRegion__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStringRegion__return")
{
  name = "GetStringRegion"
  retstr = ""
}

/* hotspot.jni.GetStringUTFChars
 * Retrieves UTF-8 encoded chars from jstring.
 *
 * env - JNIEnv pointer.
 * str - jstring pointer.
 * iscopy - pointer to a jboolean.
 */
probe hotspot.jni.GetStringUTFChars =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStringUTFChars__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStringUTFChars__entry")
{
  name = "GetStringUTFChars"
  env = $arg1
  str = $arg2
  iscopy = $arg3
  probestr = sprintf("%s(env=0x%x,str=0x%x,iscopy=0x%x)", name, env, str, iscopy)
}

/* hotspot.jni.GetStringUTFChars.return
 * Retrieves UTF-8 encoded chars from jstring. Return.
 *
 * ret - Pointer to a UTF-8 string or NULL when called failed.
 */
probe hotspot.jni.GetStringUTFChars.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStringUTFChars__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStringUTFChars__return")
{
  name = "GetStringUTFChars"
  ret = user_string($arg1)
  retstr = ret
}

/* hotspot.jni.GetStringUTFLength
 * Returns length of jstring in UTF-8 encoded chars.
 *
 * env - JNIEnv pointer.
 * str - jstring pointer.
 */
probe hotspot.jni.GetStringUTFLength =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStringUTFLength__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStringUTFLength__entry")
{
  name = "GetStringUTFLength"
  env = $arg1
  str = $arg2
  probestr = sprintf("%s(env=0x%x,str=0x%x)", name, env, str)
}

/* hotspot.jni.GetStringUTFLength.return
 * Returns length of jstring in UTF-8 encoded chars. Return.
 *
 * ret - Number of UTF-8 chars in jstring.
 */
probe hotspot.jni.GetStringUTFLength.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStringUTFLength__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStringUTFLength__return")
{
  name = "GetStringUTFLength"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.GetStringUTFRegion
 * 
 *
 * env - JNIEnv pointer.
 * str - jstring.
 * start - jchar offset to start at.
 * len - Number of jchars to get from jstring.
 * buf - Native char array to put UTF-8 encoded strings in.
 */
probe hotspot.jni.GetStringUTFRegion =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStringUTFRegion__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStringUTFRegion__entry")
{
  name = "GetStringUTFRegion"
  env = $arg1
  str = $arg2
  start = $arg3
  len = $arg4
  buf = $arg5
  probestr = sprintf("%s(env=0x%x,str=0x%x,start=%d,len=%d,buf=0x%x)", name, env, str, start, len, buf)
}

/* hotspot.jni.GetStringUTFRegion.return
 *  Return.
 */
probe hotspot.jni.GetStringUTFRegion.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetStringUTFRegion__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetStringUTFRegion__return")
{
  name = "GetStringUTFRegion"
  retstr = ""
}

/* hotspot.jni.GetSuperclass
 * Returns super class of given jclass.
 *
 * env - JNIEnv pointer.
 * clazz - jclass.
 */
probe hotspot.jni.GetSuperclass =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetSuperclass__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetSuperclass__entry")
{
  name = "GetSuperclass"
  env = $arg1
  clazz = $arg2
  probestr = sprintf("%s(env=0x%x,clazz=0x%x)", name, env, clazz)
}

/* hotspot.jni.GetSuperclass.return
 * Returns super class of given jclass. Return.
 *
 * ret - Super jclass or NULL if the given jclass is Object or an interface.
 */
probe hotspot.jni.GetSuperclass.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetSuperclass__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetSuperclass__return")
{
  name = "GetSuperclass"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.GetVersion
 * Returns JNI version.
 *
 * env - JNIEnv pointer.
 */
probe hotspot.jni.GetVersion =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetVersion__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetVersion__entry")
{
  name = "GetVersion"
  env = $arg1
  probestr = sprintf("%s(env=0x%x)", name, env)
}

/* hotspot.jni.GetVersion.return
 * Returns JNI version. Return.
 *
 * ret - JNI version.
 */
probe hotspot.jni.GetVersion.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("GetVersion__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("GetVersion__return")
{
  name = "GetVersion"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.IsAssignableFrom
 * Whether a given jclass can be cast to another jclass.
 *
 * env - JNIEnv pointer.
 * clazz1 - jclass to cast from.
 * clazz2 - jclass to cast to.
 */
probe hotspot.jni.IsAssignableFrom =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("IsAssignableFrom__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("IsAssignableFrom__entry")
{
  name = "IsAssignableFrom"
  env = $arg1
  clazz1 = $arg2
  clazz2 = $arg3
  probestr = sprintf("%s(env=0x%x,clazz1=0x%x,clazz2=0x%x)", name, env, clazz1, clazz2)
}

/* hotspot.jni.IsAssignableFrom.return
 * Whether a given jclass can be cast to another jclass. Return.
 *
 * ret - One if clazz1 can be cast to clazz2, zero otherwise.
 */
probe hotspot.jni.IsAssignableFrom.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("IsAssignableFrom__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("IsAssignableFrom__return")
{
  name = "IsAssignableFrom"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.IsInstanceOf
 * Whether a given jobject is an instance of a jclass.
 *
 * env - JNIEnv pointer.
 * obj - jobject.
 * clazz - jclass.
 */
probe hotspot.jni.IsInstanceOf =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("IsInstanceOf__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("IsInstanceOf__entry")
{
  name = "IsInstanceOf"
  env = $arg1
  obj = $arg2
  clazz = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,clazz=0x%x)", name, env, obj, clazz)
}

/* hotspot.jni.IsInstanceOf.return
 * Whether a given jobject is an instance of a jclass. Return.
 *
 * ret - One if obj can be cast to clazz, zero otherwise.
 */
probe hotspot.jni.IsInstanceOf.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("IsInstanceOf__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("IsInstanceOf__return")
{
  name = "IsInstanceOf"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.IsSameObject
 * Whether two jobjects identify the same java object.
 *
 * env - JNIEnv pointer.
 * obj1 - jobject.
 * obj2 - jobject.
 */
probe hotspot.jni.IsSameObject =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("IsSameObject__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("IsSameObject__entry")
{
  name = "IsSameObject"
  env = $arg1
  obj1 = $arg2
  obj2 = $arg3
  probestr = sprintf("%s(env=0x%x,obj1=0x%x,obj2=0x%x)", name, env, obj1, obj2)
}

/* hotspot.jni.IsSameObject.return
 * Whether two jobjects identify the same java object. Return.
 *
 * ret - One if obj1 and obj2 are references to the same java object.
 */
probe hotspot.jni.IsSameObject.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("IsSameObject__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("IsSameObject__return")
{
  name = "IsSameObject"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.MonitorEnter
 * Enter monitor for given jobject.
 *
 * env - JNIEnv pointer.
 * obj - jobject.
 */
probe hotspot.jni.MonitorEnter =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("MonitorEnter__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("MonitorEnter__entry")
{
  name = "MonitorEnter"
  env = $arg1
  obj = $arg2
  probestr = sprintf("%s(env=0x%x,obj=0x%x)", name, env, obj)
}

/* hotspot.jni.MonitorEnter.return
 * Enter monitor for given jobject. Return.
 *
 * ret - Zero on success, negative on failure.
 */
probe hotspot.jni.MonitorEnter.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("MonitorEnter__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("MonitorEnter__return")
{
  name = "MonitorEnter"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.MonitorExit
 * Exit monitor for given jobject.
 *
 * env - JNIEnv pointer.
 * obj - jobject.
 */
probe hotspot.jni.MonitorExit =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("MonitorExit__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("MonitorExit__entry")
{
  name = "MonitorExit"
  env = $arg1
  obj = $arg2
  probestr = sprintf("%s(env=0x%x,obj=0x%x)", name, env, obj)
}

/* hotspot.jni.MonitorExit.return
 * Exit monitor for given jobject. Return.
 *
 * ret - Zero on success, negative on failure.
 */
probe hotspot.jni.MonitorExit.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("MonitorExit__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("MonitorExit__return")
{
  name = "MonitorExit"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.NewBooleanArray
 * Create new boolean array.
 *
 * env - JNIEnv pointer.
 * length - size of the array.
 */
probe hotspot.jni.NewBooleanArray =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewBooleanArray__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewBooleanArray__entry")
{
  name = "NewBooleanArray"
  env = $arg1
  length = $arg2
  probestr = sprintf("%s(env=0x%x,length=%d)", name, env, length)
}

/* hotspot.jni.NewBooleanArray.return
 * Create new boolean array. Return.
 *
 * ret - jbooleanArray or NULL on failure.
 */
probe hotspot.jni.NewBooleanArray.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewBooleanArray__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewBooleanArray__return")
{
  name = "NewBooleanArray"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.NewByteArray
 * Create new byte array.
 *
 * env - JNIEnv pointer.
 * length - size of the array.
 */
probe hotspot.jni.NewByteArray =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewByteArray__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewByteArray__entry")
{
  name = "NewByteArray"
  env = $arg1
  length = $arg2
  probestr = sprintf("%s(env=0x%x,length=%d)", name, env, length)
}

/* hotspot.jni.NewByteArray.return
 * Create new byte array. Return.
 *
 * ret - jbyteArray or NULL on failure.
 */
probe hotspot.jni.NewByteArray.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewByteArray__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewByteArray__return")
{
  name = "NewByteArray"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.NewCharArray
 * Create new char array.
 *
 * env - JNIEnv pointer.
 * length - size of the array.
 */
probe hotspot.jni.NewCharArray =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewCharArray__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewCharArray__entry")
{
  name = "NewCharArray"
  env = $arg1
  length = $arg2
  probestr = sprintf("%s(env=0x%x,length=%d)", name, env, length)
}

/* hotspot.jni.NewCharArray.return
 * Create new char array. Return.
 *
 * ret - jcharArray or NULL on failure.
 */
probe hotspot.jni.NewCharArray.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewCharArray__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewCharArray__return")
{
  name = "NewCharArray"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.NewDirectByteBuffer
 * Create DirectByteBuffer for given address and size.
 *
 * env - JNIEnv pointer.
 * addr - Address to start.
 * size - Capacity of the buffer.
 */
probe hotspot.jni.NewDirectByteBuffer =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewDirectByteBuffer__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewDirectByteBuffer__entry")
{
  name = "NewDirectByteBuffer"
  env = $arg1
  addr = $arg2
  size = $arg3
  probestr = sprintf("%s(env=0x%x,addr=0x%x,size=%d)", name, env, addr, size)
}

/* hotspot.jni.NewDirectByteBuffer.return
 * Create DirectByteBuffer for given address and size. Return.
 *
 * ret - DirectByteBuffer jobject or NULL on failure.
 */
probe hotspot.jni.NewDirectByteBuffer.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewDirectByteBuffer__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewDirectByteBuffer__return")
{
  name = "NewDirectByteBuffer"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.NewDoubleArray
 * Create new double array.
 *
 * env - JNIEnv pointer.
 * length - size of the array.
 */
probe hotspot.jni.NewDoubleArray =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewDoubleArray__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewDoubleArray__entry")
{
  name = "NewDoubleArray"
  env = $arg1
  length = $arg2
  probestr = sprintf("%s(env=0x%x,length=%d)", name, env, length)
}

/* hotspot.jni.NewDoubleArray.return
 * Create new double array. Return.
 *
 * ret - jdoubleArray or NULL on failure.
 */
probe hotspot.jni.NewDoubleArray.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewDoubleArray__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewDoubleArray__return")
{
  name = "NewDoubleArray"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.NewFloatArray
 * Create new floar array.
 *
 * env - JNIEnv pointer.
 * length - size of the array.
 */
probe hotspot.jni.NewFloatArray =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewFloatArray__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewFloatArray__entry")
{
  name = "NewFloatArray"
  env = $arg1
  length = $arg2
  probestr = sprintf("%s(env=0x%x,length=%d)", name, env, length)
}

/* hotspot.jni.NewFloatArray.return
 * Create new floar array. Return.
 *
 * ret - jfloatArray or NULL on failure.
 */
probe hotspot.jni.NewFloatArray.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewFloatArray__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewFloatArray__return")
{
  name = "NewFloatArray"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.NewGlobalRef
 * Create a new global reference for a jobject.
 *
 * env - JNIEnv pointer.
 * obj - jobject to create a global reference for.
 */
probe hotspot.jni.NewGlobalRef =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewGlobalRef__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewGlobalRef__entry")
{
  name = "NewGlobalRef"
  env = $arg1
  obj = $arg2
  probestr = sprintf("%s(env=0x%x,obj=0x%x)", name, env, obj)
}

/* hotspot.jni.NewGlobalRef.return
 * Create a new global reference for a jobject. Return.
 *
 * ret - Global jobject reference, or NULL on failure.
 */
probe hotspot.jni.NewGlobalRef.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewGlobalRef__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewGlobalRef__return")
{
  name = "NewGlobalRef"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.NewIntArray
 * Create new int array.
 *
 * env - JNIEnv pointer.
 * length - size of the array.
 */
probe hotspot.jni.NewIntArray =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewIntArray__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewIntArray__entry")
{
  name = "NewIntArray"
  env = $arg1
  length = $arg2
  probestr = sprintf("%s(env=0x%x,length=%d)", name, env, length)
}

/* hotspot.jni.NewIntArray.return
 * Create new int array. Return.
 *
 * ret - jintArray or NULL on failure.
 */
probe hotspot.jni.NewIntArray.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewIntArray__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewIntArray__return")
{
  name = "NewIntArray"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.NewLocalRef
 * Create a new local reference for a jobject.
 *
 * env - JNIEnv pointer.
 * obj - jobject to create a local reference for.
 */
probe hotspot.jni.NewLocalRef =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewLocalRef__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewLocalRef__entry")
{
  name = "NewLocalRef"
  env = $arg1
  obj = $arg2
  probestr = sprintf("%s(env=0x%x,obj=0x%x)", name, env, obj)
}

/* hotspot.jni.NewLocalRef.return
 * Create a new local reference for a jobject. Return.
 *
 * ret - Global jobject reference, or NULL on failure.
 */
probe hotspot.jni.NewLocalRef.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewLocalRef__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewLocalRef__return")
{
  name = "NewLocalRef"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.NewLongArray
 * Create new long array.
 *
 * env - JNIEnv pointer.
 * length - size of the array.
 */
probe hotspot.jni.NewLongArray =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewLongArray__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewLongArray__entry")
{
  name = "NewLongArray"
  env = $arg1
  length = $arg2
  probestr = sprintf("%s(env=0x%x,length=%d)", name, env, length)
}

/* hotspot.jni.NewLongArray.return
 * Create new long array. Return.
 *
 * ret - jlongArray or NULL on failure.
 */
probe hotspot.jni.NewLongArray.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewLongArray__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewLongArray__return")
{
  name = "NewLongArray"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.NewObjectA
 * Create a new object from jclass from arguments in array.
 *
 * env - JNIEnv pointer.
 * clazz - jclass.
 * methodid - jmethodID of constructor to call.
 */
probe hotspot.jni.NewObjectA =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewObjectA__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewObjectA__entry")
{
  name = "NewObjectA"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.NewObjectA.return
 * Create a new object from jclass from arguments in array. Return.
 *
 * ret - jobject or NULL on failure.
 */
probe hotspot.jni.NewObjectA.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewObjectA__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewObjectA__return")
{
  name = "NewObjectA"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.NewObjectArray
 * Create new jobject array of given element type.
 *
 * env - JNIEnv pointer.
 * length - size of the array.
 * element - jclass of the elements in the array.
 * initial - jobject initial value.
 */
probe hotspot.jni.NewObjectArray =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewObjectArray__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewObjectArray__entry")
{
  name = "NewObjectArray"
  env = $arg1
  length = $arg2
  element = $arg3
  initial = $arg4
  probestr = sprintf("%s(env=0x%x,length=%d,element=0x%x,initial=0x%x)", name, env, length, element, initial)
}

/* hotspot.jni.NewObjectArray.return
 * Create new jobject array of given element type. Return.
 *
 * ret - jarray or NULL on failure.
 */
probe hotspot.jni.NewObjectArray.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewObjectArray__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewObjectArray__return")
{
  name = "NewObjectArray"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.NewObject
 * Create a new object from jclass using the jmethodID constructor.
 *
 * env - JNIEnv pointer.
 * clazz - jclass.
 * methodid - jmethodID of constructor to call.
 */
probe hotspot.jni.NewObject =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewObject__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewObject__entry")
{
  name = "NewObject"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.NewObject.return
 * Create a new object from jclass using the jmethodID constructor. Return.
 *
 * ret - jobject or NULL on failure.
 */
probe hotspot.jni.NewObject.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewObject__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewObject__return")
{
  name = "NewObject"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.NewObjectV
 * Create a new object from jclass from va_list arguments.
 *
 * env - JNIEnv pointer.
 * clazz - jclass.
 * methodid - jmethodID of constructor to call.
 */
probe hotspot.jni.NewObjectV =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewObjectV__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewObjectV__entry")
{
  name = "NewObjectV"
  env = $arg1
  clazz = $arg2
  methodid = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methodid=0x%x)", name, env, clazz, methodid)
}

/* hotspot.jni.NewObjectV.return
 * Create a new object from jclass from va_list arguments. Return.
 *
 * ret - jobject or NULL on failure.
 */
probe hotspot.jni.NewObjectV.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewObjectV__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewObjectV__return")
{
  name = "NewObjectV"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.NewShortArray
 * Create new short array.
 *
 * env - JNIEnv pointer.
 * length - size of the array.
 */
probe hotspot.jni.NewShortArray =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewShortArray__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewShortArray__entry")
{
  name = "NewShortArray"
  env = $arg1
  length = $arg2
  probestr = sprintf("%s(env=0x%x,length=%d)", name, env, length)
}

/* hotspot.jni.NewShortArray.return
 * Create new short array. Return.
 *
 * ret - jlongArray or NULL on failure.
 */
probe hotspot.jni.NewShortArray.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewShortArray__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewShortArray__return")
{
  name = "NewShortArray"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.NewString
 * Create a new string from jchar unicode characters.
 *
 * env - JNIEnv pointer.
 * chars - jchar array.
 * len - Length of jchar array.
 */
probe hotspot.jni.NewString =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewString__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewString__entry")
{
  name = "NewString"
  env = $arg1
  chars = $arg2
  len = $arg3
  probestr = sprintf("%s(env=0x%x,chars=0x%x,len=%d)", name, env, chars, len)
}

/* hotspot.jni.NewString.return
 * Create a new string from jchar unicode characters. Return.
 *
 * ret - jstring or NULL on error.
 */
probe hotspot.jni.NewString.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewString__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewString__return")
{
  name = "NewString"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.NewStringUTF
 * Creates a new string from a UTF-8 array.
 *
 * env - JNIEnv pointer.
 * bytes - UTF-8 array.
 */
probe hotspot.jni.NewStringUTF =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewStringUTF__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewStringUTF__entry")
{
  name = "NewStringUTF"
  env = $arg1
  bytes = user_string($arg2)
  probestr = sprintf("%s(env=0x%x,bytes='%s')", name, env, bytes)
}

/* hotspot.jni.NewStringUTF.return
 * Creates a new string from a UTF-8 array. Return.
 *
 * ret - jstring created or NULL on failure.
 */
probe hotspot.jni.NewStringUTF.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewStringUTF__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewStringUTF__return")
{
  name = "NewStringUTF"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.NewWeakGlobalRef
 * Create a new weak reference for a jobject.
 *
 * env - JNIEnv pointer.
 * obj - jobject to create a weak reference for.
 */
probe hotspot.jni.NewWeakGlobalRef =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewWeakGlobalRef__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewWeakGlobalRef__entry")
{
  name = "NewWeakGlobalRef"
  env = $arg1
  obj = $arg2
  probestr = sprintf("%s(env=0x%x,obj=0x%x)", name, env, obj)
}

/* hotspot.jni.NewWeakGlobalRef.return
 * Create a new weak reference for a jobject. Return.
 *
 * ret - jweak reference, or NULL on failure.
 */
probe hotspot.jni.NewWeakGlobalRef.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("NewWeakGlobalRef__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("NewWeakGlobalRef__return")
{
  name = "NewWeakGlobalRef"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.PopLocalFrame
 * Pops local reference frame.
 *
 * env - JNIEnv pointer.
 * obj - jobject reference in current frame.
 */
probe hotspot.jni.PopLocalFrame =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("PopLocalFrame__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("PopLocalFrame__entry")
{
  name = "PopLocalFrame"
  env = $arg1
  obj = $arg2
  probestr = sprintf("%s(env=0x%x,obj=0x%x)", name, env, obj)
}

/* hotspot.jni.PopLocalFrame.return
 * Pops local reference frame. Return.
 *
 * ret - jobject reference in previous frame for given obj or NULL when non given.
 */
probe hotspot.jni.PopLocalFrame.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("PopLocalFrame__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("PopLocalFrame__return")
{
  name = "PopLocalFrame"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.PushLocalFrame
 * Pushes local reference frame.
 *
 * env - JNIEnv pointer.
 * capacity - Minimum number of references needed.
 */
probe hotspot.jni.PushLocalFrame =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("PushLocalFrame__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("PushLocalFrame__entry")
{
  name = "PushLocalFrame"
  env = $arg1
  capacity = $arg2
  probestr = sprintf("%s(env=0x%x,capacity=%d)", name, env, capacity)
}

/* hotspot.jni.PushLocalFrame.return
 * Pushes local reference frame. Return.
 *
 * ret - Zero on success, negative on failure.
 */
probe hotspot.jni.PushLocalFrame.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("PushLocalFrame__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("PushLocalFrame__return")
{
  name = "PushLocalFrame"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.RegisterNatives
 * Registers native methods for class.
 *
 * env - JNIEnv pointer.
 * clazz - jclass to register methods for.
 * methods - pointer to JNINativeMethods array.
 * nmethods - number of methods.
 */
probe hotspot.jni.RegisterNatives =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("RegisterNatives__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("RegisterNatives__entry")
{
  name = "RegisterNatives"
  env = $arg1
  clazz = $arg2
  methods = $arg3
  nmethods = $arg4
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,methods=0x%x,nmethods=0x%x)", name, env, clazz, methods, nmethods)
}

/* hotspot.jni.RegisterNatives.return
 * Registers native methods for class. Return.
 *
 * ret - Zero on success, negative otherwise.
 */
probe hotspot.jni.RegisterNatives.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("RegisterNatives__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("RegisterNatives__return")
{
  name = "RegisterNatives"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.ReleaseBooleanArrayElements
 * Releases boolean array elements.
 *
 * env - JNIEnv pointer.
 * array - jbooleanArray.
 * elems - jboolean array.
 * mode - How array should be released (0 commit back and free, 1 commit back and do not free, 2 free but do not commit back)
 */
probe hotspot.jni.ReleaseBooleanArrayElements =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ReleaseBooleanArrayElements__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ReleaseBooleanArrayElements__entry")
{
  name = "ReleaseBooleanArrayElements"
  env = $arg1
  array = $arg2
  elems = $arg3
  mode = $arg4
  probestr = sprintf("%s(env=0x%x,array=0x%x,elems=0x%x,mode=%d)", name, env, array, elems, mode)
}

/* hotspot.jni.ReleaseBooleanArrayElements.return
 * Releases boolean array elements. Return.
 */
probe hotspot.jni.ReleaseBooleanArrayElements.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ReleaseBooleanArrayElements__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ReleaseBooleanArrayElements__return")
{
  name = "ReleaseBooleanArrayElements"
  retstr = ""
}

/* hotspot.jni.ReleaseByteArrayElements
 * Releases byte array elements.
 *
 * env - JNIEnv pointer.
 * array - jbyteArray.
 * elems - jbyte array.
 * mode - How array should be released (0 commit back and free, 1 commit back and do not free, 2 free but do not commit back)
 */
probe hotspot.jni.ReleaseByteArrayElements =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ReleaseByteArrayElements__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ReleaseByteArrayElements__entry")
{
  name = "ReleaseByteArrayElements"
  env = $arg1
  array = $arg2
  elems = $arg3
  mode = $arg4
  probestr = sprintf("%s(env=0x%x,array=0x%x,elems=0x%x,mode=%d)", name, env, array, elems, mode)
}

/* hotspot.jni.ReleaseByteArrayElements.return
 * Releases byte array elements. Return.
 */
probe hotspot.jni.ReleaseByteArrayElements.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ReleaseByteArrayElements__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ReleaseByteArrayElements__return")
{
  name = "ReleaseByteArrayElements"
  retstr = ""
}

/* hotspot.jni.ReleaseCharArrayElements
 * Releases char array elements.
 *
 * env - JNIEnv pointer.
 * array - jcharArray.
 * elems - jchar array.
 * mode - How array should be released (0 commit back and free, 1 commit back and do not free, 2 free but do not commit back)
 */
probe hotspot.jni.ReleaseCharArrayElements =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ReleaseCharArrayElements__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ReleaseCharArrayElements__entry")
{
  name = "ReleaseCharArrayElements"
  env = $arg1
  array = $arg2
  elems = $arg3
  mode = $arg4
  probestr = sprintf("%s(env=0x%x,array=0x%x,elems=0x%x,mode=%d)", name, env, array, elems, mode)
}

/* hotspot.jni.ReleaseCharArrayElements.return
 * Releases char array elements. Return.
 */
probe hotspot.jni.ReleaseCharArrayElements.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ReleaseCharArrayElements__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ReleaseCharArrayElements__return")
{
  name = "ReleaseCharArrayElements"
  retstr = ""
}

/* hotspot.jni.ReleaseDoubleArrayElements
 * Releases double array elements.
 *
 * env - JNIEnv pointer.
 * array - jdoubleArray.
 * elems - jdouble array.
 * mode - How array should be released (0 commit back and free, 1 commit back and do not free, 2 free but do not commit back)
 */
probe hotspot.jni.ReleaseDoubleArrayElements =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ReleaseDoubleArrayElements__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ReleaseDoubleArrayElements__entry")
{
  name = "ReleaseDoubleArrayElements"
  env = $arg1
  array = $arg2
  elems = $arg3
  mode = $arg4
  probestr = sprintf("%s(env=0x%x,array=0x%x,elems=0x%x,mode=%d)", name, env, array, elems, mode)
}

/* hotspot.jni.ReleaseDoubleArrayElements.return
 * Releases double array elements. Return.
 */
probe hotspot.jni.ReleaseDoubleArrayElements.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ReleaseDoubleArrayElements__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ReleaseDoubleArrayElements__return")
{
  name = "ReleaseDoubleArrayElements"
  retstr = ""
}

/* hotspot.jni.ReleaseFloatArrayElements
 * Releases float array elements.
 *
 * env - JNIEnv pointer.
 * array - jfloatArray.
 * elems - jfloat array.
 * mode - How array should be released (0 commit back and free, 1 commit back and do not free, 2 free but do not commit back)
 */
probe hotspot.jni.ReleaseFloatArrayElements =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ReleaseFloatArrayElements__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ReleaseFloatArrayElements__entry")
{
  name = "ReleaseFloatArrayElements"
  env = $arg1
  array = $arg2
  elems = $arg3
  mode = $arg4
  probestr = sprintf("%s(env=0x%x,array=0x%x,elems=0x%x,mode=%d)", name, env, array, elems, mode)
}

/* hotspot.jni.ReleaseFloatArrayElements.return
 * Releases float array elements. Return.
 */
probe hotspot.jni.ReleaseFloatArrayElements.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ReleaseFloatArrayElements__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ReleaseFloatArrayElements__return")
{
  name = "ReleaseFloatArrayElements"
  retstr = ""
}

/* hotspot.jni.ReleaseIntArrayElements
 * Releases int array elements.
 *
 * env - JNIEnv pointer.
 * array - jintArray.
 * elems - jint array.
 * mode - How array should be released (0 commit back and free, 1 commit back and do not free, 2 free but do not commit back)
 */
probe hotspot.jni.ReleaseIntArrayElements =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ReleaseIntArrayElements__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ReleaseIntArrayElements__entry")
{
  name = "ReleaseIntArrayElements"
  env = $arg1
  array = $arg2
  elems = $arg3
  mode = $arg4
  probestr = sprintf("%s(env=0x%x,array=0x%x,elems=0x%x,mode=%d)", name, env, array, elems, mode)
}

/* hotspot.jni.ReleaseIntArrayElements.return
 * Releases int array elements. Return.
 */
probe hotspot.jni.ReleaseIntArrayElements.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ReleaseIntArrayElements__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ReleaseIntArrayElements__return")
{
  name = "ReleaseIntArrayElements"
  retstr = ""
}

/* hotspot.jni.ReleaseLongArrayElements
 * Releases long array elements.
 *
 * env - JNIEnv pointer.
 * array - jlongArray.
 * elems - jlong array.
 * mode - How array should be released (0 commit back and free, 1 commit back and do not free, 2 free but do not commit back)
 */
probe hotspot.jni.ReleaseLongArrayElements =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ReleaseLongArrayElements__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ReleaseLongArrayElements__entry")
{
  name = "ReleaseLongArrayElements"
  env = $arg1
  array = $arg2
  elems = $arg3
  mode = $arg4
  probestr = sprintf("%s(env=0x%x,array=0x%x,elems=0x%x,mode=%d)", name, env, array, elems, mode)
}

/* hotspot.jni.ReleaseLongArrayElements.return
 * Releases long array elements. Return.
 */
probe hotspot.jni.ReleaseLongArrayElements.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ReleaseLongArrayElements__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ReleaseLongArrayElements__return")
{
  name = "ReleaseLongArrayElements"
  retstr = ""
}

/* hotspot.jni.ReleasePrimitiveArrayCritical
 * Releases critical array elements.
 *
 * env - JNIEnv pointer.
 * array - jarray.
 * carray - Native elements pointer.
 * mode - How array should be released (0 commit back and free, 1 commit back and do not free, 2 free but do not commit back).
 */
probe hotspot.jni.ReleasePrimitiveArrayCritical =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ReleasePrimitiveArrayCritical__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ReleasePrimitiveArrayCritical__entry")
{
  name = "ReleasePrimitiveArrayCritical"
  env = $arg1
  array = $arg2
  carray = $arg3
  mode = $arg4
  probestr = sprintf("%s(env=0x%x,array=0x%x,carray=0x%x,mode=%d)", name, env, array, carray, mode)
}

/* hotspot.jni.ReleasePrimitiveArrayCritical.return
 * Releases critical array elements. Return.
 */
probe hotspot.jni.ReleasePrimitiveArrayCritical.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ReleasePrimitiveArrayCritical__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ReleasePrimitiveArrayCritical__return")
{
  name = "ReleasePrimitiveArrayCritical"
  retstr = ""
}

/* hotspot.jni.ReleaseShortArrayElements
 * Releases short array elements.
 *
 * env - JNIEnv pointer.
 * array - jshortArray.
 * elems - jshort array.
 * mode - How array should be released (0 commit back and free, 1 commit back and do not free, 2 free but do not commit back)
 */
probe hotspot.jni.ReleaseShortArrayElements =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ReleaseShortArrayElements__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ReleaseShortArrayElements__entry")
{
  name = "ReleaseShortArrayElements"
  env = $arg1
  array = $arg2
  elems = $arg3
  mode = $arg4
  probestr = sprintf("%s(env=0x%x,array=0x%x,elems=0x%x,mode=%d)", name, env, array, elems, mode)
}

/* hotspot.jni.ReleaseShortArrayElements.return
 * Releases short array elements. Return.
 */
probe hotspot.jni.ReleaseShortArrayElements.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ReleaseShortArrayElements__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ReleaseShortArrayElements__return")
{
  name = "ReleaseShortArrayElements"
  retstr = ""
}

/* hotspot.jni.ReleaseStringChars
 * Releases GetStringChar jchar array.
 *
 * env - JNIEnv pointer.
 * str - jstring.
 * chars - jchar array to release.
 */
probe hotspot.jni.ReleaseStringChars =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ReleaseStringChars__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ReleaseStringChars__entry")
{
  name = "ReleaseStringChars"
  env = $arg1
  str = $arg2
  chars = $arg3
  probestr = sprintf("%s(env=0x%x,str=0x%x,chars=0x%x)", name, env, str, chars)
}

/* hotspot.jni.ReleaseStringChars.return
 * Releases GetStringChar jchar array. Return.
 */
probe hotspot.jni.ReleaseStringChars.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ReleaseStringChars__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ReleaseStringChars__return")
{
  name = "ReleaseStringChars"
  retstr = ""
}

/* hotspot.jni.ReleaseStringCritical
 * Releases GetStringCritical jchar array.
 *
 * env - JNIEnv pointer.
 * str - jstring.
 * chars - jchar array to release.
 */
probe hotspot.jni.ReleaseStringCritical =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ReleaseStringCritical__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ReleaseStringCritical__entry")
{
  name = "ReleaseStringCritical"
  env = $arg1
  str = $arg2
  chars = $arg3
  probestr = sprintf("%s(env=0x%x,str=0x%x,chars=0x%x)", name, env, str, chars)
}

/* hotspot.jni.ReleaseStringCritical.return
 * Releases GetStringCritical jchar array. Return.
 */
probe hotspot.jni.ReleaseStringCritical.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ReleaseStringCritical__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ReleaseStringCritical__return")
{
  name = "ReleaseStringCritical"
  retstr = ""
}

/* hotspot.jni.ReleaseStringUTFChars
 * Releases GetStringUTF char array.
 *
 * env - JNIEnv pointer.
 * str - jstring pointer.
 * utf - Pointer to utf-8 chars to release.
 */
probe hotspot.jni.ReleaseStringUTFChars =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ReleaseStringUTFChars__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ReleaseStringUTFChars__entry")
{
  name = "ReleaseStringUTFChars"
  env = $arg1
  str = $arg2
  utf = user_string($arg3)
  probestr = sprintf("%s(env=0x%x,str=0x%x,utf='%s')", name, env, str, utf)
}

/* hotspot.jni.ReleaseStringUTFChars.return
 * Releases GetStringUTF char array. Return.
 */
probe hotspot.jni.ReleaseStringUTFChars.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ReleaseStringUTFChars__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ReleaseStringUTFChars__return")
{
  name = "ReleaseStringUTFChars"
  retstr = ""
}

/* hotspot.jni.SetBooleanArrayRegion
 * Copies a region into a jboolean array.
 *
 * env - JNIEnv pointer.
 * array - jbooleanArray to copy into.
 * start - Starting index.
 * len - Number of elements to copy.
 * buf - Native jboolean array pointer to copy from.
 */
probe hotspot.jni.SetBooleanArrayRegion =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetBooleanArrayRegion__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetBooleanArrayRegion__entry")
{
  name = "SetBooleanArrayRegion"
  env = $arg1
  array = $arg2
  start = $arg3
  len = $arg4
  buf = $arg5
  probestr = sprintf("%s(env=0x%x,array=0x%x,start=%d,len=%d,buf=0x%x)", name, env, array, start, len, buf)
}

/* hotspot.jni.SetBooleanArrayRegion.return
 * Copies a region into a jboolean array. Return.
 */
probe hotspot.jni.SetBooleanArrayRegion.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetBooleanArrayRegion__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetBooleanArrayRegion__return")
{
  name = "SetBooleanArrayRegion"
  retstr = ""
}

/* hotspot.jni.SetBooleanField
 * Set non-static jboolean field value.
 *
 * env - JNIEnv pointer.
 * obj - jobject.
 * field - jfieldID.
 * value - jboolean value.
 */
probe hotspot.jni.SetBooleanField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetBooleanField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetBooleanField__entry")
{
  name = "SetBooleanField"
  env = $arg1
  obj = $arg2
  field = $arg3
  value = $arg4
  probestr = sprintf("%s(env=0x%x,obj=0x%x,field=0x%x,value=%d)", name, env, obj, field, value)
}

/* hotspot.jni.SetBooleanField.return
 * Set non-static jboolean field value. Return.
 */
probe hotspot.jni.SetBooleanField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetBooleanField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetBooleanField__return")
{
  name = "SetBooleanField"
  retstr = ""
}

/* hotspot.jni.SetByteArrayRegion
 * Copies a region into a jbyte array.
 *
 * env - JNIEnv pointer.
 * array - jbyteArray to copy into.
 * start - Starting index.
 * len - Number of elements to copy.
 * buf - Native jbyte array pointer to copy from.
 */
probe hotspot.jni.SetByteArrayRegion =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetByteArrayRegion__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetByteArrayRegion__entry")
{
  name = "SetByteArrayRegion"
  env = $arg1
  array = $arg2
  start = $arg3
  len = $arg4
  buf = $arg5
  probestr = sprintf("%s(env=0x%x,array=0x%x,start=%d,len=%d,buf=0x%x)", name, env, array, start, len, buf)
}

/* hotspot.jni.SetByteArrayRegion.return
 * Copies a region into a jbyte array. Return.
 */
probe hotspot.jni.SetByteArrayRegion.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetByteArrayRegion__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetByteArrayRegion__return")
{
  name = "SetByteArrayRegion"
  retstr = ""
}

/* hotspot.jni.SetByteField
 * Set non-static jbyte field value.
 *
 * env - JNIEnv pointer.
 * obj - jobject.
 * field - jfieldID.
 * value - jbyte value.
 */
probe hotspot.jni.SetByteField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetByteField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetByteField__entry")
{
  name = "SetByteField"
  env = $arg1
  obj = $arg2
  field = $arg3
  value = $arg4
  probestr = sprintf("%s(env=0x%x,obj=0x%x,field=0x%x,value=%d)", name, env, obj, field, value)
}

/* hotspot.jni.SetByteField.return
 * Set non-static jbyte field value. Return.
 */
probe hotspot.jni.SetByteField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetByteField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetByteField__return")
{
  name = "SetByteField"
  retstr = ""
}

/* hotspot.jni.SetCharArrayRegion
 * Copies a region into a jchar array.
 *
 * env - JNIEnv pointer.
 * array - jcharArray to copy into.
 * start - Starting index.
 * len - Number of elements to copy.
 * buf - Native jchar array pointer to copy from.
 */
probe hotspot.jni.SetCharArrayRegion =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetCharArrayRegion__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetCharArrayRegion__entry")
{
  name = "SetCharArrayRegion"
  env = $arg1
  array = $arg2
  start = $arg3
  len = $arg4
  buf = $arg5
  probestr = sprintf("%s(env=0x%x,array=0x%x,start=%d,len=%d,buf=0x%x)", name, env, array, start, len, buf)
}

/* hotspot.jni.SetCharArrayRegion.return
 * Copies a region into a jchar array. Return.
 */
probe hotspot.jni.SetCharArrayRegion.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetCharArrayRegion__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetCharArrayRegion__return")
{
  name = "SetCharArrayRegion"
  retstr = ""
}

/* hotspot.jni.SetCharField
 * Set non-static jchar field value.
 *
 * env - JNIEnv pointer.
 * obj - jobject.
 * field - jfieldID.
 * value - jchar value.
 */
probe hotspot.jni.SetCharField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetCharField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetCharField__entry")
{
  name = "SetCharField"
  env = $arg1
  obj = $arg2
  field = $arg3
  value = $arg4
  probestr = sprintf("%s(env=0x%x,obj=0x%x,field=0x%x,value=%d)", name, env, obj, field, value)
}

/* hotspot.jni.SetCharField.return
 * Set non-static jchar field value. Return.
 */
probe hotspot.jni.SetCharField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetCharField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetCharField__return")
{
  name = "SetCharField"
  retstr = ""
}

/* hotspot.jni.SetDoubleArrayRegion
 * Copies a region into a jdouble array.
 *
 * env - JNIEnv pointer.
 * array - jdoubleArray to copy into.
 * start - Starting index.
 * len - Number of elements to copy.
 * buf - Native jdouble array pointer to copy from.
 */
probe hotspot.jni.SetDoubleArrayRegion =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetDoubleArrayRegion__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetDoubleArrayRegion__entry")
{
  name = "SetDoubleArrayRegion"
  env = $arg1
  array = $arg2
  start = $arg3
  len = $arg4
  buf = $arg5
  probestr = sprintf("%s(env=0x%x,array=0x%x,start=%d,len=%d,buf=0x%x)", name, env, array, start, len, buf)
}

/* hotspot.jni.SetDoubleArrayRegion.return
 * Copies a region into a jdouble array. Return.
 */
probe hotspot.jni.SetDoubleArrayRegion.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetDoubleArrayRegion__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetDoubleArrayRegion__return")
{
  name = "SetDoubleArrayRegion"
  retstr = ""
}

/* hotspot.jni.SetDoubleField
 * Set non-static jdouble field value.
 *
 * env - JNIEnv pointer.
 * obj - jobject.
 * field - jfieldID.
 */
probe hotspot.jni.SetDoubleField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetDoubleField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetDoubleField__entry")
{
  name = "SetDoubleField"
  env = $arg1
  obj = $arg2
  field = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,field=0x%x)", name, env, obj, field)
}

/* hotspot.jni.SetDoubleField.return
 * Set non-static jdouble field value. Return.
 */
probe hotspot.jni.SetDoubleField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetDoubleField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetDoubleField__return")
{
  name = "SetDoubleField"
  retstr = ""
}

/* hotspot.jni.SetFloatArrayRegion
 * Copies a region into a jfloat array.
 *
 * env - JNIEnv pointer.
 * array - jfloatArray to copy into.
 * start - Starting index.
 * len - Number of elements to copy.
 * buf - Native jfloat array pointer to copy from.
 */
probe hotspot.jni.SetFloatArrayRegion =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetFloatArrayRegion__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetFloatArrayRegion__entry")
{
  name = "SetFloatArrayRegion"
  env = $arg1
  array = $arg2
  start = $arg3
  len = $arg4
  buf = $arg5
  probestr = sprintf("%s(env=0x%x,array=0x%x,start=%d,len=%d,buf=0x%x)", name, env, array, start, len, buf)
}

/* hotspot.jni.SetFloatArrayRegion.return
 * Copies a region into a jfloat array. Return.
 */
probe hotspot.jni.SetFloatArrayRegion.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetFloatArrayRegion__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetFloatArrayRegion__return")
{
  name = "SetFloatArrayRegion"
  retstr = ""
}

/* hotspot.jni.SetFloatField
 * Set non-static jfloat field value.
 *
 * env - JNIEnv pointer.
 * obj - jobject.
 * field - jfieldID.
 */
probe hotspot.jni.SetFloatField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetFloatField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetFloatField__entry")
{
  name = "SetFloatField"
  env = $arg1
  obj = $arg2
  field = $arg3
  probestr = sprintf("%s(env=0x%x,obj=0x%x,field=0x%x)", name, env, obj, field)
}

/* hotspot.jni.SetFloatField.return
 * Set non-static jfloat field value. Return.
 */
probe hotspot.jni.SetFloatField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetFloatField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetFloatField__return")
{
  name = "SetFloatField"
  retstr = ""
}

/* hotspot.jni.SetIntArrayRegion
 * Copies a region into a jint array.
 *
 * env - JNIEnv pointer.
 * array - jintArray to copy into.
 * start - Starting index.
 * len - Number of elements to copy.
 * buf - Native jint array pointer to copy from.
 */
probe hotspot.jni.SetIntArrayRegion =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetIntArrayRegion__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetIntArrayRegion__entry")
{
  name = "SetIntArrayRegion"
  env = $arg1
  array = $arg2
  start = $arg3
  len = $arg4
  buf = $arg5
  probestr = sprintf("%s(env=0x%x,array=0x%x,start=%d,len=%d,buf=0x%x)", name, env, array, start, len, buf)
}

/* hotspot.jni.SetIntArrayRegion.return
 * Copies a region into a jint array. Return.
 */
probe hotspot.jni.SetIntArrayRegion.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetIntArrayRegion__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetIntArrayRegion__return")
{
  name = "SetIntArrayRegion"
  retstr = ""
}

/* hotspot.jni.SetIntField
 * Set non-static jint field value.
 *
 * env - JNIEnv pointer.
 * obj - jobject.
 * field - jfieldID.
 * value - jint value.
 */
probe hotspot.jni.SetIntField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetIntField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetIntField__entry")
{
  name = "SetIntField"
  env = $arg1
  obj = $arg2
  field = $arg3
  value = $arg4
  probestr = sprintf("%s(env=0x%x,obj=0x%x,field=0x%x,value=%d)", name, env, obj, field, value)
}

/* hotspot.jni.SetIntField.return
 * Set non-static jint field value. Return.
 */
probe hotspot.jni.SetIntField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetIntField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetIntField__return")
{
  name = "SetIntField"
  retstr = ""
}

/* hotspot.jni.SetLongArrayRegion
 * Copies a region into a jlong arry.
 *
 * env - JNIEnv pointer.
 * array - jlongArray to copy into.
 * start - Starting index.
 * len - Number of elements to copy.
 * buf - Native jlong array pointer to copy from.
 */
probe hotspot.jni.SetLongArrayRegion =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetLongArrayRegion__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetLongArrayRegion__entry")
{
  name = "SetLongArrayRegion"
  env = $arg1
  array = $arg2
  start = $arg3
  len = $arg4
  buf = $arg5
  probestr = sprintf("%s(env=0x%x,array=0x%x,start=%d,len=%d,buf=0x%x)", name, env, array, start, len, buf)
}

/* hotspot.jni.SetLongArrayRegion.return
 * Copies a region into a jlong arry. Return.
 */
probe hotspot.jni.SetLongArrayRegion.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetLongArrayRegion__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetLongArrayRegion__return")
{
  name = "SetLongArrayRegion"
  retstr = ""
}

/* hotspot.jni.SetLongField
 * Set non-static jlong field value.
 *
 * env - JNIEnv pointer.
 * obj - jobject.
 * field - jfieldID.
 * value - jlong value.
 */
probe hotspot.jni.SetLongField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetLongField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetLongField__entry")
{
  name = "SetLongField"
  env = $arg1
  obj = $arg2
  field = $arg3
  value = $arg4
  probestr = sprintf("%s(env=0x%x,obj=0x%x,field=0x%x,value=%d)", name, env, obj, field, value)
}

/* hotspot.jni.SetLongField.return
 * Set non-static jlong field value. Return.
 */
probe hotspot.jni.SetLongField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetLongField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetLongField__return")
{
  name = "SetLongField"
  retstr = ""
}

/* hotspot.jni.SetObjectArrayElement
 * Set jobjectArray element.
 *
 * env - JNIEnv pointer.
 * array - jobjectArray.
 * index - Element index to set.
 * value - jobject value.
 */
probe hotspot.jni.SetObjectArrayElement =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetObjectArrayElement__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetObjectArrayElement__entry")
{
  name = "SetObjectArrayElement"
  env = $arg1
  array = $arg2
  index = $arg3
  value = $arg4
  probestr = sprintf("%s(env=0x%x,array=0x%x,index=%d,value=0x%x)", name, env, array, index, value)
}

/* hotspot.jni.SetObjectArrayElement.return
 * Set jobjectArray element. Return.
 */
probe hotspot.jni.SetObjectArrayElement.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetObjectArrayElement__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetObjectArrayElement__return")
{
  name = "SetObjectArrayElement"
  retstr = ""
}

/* hotspot.jni.SetObjectField
 * Set non-static jobject field value.
 *
 * env - JNIEnv pointer.
 * obj - jobject.
 * field - jfieldID.
 * value - jobject value.
 */
probe hotspot.jni.SetObjectField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetObjectField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetObjectField__entry")
{
  name = "SetObjectField"
  env = $arg1
  obj = $arg2
  field = $arg3
  value = $arg4
  probestr = sprintf("%s(env=0x%x,obj=0x%x,field=0x%x,value=0x%x)", name, env, obj, field, value)
}

/* hotspot.jni.SetObjectField.return
 * Set non-static jobject field value. Return.
 */
probe hotspot.jni.SetObjectField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetObjectField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetObjectField__return")
{
  name = "SetObjectField"
  retstr = ""
}

/* hotspot.jni.SetShortArrayRegion
 * Copies a region into a jshort array.
 *
 * env - JNIEnv pointer.
 * array - jshortArray to copy into.
 * start - Starting index.
 * len - Number of elements to copy.
 * buf - jshort array pointer to copy from.
 */
probe hotspot.jni.SetShortArrayRegion =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetShortArrayRegion__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetShortArrayRegion__entry")
{
  name = "SetShortArrayRegion"
  env = $arg1
  array = $arg2
  start = $arg3
  len = $arg4
  buf = $arg5
  probestr = sprintf("%s(env=0x%x,array=0x%x,start=%d,len=%d,buf=0x%x)", name, env, array, start, len, buf)
}

/* hotspot.jni.SetShortArrayRegion.return
 * Copies a region into a jshort array. Return.
 */
probe hotspot.jni.SetShortArrayRegion.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetShortArrayRegion__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetShortArrayRegion__return")
{
  name = "SetShortArrayRegion"
  retstr = ""
}

/* hotspot.jni.SetShortField
 * Set non-static jshort field value.
 *
 * env - JNIEnv pointer.
 * obj - jobject.
 * field - jfieldID.
 * value - jshort value.
 */
probe hotspot.jni.SetShortField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetShortField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetShortField__entry")
{
  name = "SetShortField"
  env = $arg1
  obj = $arg2
  field = $arg3
  value = $arg4
  probestr = sprintf("%s(env=0x%x,obj=0x%x,field=0x%x,value=%d)", name, env, obj, field, value)
}

/* hotspot.jni.SetShortField.return
 * Set non-static jshort field value. Return.
 */
probe hotspot.jni.SetShortField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetShortField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetShortField__return")
{
  name = "SetShortField"
  retstr = ""
}

/* hotspot.jni.SetStaticBooleanField
 * Set static jboolean field value.
 *
 * env - JNIEnv pointer.
 * clazz - jclazz.
 * field - jfieldID.
 * value - jboolean value.
 */
probe hotspot.jni.SetStaticBooleanField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetStaticBooleanField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetStaticBooleanField__entry")
{
  name = "SetStaticBooleanField"
  env = $arg1
  clazz = $arg2
  field = $arg3
  value = $arg4
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,field=0x%x,value=%d)", name, env, clazz, field, value)
}

/* hotspot.jni.SetStaticBooleanField.return
 * Set static jboolean field value. Return.
 */
probe hotspot.jni.SetStaticBooleanField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetStaticBooleanField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetStaticBooleanField__return")
{
  name = "SetStaticBooleanField"
  retstr = ""
}

/* hotspot.jni.SetStaticByteField
 * Set static jbyte field value.
 *
 * env - JNIEnv pointer.
 * clazz - jclazz.
 * field - jfieldID.
 * value - jbyte value.
 */
probe hotspot.jni.SetStaticByteField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetStaticByteField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetStaticByteField__entry")
{
  name = "SetStaticByteField"
  env = $arg1
  clazz = $arg2
  field = $arg3
  value = $arg4
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,field=0x%x,value=%d)", name, env, clazz, field, value)
}

/* hotspot.jni.SetStaticByteField.return
 * Set static jbyte field value. Return.
 */
probe hotspot.jni.SetStaticByteField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetStaticByteField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetStaticByteField__return")
{
  name = "SetStaticByteField"
  retstr = ""
}

/* hotspot.jni.SetStaticCharField
 * Set static jchar field value.
 *
 * env - JNIEnv pointer.
 * clazz - jclazz.
 * field - jfieldID.
 * value - jchar value.
 */
probe hotspot.jni.SetStaticCharField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetStaticCharField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetStaticCharField__entry")
{
  name = "SetStaticCharField"
  env = $arg1
  clazz = $arg2
  field = $arg3
  value = $arg4
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,field=0x%x,value=%d)", name, env, clazz, field, value)
}

/* hotspot.jni.SetStaticCharField.return
 * Set static jchar field value. Return.
 */
probe hotspot.jni.SetStaticCharField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetStaticCharField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetStaticCharField__return")
{
  name = "SetStaticCharField"
  retstr = ""
}

/* hotspot.jni.SetStaticDoubleField
 * Set static jdouble field value.
 *
 * env - JNIEnv pointer.
 * clazz - jclazz.
 * field - jfieldID.
 */
probe hotspot.jni.SetStaticDoubleField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetStaticDoubleField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetStaticDoubleField__entry")
{
  name = "SetStaticDoubleField"
  env = $arg1
  clazz = $arg2
  field = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,field=0x%x)", name, env, clazz, field)
}

/* hotspot.jni.SetStaticDoubleField.return
 * Set static jdouble field value. Return.
 */
probe hotspot.jni.SetStaticDoubleField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetStaticDoubleField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetStaticDoubleField__return")
{
  name = "SetStaticDoubleField"
  retstr = ""
}

/* hotspot.jni.SetStaticFloatField
 * Set static jfloat field value.
 *
 * env - JNIEnv pointer.
 * clazz - jclazz.
 * field - jfieldID.
 */
probe hotspot.jni.SetStaticFloatField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetStaticFloatField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetStaticFloatField__entry")
{
  name = "SetStaticFloatField"
  env = $arg1
  clazz = $arg2
  field = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,field=0x%x)", name, env, clazz, field)
}

/* hotspot.jni.SetStaticFloatField.return
 * Set static jfloat field value. Return.
 */
probe hotspot.jni.SetStaticFloatField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetStaticFloatField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetStaticFloatField__return")
{
  name = "SetStaticFloatField"
  retstr = ""
}

/* hotspot.jni.SetStaticIntField
 * Set static jint field value.
 *
 * env - JNIEnv pointer.
 * clazz - jclazz.
 * field - jfieldID.
 * value - jint value.
 */
probe hotspot.jni.SetStaticIntField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetStaticIntField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetStaticIntField__entry")
{
  name = "SetStaticIntField"
  env = $arg1
  clazz = $arg2
  field = $arg3
  value = $arg4
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,field=0x%x,value=%d)", name, env, clazz, field, value)
}

/* hotspot.jni.SetStaticIntField.return
 * Set static jint field value. Return.
 */
probe hotspot.jni.SetStaticIntField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetStaticIntField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetStaticIntField__return")
{
  name = "SetStaticIntField"
  retstr = ""
}

/* hotspot.jni.SetStaticLongField
 * Set static jlong field value.
 *
 * env - JNIEnv pointer.
 * clazz - jclazz.
 * field - jfieldID.
 * value - jlong value.
 */
probe hotspot.jni.SetStaticLongField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetStaticLongField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetStaticLongField__entry")
{
  name = "SetStaticLongField"
  env = $arg1
  clazz = $arg2
  field = $arg3
  value = $arg4
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,field=0x%x,value=%d)", name, env, clazz, field, value)
}

/* hotspot.jni.SetStaticLongField.return
 * Set static jlong field value. Return.
 */
probe hotspot.jni.SetStaticLongField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetStaticLongField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetStaticLongField__return")
{
  name = "SetStaticLongField"
  retstr = ""
}

/* hotspot.jni.SetStaticObjectField
 * Set static jobject field value.
 *
 * env - JNIEnv pointer.
 * clazz - jclazz.
 * field - jfieldID.
 * value - jobject value.
 */
probe hotspot.jni.SetStaticObjectField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetStaticObjectField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetStaticObjectField__entry")
{
  name = "SetStaticObjectField"
  env = $arg1
  clazz = $arg2
  field = $arg3
  value = $arg4
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,field=0x%x,value=0x%x)", name, env, clazz, field, value)
}

/* hotspot.jni.SetStaticObjectField.return
 * Set static jobject field value. Return.
 */
probe hotspot.jni.SetStaticObjectField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetStaticObjectField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetStaticObjectField__return")
{
  name = "SetStaticObjectField"
  retstr = ""
}

/* hotspot.jni.SetStaticShortField
 * Set static jshort field value.
 *
 * env - JNIEnv pointer.
 * clazz - jclazz.
 * field - jfieldID.
 * value - jshort value.
 */
probe hotspot.jni.SetStaticShortField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetStaticShortField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetStaticShortField__entry")
{
  name = "SetStaticShortField"
  env = $arg1
  clazz = $arg2
  field = $arg3
  value = $arg4
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,field=0x%x,value=%d)", name, env, clazz, field, value)
}

/* hotspot.jni.SetStaticShortField.return
 * Set static jshort field value. Return.
 */
probe hotspot.jni.SetStaticShortField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("SetStaticShortField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("SetStaticShortField__return")
{
  name = "SetStaticShortField"
  retstr = ""
}

/* hotspot.jni.Throw
 * Throws a given jthrowable object.
 *
 * env - JNIEnv pointer.
 * obj - jthrowable to throw.
 */
probe hotspot.jni.Throw =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("Throw__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("Throw__entry")
{
  name = "Throw"
  env = $arg1
  obj = $arg2
  probestr = sprintf("%s(env=0x%x,obj=0x%x)", name, env, obj)
}

/* hotspot.jni.Throw.return
 * Throws a given jthrowable object. Return.
 *
 * ret - Zero on success, negative on error.
 */
probe hotspot.jni.Throw.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("Throw__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("Throw__return")
{
  name = "Throw"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.ThrowNew
 * Throws a new instance of the given jclass throwable with message.
 *
 * env - JNIEnv pointer.
 * clazz - jclass of the throwable.
 * msg - Message of the throwable.
 */
probe hotspot.jni.ThrowNew =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ThrowNew__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ThrowNew__entry")
{
  name = "ThrowNew"
  env = $arg1
  clazz = $arg2
  msg = user_string($arg3)
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,msg='%s')", name, env, clazz, msg)
}

/* hotspot.jni.ThrowNew.return
 * Throws a new instance of the given jclass throwable with message. Return.
 *
 * ret - Zero on success, negative on error.
 */
probe hotspot.jni.ThrowNew.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ThrowNew__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ThrowNew__return")
{
  name = "ThrowNew"
  ret = $arg1
  retstr = sprint(ret)
}

/* hotspot.jni.ToReflectedField
 * Get Field object from jfieldID.
 *
 * env - JNIEnv pointer.
 * clazz - jclass.
 * field - jfieldID.
 */
probe hotspot.jni.ToReflectedField =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ToReflectedField__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ToReflectedField__entry")
{
  name = "ToReflectedField"
  env = $arg1
  clazz = $arg2
  field = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,field=0x%x)", name, env, clazz, field)
}

/* hotspot.jni.ToReflectedField.return
 * Get Field object from jfieldID. Return.
 *
 * ret - jobject to instance of Field or NULL on failure
 */
probe hotspot.jni.ToReflectedField.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ToReflectedField__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ToReflectedField__return")
{
  name = "ToReflectedField"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.ToReflectedMethod
 * Get Method object from jmethodID.
 *
 * env - JNIEnv pointer.
 * clazz - jclass.
 * method - jmethodID.
 */
probe hotspot.jni.ToReflectedMethod =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ToReflectedMethod__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ToReflectedMethod__entry")
{
  name = "ToReflectedMethod"
  env = $arg1
  clazz = $arg2
  method = $arg3
  probestr = sprintf("%s(env=0x%x,clazz=0x%x,method=0x%x)", name, env, clazz, method)
}

/* hotspot.jni.ToReflectedMethod.return
 * Get Method object from jmethodID. Return.
 *
 * ret - jobject to instance of Method or NULL on failure
 */
probe hotspot.jni.ToReflectedMethod.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("ToReflectedMethod__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("ToReflectedMethod__return")
{
  name = "ToReflectedMethod"
  ret = $arg1
  retstr = sprintf("0x%x", ret)
}

/* hotspot.jni.UnregisterNatives
 * Unregisters native methods from the given jclass.
 *
 * env - JNIEnv pointer.
 * clazz - jclass to unregister native methods from.
 */
probe hotspot.jni.UnregisterNatives =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("UnregisterNatives__entry"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("UnregisterNatives__entry")
{
  name = "UnregisterNatives"
  env = $arg1
  clazz = $arg2
  probestr = sprintf("%s(env=0x%x,clazz=0x%x)", name, env, clazz)
}

/* hotspot.jni.UnregisterNatives.return
 * Unregisters native methods from the given jclass. Return.
 *
 * ret - Zero on success, negative on error.
 */
probe hotspot.jni.UnregisterNatives.return =
  process("@ABS_CLIENT_LIBJVM_SO@").mark("UnregisterNatives__return"),
  process("@ABS_SERVER_LIBJVM_SO@").mark("UnregisterNatives__return")
{
  name = "UnregisterNatives"
  ret = $arg1
  retstr = sprint(ret)
}