vm/include/ncai.h - harmony-drlvm - Git at Google

 /*
  *  Licensed to the Apache Software Foundation (ASF) under one or more
  *  contributor license agreements.  See the NOTICE file distributed with
  *  this work for additional information regarding copyright ownership.
  *  The ASF licenses this file to You under the Apache License, Version 2.0
  *  (the "License"); you may not use this file except in compliance with
  *  the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */

 /**
  * @author Intel, Petr Ivanov
  */
 #ifndef _NCAI_H_
 #define _NCAI_H_

 #include "ncai_types.h"
 #include "jni_types.h"


 /*
  * Supported NCAI versions
  */
 #define NCAI_VERSION_MASK_MAJOR 0x0FFF0000
 #define NCAI_VERSION_MASK_MINOR 0x0000FF00
 #define NCAI_VERSION_MASK_MICRO 0x000000FF
 #define NCAI_VERSION_SHIFT_MAJOR 16
 #define NCAI_VERSION_SHIFT_MINOR 8
 #define NCAI_VERSION_SHIFT_MICRO 0

 #define NCAI_VERSION_MAJOR 1
 #define NCAI_VERSION_MINOR 0
 #define NCAI_VERSION_MICRO 3

 #define NCAI_VERSION_1_0 \
     ((NCAI_VERSION_MAJOR << NCAI_VERSION_SHIFT_MAJOR) | \
      (NCAI_VERSION_MINOR << NCAI_VERSION_SHIFT_MINOR) | \
      (NCAI_VERSION_MICRO << NCAI_VERSION_SHIFT_MICRO))

 #define NCAI_VERSION NCAI_VERSION_1_0


 struct _ncai
 {
     ncaiError (JNICALL *GetAllLoadedModules) (ncaiEnv* env,
         jint* count_ptr,
         ncaiModule** modules_ptr);

     ncaiError (JNICALL *GetModuleInfo) (ncaiEnv* env,
         ncaiModule module,
         ncaiModuleInfo* info_ptr);

     ncaiError (JNICALL *GetModuleClassLoader) (ncaiEnv* env,
         ncaiModule module,
         jobject* classloader_ptr);

     ncaiError (JNICALL *IsMethodCompiled) (ncaiEnv* env,
         jmethodID method,
         jboolean* is_compiled_ptr);

     ncaiError (JNICALL *GetMethodLocation) (ncaiEnv* env,
         jmethodID method,
         void** address_ptr,
         size_t* size_ptr);

     ncaiError (JNICALL *FindJavaMethod) (ncaiEnv* env,
         void* address,
         jmethodID* method_ptr);

     ncaiError (JNICALL *GetBytcodeLocation) (ncaiEnv* env,
         void* address,
         jmethodID* method,
         jlocation* location_ptr);

     ncaiError (JNICALL *GetNativeLocation) (ncaiEnv* env,
         jmethodID method,
         jlocation location,
         void** address_ptr);

     ncaiError (JNICALL *GetAllThreads) (ncaiEnv* env,
         jint* count_ptr,
         ncaiThread** threads_ptr);

     ncaiError (JNICALL *GetThreadInfo) (ncaiEnv* env,
         ncaiThread thread,
         ncaiThreadInfo* info_ptr);

     ncaiError (JNICALL *GetThreadHandle) (ncaiEnv* env,
         jthread thread,
         ncaiThread* thread_ptr);

     ncaiError (JNICALL *GetThreadObject) (ncaiEnv* env,
         ncaiThread thread,
         jthread* thread_ptr);

     ncaiError (JNICALL *SuspendThread) (ncaiEnv* env,
         ncaiThread thread);

     ncaiError (JNICALL *ResumeThread) (ncaiEnv* env,
         ncaiThread thread);

     ncaiError (JNICALL *TerminateThread) (ncaiEnv* env,
         ncaiThread thread);

     ncaiError (JNICALL *GetThreadState) (ncaiEnv* env,
         ncaiThread thread,
         jint* state_ptr);

     ncaiError (JNICALL *GetFrameCount) (ncaiEnv* env,
         ncaiThread thread,
         jint* count_ptr);

     ncaiError (JNICALL *GetStackTrace) (ncaiEnv* env,
         ncaiThread thread,
         jint depth,
         ncaiFrameInfo* frame_buffer,
         jint* count_ptr);

     ncaiError (JNICALL *GetRegisterCount) (ncaiEnv* env,
         jint* count_ptr);

     ncaiError (JNICALL *GetRegisterInfo) (ncaiEnv* env,
         jint reg_number,
         ncaiRegisterInfo* info_ptr);

     ncaiError (JNICALL *GetRegisterValue) (ncaiEnv* env,
         ncaiThread thread,
         jint reg_number,
         void* buf);

     ncaiError (JNICALL *SetRegisterValue) (ncaiEnv* env,
         ncaiThread thread,
         jint reg_number,
         void* buf);

     ncaiError (JNICALL *ReadMemory) (ncaiEnv* env,
         void* addr,
         size_t size,
         void* buf);

     ncaiError (JNICALL *WriteMemory) (ncaiEnv* env,
         void* addr,
         size_t size,
         void* buf);

     ncaiError (JNICALL *GetSignalCount) (ncaiEnv* env,
         jint* count_ptr);

     ncaiError (JNICALL *GetSignalInfo) (ncaiEnv* env,
         jint signal,
         ncaiSignalInfo* info_ptr);

     ncaiError (JNICALL *GetJvmtiEnv) (ncaiEnv* env,
         jvmtiEnv** jvmti_env_ptr);

     ncaiError (JNICALL *GetVersion) (ncaiEnv* env,
         jint* version_ptr);

     ncaiError (JNICALL *GetErrorName) (ncaiEnv* env,
         ncaiError err,
         const char** name_ptr);

     ncaiError (JNICALL *GetPotentialCapabilities) (ncaiEnv* env,
         ncaiCapabilities* caps_ptr);

     ncaiError (JNICALL *GetCapabilities) (ncaiEnv* env,
         ncaiCapabilities* caps_ptr);

     ncaiError (JNICALL *AddCapabilities) (ncaiEnv* env,
         ncaiCapabilities* caps_ptr);

     ncaiError (JNICALL *RelinquishCapabilities) (ncaiEnv* env,
         ncaiCapabilities* caps_ptr);

     ncaiError (JNICALL *GetEventCallbacks) (ncaiEnv* env,
         ncaiEventCallbacks* callbacks,
         size_t size);

     ncaiError (JNICALL *SetEventCallbacks) (ncaiEnv* env,
         ncaiEventCallbacks* callbacks,
         size_t size);

     ncaiError (JNICALL *SetEventNotificationMode) (ncaiEnv* env,
         ncaiEventMode mode,
         ncaiEventKind event,
         ncaiThread thread);

     ncaiError (JNICALL *SetBreakpoint) (ncaiEnv* env,
         void* code_addr);

     ncaiError (JNICALL *ClearBreakpoint) (ncaiEnv* env,
         void* code_addr);

     ncaiError (JNICALL *SetWatchpoint) (ncaiEnv* env,
         void* data_addr,
         size_t len,
         ncaiWatchpointMode mode);

     ncaiError (JNICALL *ClearWatchpoint) (ncaiEnv* env,
         void* data_addr);

     ncaiError (JNICALL *SetStepMode) (ncaiEnv* env,
         ncaiThread thread,
         ncaiStepMode mode);

     ncaiError (JNICALL *NotifyFramePop) (ncaiEnv* env,
         ncaiThread thread,
         void* frame_address);
 };

 struct ncaiEnv_struct
 {
     const struct _ncai* funcs;

 #ifdef __cplusplus

     ncaiError GetAllLoadedModules (jint* count_ptr, ncaiModule** modules_ptr)
     {
         return funcs->GetAllLoadedModules (this, count_ptr, modules_ptr);
     }

     ncaiError GetModuleInfo (ncaiModule module, ncaiModuleInfo* info_ptr)
     {
         return funcs->GetModuleInfo (this, module, info_ptr);
     }

     ncaiError GetModuleClassLoader (ncaiModule module, jobject* classloader_ptr)
     {
         return funcs->GetModuleClassLoader (this, module, classloader_ptr);
     }

     ncaiError IsMethodCompiled (jmethodID method, jboolean* is_compiled_ptr)
     {
         return funcs->IsMethodCompiled (this, method, is_compiled_ptr);
     }

     ncaiError GetMethodLocation (jmethodID method, void** address_ptr, size_t* size_ptr)
     {
         return funcs->GetMethodLocation (this, method, address_ptr, size_ptr);
     }

     ncaiError FindJavaMethod (void* address, jmethodID* method_ptr)
     {
         return funcs->FindJavaMethod (this, address, method_ptr);
     }

     ncaiError GetBytcodeLocation (void* address, jmethodID* method, jlocation* location_ptr)
     {
         return funcs->GetBytcodeLocation (this, address, method, location_ptr);
     }

     ncaiError GetNativeLocation (jmethodID method, jlocation location, void** address_ptr)
     {
         return funcs->GetNativeLocation (this, method, location, address_ptr);
     }

     ncaiError GetAllThreads (jint* count_ptr, ncaiThread** threads_ptr)
     {
         return funcs->GetAllThreads (this, count_ptr, threads_ptr);
     }

     ncaiError GetThreadInfo (ncaiThread thread, ncaiThreadInfo* info_ptr)
     {
         return funcs->GetThreadInfo (this, thread, info_ptr);
     }

     ncaiError GetThreadHandle (jthread thread, ncaiThread* thread_ptr)
     {
         return funcs->GetThreadHandle (this, thread, thread_ptr);
     }

     ncaiError GetThreadObject (ncaiThread thread, jthread* thread_ptr)
     {
         return funcs->GetThreadObject (this, thread, thread_ptr);
     }

     ncaiError SuspendThread (ncaiThread thread)
     {
         return funcs->SuspendThread (this, thread);
     }

     ncaiError ResumeThread (ncaiThread thread)
     {
         return funcs->ResumeThread (this, thread);
     }

     ncaiError TerminateThread (ncaiThread thread)
     {
         return funcs->TerminateThread (this, thread);
     }

     ncaiError GetThreadState (ncaiThread thread, jint* state_ptr)
     {
         return funcs->GetThreadState (this, thread, state_ptr);
     }

     ncaiError GetFrameCount (ncaiThread thread, jint* count_ptr)
     {
         return funcs->GetFrameCount (this, thread, count_ptr);
     }

     ncaiError GetStackTrace (ncaiThread thread, jint depth, ncaiFrameInfo* frame_buffer, jint* count_ptr)
     {
         return funcs->GetStackTrace (this, thread, depth, frame_buffer, count_ptr);
     }

     ncaiError GetRegisterCount (jint* count_ptr)
     {
         return funcs->GetRegisterCount (this, count_ptr);
     }

     ncaiError GetRegisterInfo (jint reg_number, ncaiRegisterInfo* info_ptr)
     {
         return funcs->GetRegisterInfo (this, reg_number, info_ptr);
     }

     ncaiError GetRegisterValue (ncaiThread thread, jint reg_number, void* buf)
     {
         return funcs->GetRegisterValue (this, thread, reg_number, buf);
     }

     ncaiError SetRegisterValue (ncaiThread thread, jint reg_number, void* buf)
     {
         return funcs->SetRegisterValue (this, thread, reg_number, buf);
     }

     ncaiError ReadMemory (void* addr, size_t size, void* buf)
     {
         return funcs->ReadMemory (this, addr, size, buf);
     }

     ncaiError WriteMemory (void* addr, size_t size, void* buf)
     {
         return funcs->WriteMemory (this, addr, size, buf);
     }

     ncaiError GetSignalCount (jint* count_ptr)
     {
         return funcs->GetSignalCount (this, count_ptr);
     }

     ncaiError GetSignalInfo (jint signal, ncaiSignalInfo* info_ptr)
     {
         return funcs->GetSignalInfo (this, signal, info_ptr);
     }

     ncaiError GetJvmtiEnv (jvmtiEnv** jvmti_env_ptr)
     {
         return funcs->GetJvmtiEnv (this, jvmti_env_ptr);
     }

     ncaiError GetVersion (jint* version_ptr)
     {
         return funcs->GetVersion (this, version_ptr);
     }

     ncaiError GetErrorName (ncaiError err, const char** name_ptr)
     {
         return funcs->GetErrorName (this, err, name_ptr);
     }

     ncaiError GetPotentialCapabilities (ncaiCapabilities* caps_ptr)
     {
         return funcs->GetPotentialCapabilities (this, caps_ptr);
     }

     ncaiError GetCapabilities (ncaiCapabilities* caps_ptr)
     {
         return funcs->GetCapabilities (this, caps_ptr);
     }

     ncaiError AddCapabilities (ncaiCapabilities* caps_ptr)
     {
         return funcs->AddCapabilities (this, caps_ptr);
     }

     ncaiError RelinquishCapabilities (ncaiCapabilities* caps_ptr)
     {
         return funcs->RelinquishCapabilities (this, caps_ptr);
     }

     ncaiError GetEventCallbacks (ncaiEventCallbacks* callbacks, size_t size)
     {
         return funcs->GetEventCallbacks (this, callbacks, size);
     }

     ncaiError SetEventCallbacks (ncaiEventCallbacks* callbacks, size_t size)
     {
         return funcs->SetEventCallbacks (this, callbacks, size);
     }

     ncaiError SetEventNotificationMode (ncaiEventMode mode, ncaiEventKind event, ncaiThread thread)
     {
         return funcs->SetEventNotificationMode (this, mode, event, thread);
     }

     ncaiError SetBreakpoint (void* code_addr)
     {
         return funcs->SetBreakpoint (this, code_addr);
     }

     ncaiError ClearBreakpoint (void* code_addr)
     {
         return funcs->ClearBreakpoint (this, code_addr);
     }

     ncaiError SetWatchpoint (void* data_addr, size_t len, ncaiWatchpointMode mode)
     {
         return funcs->SetWatchpoint (this, data_addr, len, mode);
     }

     ncaiError ClearWatchpoint (void* data_addr)
     {
         return funcs->ClearWatchpoint (this, data_addr);
     }

     ncaiError SetStepMode (ncaiThread thread, ncaiStepMode mode)
     {
         return funcs->SetStepMode (this, thread, mode);
     }

     ncaiError NotifyFramePop (ncaiThread thread, void* frame_address)
     {
         return funcs->NotifyFramePop (this, thread, frame_address);
     }

 #endif
 };


 #endif /* _NCAI_H_ */
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/**
	* @author Intel, Petr Ivanov
	*/
	#ifndef _NCAI_H_
	#define _NCAI_H_

	#include "ncai_types.h"
	#include "jni_types.h"


	/*
	* Supported NCAI versions
	*/
	#define NCAI_VERSION_MASK_MAJOR 0x0FFF0000
	#define NCAI_VERSION_MASK_MINOR 0x0000FF00
	#define NCAI_VERSION_MASK_MICRO 0x000000FF
	#define NCAI_VERSION_SHIFT_MAJOR 16
	#define NCAI_VERSION_SHIFT_MINOR 8
	#define NCAI_VERSION_SHIFT_MICRO 0

	#define NCAI_VERSION_MAJOR 1
	#define NCAI_VERSION_MINOR 0
	#define NCAI_VERSION_MICRO 3

	#define NCAI_VERSION_1_0 \
	((NCAI_VERSION_MAJOR << NCAI_VERSION_SHIFT_MAJOR) \| \
	(NCAI_VERSION_MINOR << NCAI_VERSION_SHIFT_MINOR) \| \
	(NCAI_VERSION_MICRO << NCAI_VERSION_SHIFT_MICRO))

	#define NCAI_VERSION NCAI_VERSION_1_0


	struct _ncai
	{
	ncaiError (JNICALL GetAllLoadedModules) (ncaiEnv env,
	jint* count_ptr,
	ncaiModule** modules_ptr);

	ncaiError (JNICALL GetModuleInfo) (ncaiEnv env,
	ncaiModule module,
	ncaiModuleInfo* info_ptr);

	ncaiError (JNICALL GetModuleClassLoader) (ncaiEnv env,
	ncaiModule module,
	jobject* classloader_ptr);

	ncaiError (JNICALL IsMethodCompiled) (ncaiEnv env,
	jmethodID method,
	jboolean* is_compiled_ptr);

	ncaiError (JNICALL GetMethodLocation) (ncaiEnv env,
	jmethodID method,
	void** address_ptr,
	size_t* size_ptr);

	ncaiError (JNICALL FindJavaMethod) (ncaiEnv env,
	void* address,
	jmethodID* method_ptr);

	ncaiError (JNICALL GetBytcodeLocation) (ncaiEnv env,
	void* address,
	jmethodID* method,
	jlocation* location_ptr);

	ncaiError (JNICALL GetNativeLocation) (ncaiEnv env,
	jmethodID method,
	jlocation location,
	void** address_ptr);

	ncaiError (JNICALL GetAllThreads) (ncaiEnv env,
	jint* count_ptr,
	ncaiThread** threads_ptr);

	ncaiError (JNICALL GetThreadInfo) (ncaiEnv env,
	ncaiThread thread,
	ncaiThreadInfo* info_ptr);

	ncaiError (JNICALL GetThreadHandle) (ncaiEnv env,
	jthread thread,
	ncaiThread* thread_ptr);

	ncaiError (JNICALL GetThreadObject) (ncaiEnv env,
	ncaiThread thread,
	jthread* thread_ptr);

	ncaiError (JNICALL SuspendThread) (ncaiEnv env,
	ncaiThread thread);

	ncaiError (JNICALL ResumeThread) (ncaiEnv env,
	ncaiThread thread);

	ncaiError (JNICALL TerminateThread) (ncaiEnv env,
	ncaiThread thread);

	ncaiError (JNICALL GetThreadState) (ncaiEnv env,
	ncaiThread thread,
	jint* state_ptr);

	ncaiError (JNICALL GetFrameCount) (ncaiEnv env,
	ncaiThread thread,
	jint* count_ptr);

	ncaiError (JNICALL GetStackTrace) (ncaiEnv env,
	ncaiThread thread,
	jint depth,
	ncaiFrameInfo* frame_buffer,
	jint* count_ptr);

	ncaiError (JNICALL GetRegisterCount) (ncaiEnv env,
	jint* count_ptr);

	ncaiError (JNICALL GetRegisterInfo) (ncaiEnv env,
	jint reg_number,
	ncaiRegisterInfo* info_ptr);

	ncaiError (JNICALL GetRegisterValue) (ncaiEnv env,
	ncaiThread thread,
	jint reg_number,
	void* buf);

	ncaiError (JNICALL SetRegisterValue) (ncaiEnv env,
	ncaiThread thread,
	jint reg_number,
	void* buf);

	ncaiError (JNICALL ReadMemory) (ncaiEnv env,
	void* addr,
	size_t size,
	void* buf);

	ncaiError (JNICALL WriteMemory) (ncaiEnv env,
	void* addr,
	size_t size,
	void* buf);

	ncaiError (JNICALL GetSignalCount) (ncaiEnv env,
	jint* count_ptr);

	ncaiError (JNICALL GetSignalInfo) (ncaiEnv env,
	jint signal,
	ncaiSignalInfo* info_ptr);

	ncaiError (JNICALL GetJvmtiEnv) (ncaiEnv env,
	jvmtiEnv** jvmti_env_ptr);

	ncaiError (JNICALL GetVersion) (ncaiEnv env,
	jint* version_ptr);

	ncaiError (JNICALL GetErrorName) (ncaiEnv env,
	ncaiError err,
	const char** name_ptr);

	ncaiError (JNICALL GetPotentialCapabilities) (ncaiEnv env,
	ncaiCapabilities* caps_ptr);

	ncaiError (JNICALL GetCapabilities) (ncaiEnv env,
	ncaiCapabilities* caps_ptr);

	ncaiError (JNICALL AddCapabilities) (ncaiEnv env,
	ncaiCapabilities* caps_ptr);

	ncaiError (JNICALL RelinquishCapabilities) (ncaiEnv env,
	ncaiCapabilities* caps_ptr);

	ncaiError (JNICALL GetEventCallbacks) (ncaiEnv env,
	ncaiEventCallbacks* callbacks,
	size_t size);

	ncaiError (JNICALL SetEventCallbacks) (ncaiEnv env,
	ncaiEventCallbacks* callbacks,
	size_t size);

	ncaiError (JNICALL SetEventNotificationMode) (ncaiEnv env,
	ncaiEventMode mode,
	ncaiEventKind event,
	ncaiThread thread);

	ncaiError (JNICALL SetBreakpoint) (ncaiEnv env,
	void* code_addr);

	ncaiError (JNICALL ClearBreakpoint) (ncaiEnv env,
	void* code_addr);

	ncaiError (JNICALL SetWatchpoint) (ncaiEnv env,
	void* data_addr,
	size_t len,
	ncaiWatchpointMode mode);

	ncaiError (JNICALL ClearWatchpoint) (ncaiEnv env,
	void* data_addr);

	ncaiError (JNICALL SetStepMode) (ncaiEnv env,
	ncaiThread thread,
	ncaiStepMode mode);

	ncaiError (JNICALL NotifyFramePop) (ncaiEnv env,
	ncaiThread thread,
	void* frame_address);
	};

	struct ncaiEnv_struct
	{
	const struct _ncai* funcs;

	#ifdef __cplusplus

	ncaiError GetAllLoadedModules (jint* count_ptr, ncaiModule** modules_ptr)
	{
	return funcs->GetAllLoadedModules (this, count_ptr, modules_ptr);
	}

	ncaiError GetModuleInfo (ncaiModule module, ncaiModuleInfo* info_ptr)
	{
	return funcs->GetModuleInfo (this, module, info_ptr);
	}

	ncaiError GetModuleClassLoader (ncaiModule module, jobject* classloader_ptr)
	{
	return funcs->GetModuleClassLoader (this, module, classloader_ptr);
	}

	ncaiError IsMethodCompiled (jmethodID method, jboolean* is_compiled_ptr)
	{
	return funcs->IsMethodCompiled (this, method, is_compiled_ptr);
	}

	ncaiError GetMethodLocation (jmethodID method, void** address_ptr, size_t* size_ptr)
	{
	return funcs->GetMethodLocation (this, method, address_ptr, size_ptr);
	}

	ncaiError FindJavaMethod (void* address, jmethodID* method_ptr)
	{
	return funcs->FindJavaMethod (this, address, method_ptr);
	}

	ncaiError GetBytcodeLocation (void* address, jmethodID* method, jlocation* location_ptr)
	{
	return funcs->GetBytcodeLocation (this, address, method, location_ptr);
	}

	ncaiError GetNativeLocation (jmethodID method, jlocation location, void** address_ptr)
	{
	return funcs->GetNativeLocation (this, method, location, address_ptr);
	}

	ncaiError GetAllThreads (jint* count_ptr, ncaiThread** threads_ptr)
	{
	return funcs->GetAllThreads (this, count_ptr, threads_ptr);
	}

	ncaiError GetThreadInfo (ncaiThread thread, ncaiThreadInfo* info_ptr)
	{
	return funcs->GetThreadInfo (this, thread, info_ptr);
	}

	ncaiError GetThreadHandle (jthread thread, ncaiThread* thread_ptr)
	{
	return funcs->GetThreadHandle (this, thread, thread_ptr);
	}

	ncaiError GetThreadObject (ncaiThread thread, jthread* thread_ptr)
	{
	return funcs->GetThreadObject (this, thread, thread_ptr);
	}

	ncaiError SuspendThread (ncaiThread thread)
	{
	return funcs->SuspendThread (this, thread);
	}

	ncaiError ResumeThread (ncaiThread thread)
	{
	return funcs->ResumeThread (this, thread);
	}

	ncaiError TerminateThread (ncaiThread thread)
	{
	return funcs->TerminateThread (this, thread);
	}

	ncaiError GetThreadState (ncaiThread thread, jint* state_ptr)
	{
	return funcs->GetThreadState (this, thread, state_ptr);
	}

	ncaiError GetFrameCount (ncaiThread thread, jint* count_ptr)
	{
	return funcs->GetFrameCount (this, thread, count_ptr);
	}

	ncaiError GetStackTrace (ncaiThread thread, jint depth, ncaiFrameInfo* frame_buffer, jint* count_ptr)
	{
	return funcs->GetStackTrace (this, thread, depth, frame_buffer, count_ptr);
	}

	ncaiError GetRegisterCount (jint* count_ptr)
	{
	return funcs->GetRegisterCount (this, count_ptr);
	}

	ncaiError GetRegisterInfo (jint reg_number, ncaiRegisterInfo* info_ptr)
	{
	return funcs->GetRegisterInfo (this, reg_number, info_ptr);
	}

	ncaiError GetRegisterValue (ncaiThread thread, jint reg_number, void* buf)
	{
	return funcs->GetRegisterValue (this, thread, reg_number, buf);
	}

	ncaiError SetRegisterValue (ncaiThread thread, jint reg_number, void* buf)
	{
	return funcs->SetRegisterValue (this, thread, reg_number, buf);
	}

	ncaiError ReadMemory (void* addr, size_t size, void* buf)
	{
	return funcs->ReadMemory (this, addr, size, buf);
	}

	ncaiError WriteMemory (void* addr, size_t size, void* buf)
	{
	return funcs->WriteMemory (this, addr, size, buf);
	}

	ncaiError GetSignalCount (jint* count_ptr)
	{
	return funcs->GetSignalCount (this, count_ptr);
	}

	ncaiError GetSignalInfo (jint signal, ncaiSignalInfo* info_ptr)
	{
	return funcs->GetSignalInfo (this, signal, info_ptr);
	}

	ncaiError GetJvmtiEnv (jvmtiEnv** jvmti_env_ptr)
	{
	return funcs->GetJvmtiEnv (this, jvmti_env_ptr);
	}

	ncaiError GetVersion (jint* version_ptr)
	{
	return funcs->GetVersion (this, version_ptr);
	}

	ncaiError GetErrorName (ncaiError err, const char** name_ptr)
	{
	return funcs->GetErrorName (this, err, name_ptr);
	}

	ncaiError GetPotentialCapabilities (ncaiCapabilities* caps_ptr)
	{
	return funcs->GetPotentialCapabilities (this, caps_ptr);
	}

	ncaiError GetCapabilities (ncaiCapabilities* caps_ptr)
	{
	return funcs->GetCapabilities (this, caps_ptr);
	}

	ncaiError AddCapabilities (ncaiCapabilities* caps_ptr)
	{
	return funcs->AddCapabilities (this, caps_ptr);
	}

	ncaiError RelinquishCapabilities (ncaiCapabilities* caps_ptr)
	{
	return funcs->RelinquishCapabilities (this, caps_ptr);
	}

	ncaiError GetEventCallbacks (ncaiEventCallbacks* callbacks, size_t size)
	{
	return funcs->GetEventCallbacks (this, callbacks, size);
	}

	ncaiError SetEventCallbacks (ncaiEventCallbacks* callbacks, size_t size)
	{
	return funcs->SetEventCallbacks (this, callbacks, size);
	}

	ncaiError SetEventNotificationMode (ncaiEventMode mode, ncaiEventKind event, ncaiThread thread)
	{
	return funcs->SetEventNotificationMode (this, mode, event, thread);
	}

	ncaiError SetBreakpoint (void* code_addr)
	{
	return funcs->SetBreakpoint (this, code_addr);
	}

	ncaiError ClearBreakpoint (void* code_addr)
	{
	return funcs->ClearBreakpoint (this, code_addr);
	}

	ncaiError SetWatchpoint (void* data_addr, size_t len, ncaiWatchpointMode mode)
	{
	return funcs->SetWatchpoint (this, data_addr, len, mode);
	}

	ncaiError ClearWatchpoint (void* data_addr)
	{
	return funcs->ClearWatchpoint (this, data_addr);
	}

	ncaiError SetStepMode (ncaiThread thread, ncaiStepMode mode)
	{
	return funcs->SetStepMode (this, thread, mode);
	}

	ncaiError NotifyFramePop (ncaiThread thread, void* frame_address)
	{
	return funcs->NotifyFramePop (this, thread, frame_address);
	}

	#endif
	};


	#endif /* _NCAI_H_ */