1 /* src/native/jvmti.c - implementation of the Java Virtual Machine Tool
4 Copyright (C) 1996-2005 R. Grafl, A. Krall, C. Kruegel, C. Oates,
5 R. Obermaisser, M. Platter, M. Probst, S. Ring, E. Steiner,
6 C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich, J. Wenninger,
7 Institut f. Computersprachen - TU Wien
9 This file is part of CACAO.
11 This program is free software; you can redistribute it and/or
12 modify it under the terms of the GNU General Public License as
13 published by the Free Software Foundation; either version 2, or (at
14 your option) any later version.
16 This program is distributed in the hope that it will be useful, but
17 WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
26 Contact: cacao@complang.tuwien.ac.at
28 Author: Martin Platter
33 $Id: jvmti.c 3062 2005-07-19 10:03:00Z motse $
38 #include "native/jni.h"
39 #include "native/jvmti.h"
40 #include "vm/global.h"
41 #include "vm/loader.h"
42 #include "vm/builtin.h"
43 #include "vm/jit/asmpart.h"
45 #include "toolbox/logging.h"
46 #include "vm/options.h"
47 #include "cacao/cacao.h"
48 #include "vm/stringlocal.h"
49 #include "mm/memory.h"
50 #include "threads/native/threads.h"
51 #include "vm/exceptions.h"
54 #include <linux/unistd.h>
57 static jvmtiPhase phase;
61 jvmtiEventCallbacks callbacks;
62 jobject *events; /* hashtable for enabled/disabled jvmtiEvents */
63 jvmtiCapabilities capabilities;
64 void *EnvironmentLocalStorage;
68 /* jmethodID and jclass caching */
69 static jclass ihmclass = NULL;
70 static jmethodID ihmmid = NULL;
72 jvmtiEnv JVMTI_EnvTable;
73 jvmtiCapabilities JVMTI_Capabilities;
75 #define CHECK_PHASE_START if (!(0
76 #define CHECK_PHASE(chkphase) || (phase == chkphase)
77 #define CHECK_PHASE_END )) return JVMTI_ERROR_WRONG_PHASE
80 /* SetEventNotificationMode ****************************************************
82 Control the generation of events
84 *******************************************************************************/
87 SetEventNotificationMode (jvmtiEnv * env, jvmtiEventMode mode,
88 jvmtiEvent event_type, jthread event_thread, ...)
91 CHECK_PHASE(JVMTI_PHASE_ONLOAD)
92 CHECK_PHASE(JVMTI_PHASE_LIVE)
95 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
97 return JVMTI_ERROR_NONE;
101 /* GetAllThreads ***************************************************************
105 *******************************************************************************/
108 GetAllThreads (jvmtiEnv * env, jint * threads_count_ptr,
109 jthread ** threads_ptr)
112 threadobject* thread;
115 CHECK_PHASE(JVMTI_PHASE_LIVE)
118 if ((threads_count_ptr == NULL) || (threads_ptr == NULL))
119 return JVMTI_ERROR_NULL_POINTER;
121 thread = mainthreadobj;
124 thread = thread->info.prev;
125 } while (thread != mainthreadobj);
127 *threads_count_ptr = i;
129 *threads_ptr = (jthread*) heap_allocate(sizeof(jthread) * i,true,NULL);
132 memcpy(*threads_ptr[i],thread,sizeof(jthread));
133 thread = thread->info.prev;
135 } while (thread != mainthreadobj);
137 return JVMTI_ERROR_NONE;
141 /* SuspendThread ***************************************************************
145 *******************************************************************************/
148 SuspendThread (jvmtiEnv * env, jthread thread)
151 CHECK_PHASE(JVMTI_PHASE_START)
152 CHECK_PHASE(JVMTI_PHASE_LIVE)
155 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
156 return JVMTI_ERROR_NONE;
159 /* *****************************************************************************
163 *******************************************************************************/
166 ResumeThread (jvmtiEnv * env, jthread thread)
169 CHECK_PHASE(JVMTI_PHASE_START)
170 CHECK_PHASE(JVMTI_PHASE_LIVE)
173 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
174 return JVMTI_ERROR_NONE;
177 /* *****************************************************************************
181 *******************************************************************************/
184 StopThread (jvmtiEnv * env, jthread thread, jobject exception)
187 CHECK_PHASE(JVMTI_PHASE_START)
188 CHECK_PHASE(JVMTI_PHASE_LIVE)
191 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
192 return JVMTI_ERROR_NONE;
195 /* *****************************************************************************
199 *******************************************************************************/
202 InterruptThread (jvmtiEnv * env, jthread thread)
205 CHECK_PHASE(JVMTI_PHASE_START)
206 CHECK_PHASE(JVMTI_PHASE_LIVE)
209 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
210 return JVMTI_ERROR_NONE;
213 /* GetThreadInfo ***************************************************************
215 Get thread information. The fields of the jvmtiThreadInfo structure are
216 filled in with details of the specified thread.
218 *******************************************************************************/
221 GetThreadInfo (jvmtiEnv * env, jthread thread, jvmtiThreadInfo * info_ptr)
224 CHECK_PHASE(JVMTI_PHASE_LIVE)
227 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
228 return JVMTI_ERROR_NONE;
231 /* GetOwnedMonitorInfo *********************************************************
235 *******************************************************************************/
238 GetOwnedMonitorInfo (jvmtiEnv * env, jthread thread,
239 jint * owned_monitor_count_ptr,
240 jobject ** owned_monitors_ptr)
243 CHECK_PHASE(JVMTI_PHASE_START)
244 CHECK_PHASE(JVMTI_PHASE_LIVE)
247 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
248 return JVMTI_ERROR_NONE;
251 /* *****************************************************************************
255 *******************************************************************************/
258 GetCurrentContendedMonitor (jvmtiEnv * env, jthread thread,
259 jobject * monitor_ptr)
262 CHECK_PHASE(JVMTI_PHASE_START)
263 CHECK_PHASE(JVMTI_PHASE_LIVE)
266 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
267 return JVMTI_ERROR_NONE;
271 /* *****************************************************************************
275 *******************************************************************************/
278 RunAgentThread (jvmtiEnv * env, jthread thread, jvmtiStartFunction proc,
279 const void *arg, jint priority)
282 CHECK_PHASE(JVMTI_PHASE_START)
283 CHECK_PHASE(JVMTI_PHASE_LIVE)
286 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
287 return JVMTI_ERROR_NONE;
291 /* *****************************************************************************
295 *******************************************************************************/
298 GetTopThreadGroups (jvmtiEnv * env, jint * group_count_ptr,
299 jthreadGroup ** groups_ptr)
302 CHECK_PHASE(JVMTI_PHASE_START)
303 CHECK_PHASE(JVMTI_PHASE_LIVE)
306 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
307 return JVMTI_ERROR_NONE;
311 /* *****************************************************************************
315 *******************************************************************************/
318 GetThreadGroupInfo (jvmtiEnv * env, jthreadGroup group,
319 jvmtiThreadGroupInfo * info_ptr)
322 CHECK_PHASE(JVMTI_PHASE_START)
323 CHECK_PHASE(JVMTI_PHASE_LIVE)
326 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
327 return JVMTI_ERROR_NONE;
331 /* *****************************************************************************
335 *******************************************************************************/
338 GetThreadGroupChildren (jvmtiEnv * env, jthreadGroup group,
339 jint * thread_count_ptr, jthread ** threads_ptr,
340 jint * group_count_ptr, jthreadGroup ** groups_ptr)
343 CHECK_PHASE(JVMTI_PHASE_START)
344 CHECK_PHASE(JVMTI_PHASE_LIVE)
347 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
348 return JVMTI_ERROR_NONE;
352 /* *****************************************************************************
356 *******************************************************************************/
359 GetFrameCount (jvmtiEnv * env, jthread thread, jint * count_ptr)
362 CHECK_PHASE(JVMTI_PHASE_START)
363 CHECK_PHASE(JVMTI_PHASE_LIVE)
366 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
367 return JVMTI_ERROR_NONE;
371 /* GetThreadState **************************************************************
373 Get the state of a thread.
375 *******************************************************************************/
378 GetThreadState (jvmtiEnv * env, jthread thread, jint * thread_state_ptr)
381 CHECK_PHASE(JVMTI_PHASE_LIVE)
384 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
385 return JVMTI_ERROR_NONE;
389 /* *****************************************************************************
393 *******************************************************************************/
396 GetFrameLocation (jvmtiEnv * env, jthread thread, jint depth,
397 jmethodID * method_ptr, jlocation * location_ptr)
400 CHECK_PHASE(JVMTI_PHASE_START)
401 CHECK_PHASE(JVMTI_PHASE_LIVE)
404 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
405 return JVMTI_ERROR_NONE;
409 /* *****************************************************************************
413 *******************************************************************************/
416 NotifyFramePop (jvmtiEnv * env, jthread thread, jint depth)
419 CHECK_PHASE(JVMTI_PHASE_START)
420 CHECK_PHASE(JVMTI_PHASE_LIVE)
423 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
424 return JVMTI_ERROR_NONE;
427 /* *****************************************************************************
431 *******************************************************************************/
434 GetLocalObject (jvmtiEnv * env,
435 jthread thread, jint depth, jint slot, jobject * value_ptr)
438 CHECK_PHASE(JVMTI_PHASE_START)
439 CHECK_PHASE(JVMTI_PHASE_LIVE)
442 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
443 return JVMTI_ERROR_NONE;
446 /* *****************************************************************************
450 *******************************************************************************/
453 GetLocalInt (jvmtiEnv * env,
454 jthread thread, jint depth, jint slot, jint * value_ptr)
457 CHECK_PHASE(JVMTI_PHASE_START)
458 CHECK_PHASE(JVMTI_PHASE_LIVE)
461 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
462 return JVMTI_ERROR_NONE;
465 /* *****************************************************************************
469 *******************************************************************************/
472 GetLocalLong (jvmtiEnv * env, jthread thread, jint depth, jint slot,
476 CHECK_PHASE(JVMTI_PHASE_START)
477 CHECK_PHASE(JVMTI_PHASE_LIVE)
480 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
481 return JVMTI_ERROR_NONE;
485 /* *****************************************************************************
489 *******************************************************************************/
492 GetLocalFloat (jvmtiEnv * env, jthread thread, jint depth, jint slot,
496 CHECK_PHASE(JVMTI_PHASE_START)
497 CHECK_PHASE(JVMTI_PHASE_LIVE)
500 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
501 return JVMTI_ERROR_NONE;
505 /* *****************************************************************************
509 *******************************************************************************/
512 GetLocalDouble (jvmtiEnv * env, jthread thread, jint depth, jint slot,
516 CHECK_PHASE(JVMTI_PHASE_START)
517 CHECK_PHASE(JVMTI_PHASE_LIVE)
520 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
521 return JVMTI_ERROR_NONE;
525 /* *****************************************************************************
529 *******************************************************************************/
532 SetLocalObject (jvmtiEnv * env, jthread thread, jint depth, jint slot,
536 CHECK_PHASE(JVMTI_PHASE_START)
537 CHECK_PHASE(JVMTI_PHASE_LIVE)
540 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
541 return JVMTI_ERROR_NONE;
545 /* *****************************************************************************
549 *******************************************************************************/
552 SetLocalInt (jvmtiEnv * env, jthread thread, jint depth, jint slot,
556 CHECK_PHASE(JVMTI_PHASE_START)
557 CHECK_PHASE(JVMTI_PHASE_LIVE)
560 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
561 return JVMTI_ERROR_NONE;
565 /* *****************************************************************************
569 *******************************************************************************/
572 SetLocalLong (jvmtiEnv * env, jthread thread, jint depth, jint slot,
576 CHECK_PHASE(JVMTI_PHASE_START)
577 CHECK_PHASE(JVMTI_PHASE_LIVE)
580 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
581 return JVMTI_ERROR_NONE;
585 /* *****************************************************************************
589 *******************************************************************************/
592 SetLocalFloat (jvmtiEnv * env, jthread thread, jint depth, jint slot,
596 CHECK_PHASE(JVMTI_PHASE_START)
597 CHECK_PHASE(JVMTI_PHASE_LIVE)
600 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
601 return JVMTI_ERROR_NONE;
605 /* *****************************************************************************
609 *******************************************************************************/
612 SetLocalDouble (jvmtiEnv * env, jthread thread, jint depth, jint slot,
616 CHECK_PHASE(JVMTI_PHASE_START)
617 CHECK_PHASE(JVMTI_PHASE_LIVE)
620 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
621 return JVMTI_ERROR_NONE;
625 /* *****************************************************************************
629 *******************************************************************************/
632 CreateRawMonitor (jvmtiEnv * env, const char *name,
633 jrawMonitorID * monitor_ptr)
636 CHECK_PHASE(JVMTI_PHASE_START)
637 CHECK_PHASE(JVMTI_PHASE_LIVE)
640 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
641 return JVMTI_ERROR_NONE;
645 /* *****************************************************************************
649 *******************************************************************************/
652 DestroyRawMonitor (jvmtiEnv * env, jrawMonitorID monitor)
655 CHECK_PHASE(JVMTI_PHASE_START)
656 CHECK_PHASE(JVMTI_PHASE_LIVE)
659 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
660 return JVMTI_ERROR_NONE;
664 /* *****************************************************************************
668 *******************************************************************************/
671 RawMonitorEnter (jvmtiEnv * env, jrawMonitorID monitor)
674 CHECK_PHASE(JVMTI_PHASE_START)
675 CHECK_PHASE(JVMTI_PHASE_LIVE)
678 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
679 return JVMTI_ERROR_NONE;
683 /* *****************************************************************************
687 *******************************************************************************/
690 RawMonitorExit (jvmtiEnv * env, jrawMonitorID monitor)
693 CHECK_PHASE(JVMTI_PHASE_START)
694 CHECK_PHASE(JVMTI_PHASE_LIVE)
697 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
698 return JVMTI_ERROR_NONE;
702 /* *****************************************************************************
706 *******************************************************************************/
709 RawMonitorWait (jvmtiEnv * env, jrawMonitorID monitor, jlong millis)
712 CHECK_PHASE(JVMTI_PHASE_START)
713 CHECK_PHASE(JVMTI_PHASE_LIVE)
716 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
717 return JVMTI_ERROR_NONE;
721 /* *****************************************************************************
725 *******************************************************************************/
728 RawMonitorNotify (jvmtiEnv * env, jrawMonitorID monitor)
731 CHECK_PHASE(JVMTI_PHASE_START)
732 CHECK_PHASE(JVMTI_PHASE_LIVE)
735 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
736 return JVMTI_ERROR_NONE;
740 /* *****************************************************************************
744 *******************************************************************************/
747 RawMonitorNotifyAll (jvmtiEnv * env, jrawMonitorID monitor)
750 CHECK_PHASE(JVMTI_PHASE_START)
751 CHECK_PHASE(JVMTI_PHASE_LIVE)
754 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
755 return JVMTI_ERROR_NONE;
759 /* *****************************************************************************
763 *******************************************************************************/
766 SetBreakpoint (jvmtiEnv * env, jmethodID method, jlocation location)
769 CHECK_PHASE(JVMTI_PHASE_START)
770 CHECK_PHASE(JVMTI_PHASE_LIVE)
773 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
774 return JVMTI_ERROR_NONE;
778 /* *****************************************************************************
782 *******************************************************************************/
785 ClearBreakpoint (jvmtiEnv * env, jmethodID method, jlocation location)
788 CHECK_PHASE(JVMTI_PHASE_START)
789 CHECK_PHASE(JVMTI_PHASE_LIVE)
792 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
793 return JVMTI_ERROR_NONE;
797 /* *****************************************************************************
801 *******************************************************************************/
804 SetFieldAccessWatch (jvmtiEnv * env, jclass klass, jfieldID field)
807 CHECK_PHASE(JVMTI_PHASE_START)
808 CHECK_PHASE(JVMTI_PHASE_LIVE)
811 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
812 return JVMTI_ERROR_NONE;
816 /* *****************************************************************************
820 *******************************************************************************/
823 ClearFieldAccessWatch (jvmtiEnv * env, jclass klass, jfieldID field)
826 CHECK_PHASE(JVMTI_PHASE_START)
827 CHECK_PHASE(JVMTI_PHASE_LIVE)
830 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
831 return JVMTI_ERROR_NONE;
835 /* *****************************************************************************
839 *******************************************************************************/
842 SetFieldModificationWatch (jvmtiEnv * env, jclass klass, jfieldID field)
845 CHECK_PHASE(JVMTI_PHASE_START)
846 CHECK_PHASE(JVMTI_PHASE_LIVE)
849 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
850 return JVMTI_ERROR_NONE;
854 /* *****************************************************************************
858 *******************************************************************************/
861 ClearFieldModificationWatch (jvmtiEnv * env, jclass klass, jfieldID field)
864 CHECK_PHASE(JVMTI_PHASE_START)
865 CHECK_PHASE(JVMTI_PHASE_LIVE)
868 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
869 return JVMTI_ERROR_NONE;
873 /* Allocate ********************************************************************
875 Allocate an area of memory through the JVM TI allocator. The allocated
876 memory should be freed with Deallocate
878 *******************************************************************************/
881 Allocate (jvmtiEnv * env, jlong size, unsigned char **mem_ptr)
884 if (mem_ptr == NULL) return JVMTI_ERROR_NULL_POINTER;
885 if (size < 0) return JVMTI_ERROR_ILLEGAL_ARGUMENT;
887 *mem_ptr = heap_allocate(sizeof(size),true,NULL);
888 if (*mem_ptr == NULL)
889 return JVMTI_ERROR_OUT_OF_MEMORY;
891 return JVMTI_ERROR_NONE;
896 /* Deallocate ******************************************************************
898 Deallocate mem using the JVM TI allocator.
900 *******************************************************************************/
903 Deallocate (jvmtiEnv * env, unsigned char *mem)
905 /* let Boehm GC do the job */
906 return JVMTI_ERROR_NONE;
910 /* GetClassSignature ************************************************************
912 For the class indicated by klass, return the JNI type signature and the
913 generic signature of the class.
915 *******************************************************************************/
918 GetClassSignature (jvmtiEnv * env, jclass klass, char **signature_ptr,
924 CHECK_PHASE(JVMTI_PHASE_START)
925 CHECK_PHASE(JVMTI_PHASE_LIVE)
928 if ((generic_ptr== NULL)||(signature_ptr == NULL))
929 return JVMTI_ERROR_NULL_POINTER;
931 nsize=((classinfo*)klass)->name->blength;
932 psize=((classinfo*)klass)->packagename->blength;
934 *signature_ptr = (char*)
935 heap_allocate(sizeof(char)* nsize+psize+4,true,NULL);
937 *signature_ptr[0]='L';
938 memcpy(&(*signature_ptr[1]),((classinfo*)klass)->packagename->text, psize);
939 *signature_ptr[psize+2]='/';
940 memcpy(&(*signature_ptr[psize+3]),((classinfo*)klass)->name->text, nsize);
941 *signature_ptr[nsize+psize+3]=';';
942 *signature_ptr[nsize+psize+4]='\0';
946 return JVMTI_ERROR_NONE;
949 /* *****************************************************************************
953 *******************************************************************************/
956 GetClassStatus (jvmtiEnv * env, jclass klass, jint * status_ptr)
959 CHECK_PHASE(JVMTI_PHASE_START)
960 CHECK_PHASE(JVMTI_PHASE_LIVE)
963 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
964 return JVMTI_ERROR_NONE;
968 /* GetSourceFileName **********************************************************
970 For the class indicated by klass, return the source file name.
972 *******************************************************************************/
975 GetSourceFileName (jvmtiEnv * env, jclass klass, char **source_name_ptr)
980 CHECK_PHASE(JVMTI_PHASE_START)
981 CHECK_PHASE(JVMTI_PHASE_LIVE)
984 if ((klass == NULL)||(source_name_ptr == NULL))
985 return JVMTI_ERROR_NULL_POINTER;
987 size = (((classinfo*)klass)->sourcefile->blength);
989 *source_name_ptr = (char*) heap_allocate(sizeof(char)* size,true,NULL);
991 memcpy(*source_name_ptr,((classinfo*)klass)->sourcefile->text, size);
993 return JVMTI_ERROR_NONE;
997 /* *****************************************************************************
1001 *******************************************************************************/
1004 GetClassModifiers (jvmtiEnv * env, jclass klass, jint * modifiers_ptr)
1007 CHECK_PHASE(JVMTI_PHASE_START)
1008 CHECK_PHASE(JVMTI_PHASE_LIVE)
1011 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1012 return JVMTI_ERROR_NONE;
1016 /* GetClassMethods *************************************************************
1018 For the class indicated by klass, return a count of methods and a list of
1021 *******************************************************************************/
1024 GetClassMethods (jvmtiEnv * env, jclass klass, jint * method_count_ptr,
1025 jmethodID ** methods_ptr)
1028 CHECK_PHASE(JVMTI_PHASE_START)
1029 CHECK_PHASE(JVMTI_PHASE_LIVE)
1032 if ((klass == NULL)||(methods_ptr == NULL)||(method_count_ptr == NULL))
1033 return JVMTI_ERROR_NULL_POINTER;
1035 *method_count_ptr = (jint)((classinfo*)klass)->methodscount;
1036 *methods_ptr = (jmethodID*)
1037 heap_allocate(sizeof(jmethodID) * (*method_count_ptr),true,NULL);
1039 memcpy (*methods_ptr, ((classinfo*)klass)->methods,
1040 sizeof(jmethodID) * (*method_count_ptr));
1042 return JVMTI_ERROR_NONE;
1046 /* GetClassFields *************************************************************
1048 For the class indicated by klass, return a count of fields and a list of
1051 *******************************************************************************/
1054 GetClassFields (jvmtiEnv * env, jclass klass, jint * field_count_ptr,
1055 jfieldID ** fields_ptr)
1058 CHECK_PHASE(JVMTI_PHASE_START)
1059 CHECK_PHASE(JVMTI_PHASE_LIVE)
1062 if ((klass == NULL)||(fields_ptr == NULL)||(field_count_ptr == NULL))
1063 return JVMTI_ERROR_NULL_POINTER;
1065 *field_count_ptr = (jint)((classinfo*)klass)->fieldscount;
1066 *fields_ptr = (jfieldID*)
1067 heap_allocate(sizeof(jfieldID) * (*field_count_ptr),true,NULL);
1069 memcpy (*fields_ptr, ((classinfo*)klass)->fields,
1070 sizeof(jfieldID) * (*field_count_ptr));
1072 return JVMTI_ERROR_NONE;
1076 /* *****************************************************************************
1080 *******************************************************************************/
1083 GetImplementedInterfaces (jvmtiEnv * env, jclass klass,
1084 jint * interface_count_ptr,
1085 jclass ** interfaces_ptr)
1088 CHECK_PHASE(JVMTI_PHASE_START)
1089 CHECK_PHASE(JVMTI_PHASE_LIVE)
1092 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1093 return JVMTI_ERROR_NONE;
1097 /* IsInterface ****************************************************************
1099 Determines whether a class object reference represents an interface.
1101 *******************************************************************************/
1104 IsInterface (jvmtiEnv * env, jclass klass, jboolean * is_interface_ptr)
1107 CHECK_PHASE(JVMTI_PHASE_START)
1108 CHECK_PHASE(JVMTI_PHASE_LIVE)
1111 if ((klass == NULL)||(is_interface_ptr == NULL))
1112 return JVMTI_ERROR_NULL_POINTER;
1114 *is_interface_ptr = (((classinfo*)klass)->flags & ACC_INTERFACE);
1116 return JVMTI_ERROR_NONE;
1119 /* IsArrayClass ***************************************************************
1121 Determines whether a class object reference represents an array.
1123 *******************************************************************************/
1126 IsArrayClass (jvmtiEnv * env, jclass klass, jboolean * is_array_class_ptr)
1129 CHECK_PHASE(JVMTI_PHASE_START)
1130 CHECK_PHASE(JVMTI_PHASE_LIVE)
1133 if (is_array_class_ptr == NULL)
1134 return JVMTI_ERROR_NULL_POINTER;
1136 *is_array_class_ptr = ((classinfo*)klass)->name->text[0] == '[';
1138 return JVMTI_ERROR_NONE;
1142 /* GetClassLoader *************************************************************
1144 For the class indicated by klass, return via classloader_ptr a reference to
1145 the class loader for the class.
1147 *******************************************************************************/
1150 GetClassLoader (jvmtiEnv * env, jclass klass, jobject * classloader_ptr)
1153 CHECK_PHASE(JVMTI_PHASE_START)
1154 CHECK_PHASE(JVMTI_PHASE_LIVE)
1157 if ((klass == NULL)||(classloader_ptr == NULL))
1158 return JVMTI_ERROR_NULL_POINTER;
1160 *classloader_ptr = (jobject)((classinfo*)klass)->classloader;
1162 return JVMTI_ERROR_NONE;
1166 /* *****************************************************************************
1170 *******************************************************************************/
1173 GetObjectHashCode (jvmtiEnv * env, jobject object, jint * hash_code_ptr)
1176 CHECK_PHASE(JVMTI_PHASE_START)
1177 CHECK_PHASE(JVMTI_PHASE_LIVE)
1180 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1181 return JVMTI_ERROR_NONE;
1185 /* *****************************************************************************
1189 *******************************************************************************/
1192 GetObjectMonitorUsage (jvmtiEnv * env, jobject object,
1193 jvmtiMonitorUsage * info_ptr)
1196 CHECK_PHASE(JVMTI_PHASE_START)
1197 CHECK_PHASE(JVMTI_PHASE_LIVE)
1200 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1201 return JVMTI_ERROR_NONE;
1205 /* GetFieldName ***************************************************************
1207 For the field indicated by klass and field, return the field name and
1210 *******************************************************************************/
1213 GetFieldName (jvmtiEnv * env, jclass klass, jfieldID field,
1214 char **name_ptr, char **signature_ptr, char **generic_ptr)
1219 CHECK_PHASE(JVMTI_PHASE_START)
1220 CHECK_PHASE(JVMTI_PHASE_LIVE)
1223 if ((field == NULL)||(name_ptr == NULL)||(signature_ptr == NULL))
1224 return JVMTI_ERROR_NULL_POINTER;
1226 size = (((fieldinfo*)field)->name->blength);
1227 *name_ptr = (char*) heap_allocate(sizeof(char)* size,true,NULL);
1228 memcpy(*name_ptr,((fieldinfo*)field)->name->text, size);
1230 size = (((fieldinfo*)field)->descriptor->blength);
1231 *signature_ptr = (char*) heap_allocate(sizeof(char)* size,true,NULL);
1232 memcpy(*signature_ptr,((fieldinfo*)field)->descriptor->text, size);
1234 *generic_ptr = NULL;
1236 return JVMTI_ERROR_NONE;
1240 /* GetFieldDeclaringClass *****************************************************
1242 For the field indicated by klass and field return the class that defined it
1243 The declaring class will either be klass, a superclass, or an implemented
1246 *******************************************************************************/
1249 GetFieldDeclaringClass (jvmtiEnv * env, jclass klass, jfieldID field,
1250 jclass * declaring_class_ptr)
1253 CHECK_PHASE(JVMTI_PHASE_START)
1254 CHECK_PHASE(JVMTI_PHASE_LIVE)
1257 /* todo: find declaring class */
1259 return JVMTI_ERROR_NONE;
1263 /* *****************************************************************************
1267 *******************************************************************************/
1270 GetFieldModifiers (jvmtiEnv * env, jclass klass, jfieldID field,
1271 jint * modifiers_ptr)
1274 CHECK_PHASE(JVMTI_PHASE_START)
1275 CHECK_PHASE(JVMTI_PHASE_LIVE)
1278 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1279 return JVMTI_ERROR_NONE;
1283 /* *****************************************************************************
1287 *******************************************************************************/
1290 IsFieldSynthetic (jvmtiEnv * env, jclass klass, jfieldID field,
1291 jboolean * is_synthetic_ptr)
1294 CHECK_PHASE(JVMTI_PHASE_START)
1295 CHECK_PHASE(JVMTI_PHASE_LIVE)
1298 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1299 return JVMTI_ERROR_NONE;
1303 /* GetMethodName ***************************************************************
1305 For the method indicated by method, return the method name via name_ptr and
1306 method signature via signature_ptr.
1308 *******************************************************************************/
1311 GetMethodName (jvmtiEnv * env, jmethodID method, char **name_ptr,
1312 char **signature_ptr, char **generic_ptr)
1314 methodinfo* m = (methodinfo*)method;
1317 CHECK_PHASE(JVMTI_PHASE_START)
1318 CHECK_PHASE(JVMTI_PHASE_LIVE)
1321 if ((method == NULL) || (name_ptr == NULL) || (signature_ptr == NULL)
1322 || (generic_ptr == NULL)) return JVMTI_ERROR_NULL_POINTER;
1324 *name_ptr = (char*)heap_allocate(m->name->blength,true,NULL);
1325 memcpy(*name_ptr, m->name->text, m->name->blength);
1327 *signature_ptr = (char*)heap_allocate(m->descriptor->blength,true,NULL);
1328 memcpy(*signature_ptr, m->descriptor->text, m->descriptor->blength);
1330 /* there is no generic signature attribute */
1331 *generic_ptr = NULL;
1333 return JVMTI_ERROR_NONE;
1337 /* GetMethodDeclaringClass *****************************************************
1339 For the method indicated by method, return the class that defined it.
1341 *******************************************************************************/
1344 GetMethodDeclaringClass (jvmtiEnv * env, jmethodID method,
1345 jclass * declaring_class_ptr)
1348 CHECK_PHASE(JVMTI_PHASE_START)
1349 CHECK_PHASE(JVMTI_PHASE_LIVE)
1352 if ((method == NULL) || (declaring_class_ptr == NULL))
1353 return JVMTI_ERROR_NULL_POINTER;
1355 *declaring_class_ptr = (jclass)((methodinfo*)method)->class;
1357 return JVMTI_ERROR_NONE;
1361 /* GetMethodModifiers **********************************************************
1363 For the method indicated by method, return the access flags.
1365 *******************************************************************************/
1368 GetMethodModifiers (jvmtiEnv * env, jmethodID method, jint * modifiers_ptr)
1371 CHECK_PHASE(JVMTI_PHASE_START)
1372 CHECK_PHASE(JVMTI_PHASE_LIVE)
1375 if ((method == NULL) || (modifiers_ptr == NULL))
1376 return JVMTI_ERROR_NULL_POINTER;
1378 *modifiers_ptr = (jint) (((methodinfo*)method)->flags);
1380 return JVMTI_ERROR_NONE;
1384 /* GetMaxLocals ****************************************************************
1386 For the method indicated by method, return the number of local variable slots
1387 used by the method, including the local variables used to pass parameters to
1388 the method on its invocation.
1390 *******************************************************************************/
1393 GetMaxLocals (jvmtiEnv * env, jmethodID method, jint * max_ptr)
1396 CHECK_PHASE(JVMTI_PHASE_START)
1397 CHECK_PHASE(JVMTI_PHASE_LIVE)
1400 if ((method == NULL)||(max_ptr == NULL))
1401 return JVMTI_ERROR_NULL_POINTER;
1403 if (((methodinfo*)method)->flags & ACC_NATIVE)
1404 return JVMTI_ERROR_NATIVE_METHOD;
1406 *max_ptr = (jint) ((methodinfo*)method)->maxlocals;
1408 return JVMTI_ERROR_NONE;
1413 /* GetArgumentsSize ************************************************************
1415 Return the number of local variable slots used by the method's arguments.
1417 *******************************************************************************/
1420 GetArgumentsSize (jvmtiEnv * env, jmethodID method, jint * size_ptr)
1423 CHECK_PHASE(JVMTI_PHASE_START)
1424 CHECK_PHASE(JVMTI_PHASE_LIVE)
1427 if ((method == NULL)||(size_ptr == NULL))
1428 return JVMTI_ERROR_NULL_POINTER;
1430 if (((methodinfo*)method)->flags & ACC_NATIVE)
1431 return JVMTI_ERROR_NATIVE_METHOD;
1433 *size_ptr = (jint)((methodinfo*)method)->paramcount;
1434 return JVMTI_ERROR_NONE;
1439 /* GetLineNumberTable ***********************************************************
1441 For the method indicated by method, return a table of source line number
1444 *******************************************************************************/
1447 GetLineNumberTable (jvmtiEnv * env, jmethodID method,
1448 jint * entry_count_ptr, jvmtiLineNumberEntry ** table_ptr)
1453 CHECK_PHASE(JVMTI_PHASE_START)
1454 CHECK_PHASE(JVMTI_PHASE_LIVE)
1457 if ((method == NULL) || (entry_count_ptr == NULL) || (table_ptr == NULL))
1458 return JVMTI_ERROR_NULL_POINTER;
1459 if (((methodinfo*)method)->flags & ACC_NATIVE)
1460 return JVMTI_ERROR_NATIVE_METHOD;
1461 if (((methodinfo*)method)->linenumbers == NULL)
1462 return JVMTI_ERROR_ABSENT_INFORMATION;
1464 *entry_count_ptr= (jint)((methodinfo*)method)->linenumbercount;
1465 *table_ptr = (jvmtiLineNumberEntry*) heap_allocate(
1466 sizeof(jvmtiLineNumberEntry) * (*entry_count_ptr),true,NULL);
1469 for (i=0; i < *entry_count_ptr; i++) {
1470 (*table_ptr[i]).start_location =
1471 (jlocation) method->linenumbers[i].start_pc;
1472 (*table_ptr[i]).line_number =
1473 (jint) ((methodinfo*)method)->linenumbers[i].line_number;
1476 return JVMTI_ERROR_NONE;
1480 /* GetMethodLocation ***********************************************************
1482 For the method indicated by method, return the beginning and ending addresses
1483 through start_location_ptr and end_location_ptr. In cacao this points to
1484 entry point in machine code and length of machine code
1486 *******************************************************************************/
1489 GetMethodLocation (jvmtiEnv * env, jmethodID method,
1490 jlocation * start_location_ptr,
1491 jlocation * end_location_ptr)
1493 methodinfo* m = (methodinfo*)method;
1496 CHECK_PHASE(JVMTI_PHASE_START)
1497 CHECK_PHASE(JVMTI_PHASE_LIVE)
1500 if ((method == NULL) || (start_location_ptr == NULL) ||
1501 (end_location_ptr == NULL)) return JVMTI_ERROR_NULL_POINTER;
1503 *start_location_ptr = (jlocation)m->mcode;
1504 *end_location_ptr = (jlocation)(m->mcode)+m->mcodelength;
1505 return JVMTI_ERROR_NONE;
1509 /* GetLocalVariableTable *******************************************************
1511 Return local variable information.
1513 *******************************************************************************/
1516 GetLocalVariableTable (jvmtiEnv * env, jmethodID method,
1517 jint * entry_count_ptr,
1518 jvmtiLocalVariableEntry ** table_ptr)
1521 CHECK_PHASE(JVMTI_PHASE_LIVE)
1524 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1526 return JVMTI_ERROR_NONE;
1530 /* GetBytecode *****************************************************************
1532 For the method indicated by method, return the byte codes that implement the
1535 *******************************************************************************/
1538 GetBytecodes (jvmtiEnv * env, jmethodID method,
1539 jint * bytecode_count_ptr, unsigned char **bytecodes_ptr)
1541 methodinfo* m = (methodinfo*)method;;
1544 CHECK_PHASE(JVMTI_PHASE_START)
1545 CHECK_PHASE(JVMTI_PHASE_LIVE)
1548 if ((method == NULL) || (bytecode_count_ptr == NULL) ||
1549 (bytecodes_ptr == NULL)) return JVMTI_ERROR_NULL_POINTER;
1551 *bytecode_count_ptr = m->jcodelength;
1552 *bytecodes_ptr = (unsigned char*)heap_allocate(m->jcodelength,true,NULL);
1553 memcpy(*bytecodes_ptr, m->jcode, m->jcodelength);
1555 return JVMTI_ERROR_NONE;
1559 /* IsMethodNative **************************************************************
1561 For the method indicated by method, return a value indicating whether the
1562 method is a native function
1564 *******************************************************************************/
1567 IsMethodNative (jvmtiEnv * env, jmethodID method, jboolean * is_native_ptr)
1570 CHECK_PHASE(JVMTI_PHASE_START)
1571 CHECK_PHASE(JVMTI_PHASE_LIVE)
1574 if ((method == NULL)||(is_native_ptr == NULL))
1575 return JVMTI_ERROR_NULL_POINTER;
1577 if (((methodinfo*)method)->flags & ACC_NATIVE)
1578 *is_native_ptr = JNI_TRUE;
1580 *is_native_ptr = JNI_FALSE;
1582 return JVMTI_ERROR_NONE;
1586 /* IsMethodSynthetic ***********************************************************
1588 return a value indicating whether the method is synthetic. Synthetic methods
1589 are generated by the compiler but not present in the original source code.
1591 *******************************************************************************/
1594 IsMethodSynthetic (jvmtiEnv * env, jmethodID method,
1595 jboolean * is_synthetic_ptr)
1598 CHECK_PHASE(JVMTI_PHASE_START)
1599 CHECK_PHASE(JVMTI_PHASE_LIVE)
1602 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1603 return JVMTI_ERROR_NONE;
1607 /* GetLoadedClasses ************************************************************
1609 Return an array of all classes loaded in the virtual machine.
1611 *******************************************************************************/
1614 GetLoadedClasses (jvmtiEnv * env, jint * class_count_ptr,
1615 jclass ** classes_ptr)
1618 CHECK_PHASE(JVMTI_PHASE_LIVE)
1621 if (class_count_ptr == NULL) return JVMTI_ERROR_NULL_POINTER;
1622 if (classes_ptr == NULL) return JVMTI_ERROR_NULL_POINTER;
1623 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1624 return JVMTI_ERROR_NONE;
1628 /* GetClassLoaderClasses *******************************************************
1630 Returns an array of those classes for which this class loader has been
1631 recorded as an initiating loader.
1633 *******************************************************************************/
1636 GetClassLoaderClasses (jvmtiEnv * env, jobject initiating_loader,
1637 jint * class_count_ptr, jclass ** classes_ptr)
1640 CHECK_PHASE(JVMTI_PHASE_LIVE)
1643 if (class_count_ptr == NULL) return JVMTI_ERROR_NULL_POINTER;
1644 if (classes_ptr == NULL) return JVMTI_ERROR_NULL_POINTER;
1646 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1647 return JVMTI_ERROR_NONE;
1651 /* *****************************************************************************
1655 *******************************************************************************/
1658 PopFrame (jvmtiEnv * env, jthread thread)
1661 CHECK_PHASE(JVMTI_PHASE_START)
1662 CHECK_PHASE(JVMTI_PHASE_LIVE)
1665 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1666 return JVMTI_ERROR_NONE;
1670 /* *****************************************************************************
1674 *******************************************************************************/
1677 RedefineClasses (jvmtiEnv * env, jint class_count,
1678 const jvmtiClassDefinition * class_definitions)
1681 CHECK_PHASE(JVMTI_PHASE_START)
1682 CHECK_PHASE(JVMTI_PHASE_LIVE)
1685 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1686 return JVMTI_ERROR_NONE;
1690 /* GetVersionNumber ***********************************************************
1692 Return the JVM TI version identifier.
1694 *******************************************************************************/
1697 GetVersionNumber (jvmtiEnv * env, jint * version_ptr)
1699 if (version_ptr == NULL) return JVMTI_ERROR_NULL_POINTER;
1701 *version_ptr = JVMTI_VERSION_1_0;
1703 return JVMTI_ERROR_NONE;
1707 /* GetCapabilities ************************************************************
1709 Returns via capabilities_ptr the optional JVM TI features which this
1710 environment currently possesses.
1712 *******************************************************************************/
1715 GetCapabilities (jvmtiEnv * env, jvmtiCapabilities * capabilities_ptr)
1717 if (capabilities_ptr == NULL) return JVMTI_ERROR_NULL_POINTER;
1719 memcpy(capabilities_ptr, &(((environment*) env)->capabilities), sizeof(JVMTI_Capabilities));
1721 return JVMTI_ERROR_NONE;
1725 /* *****************************************************************************
1729 *******************************************************************************/
1732 GetSourceDebugExtension (jvmtiEnv * env, jclass klass,
1733 char **source_debug_extension_ptr)
1736 CHECK_PHASE(JVMTI_PHASE_START)
1737 CHECK_PHASE(JVMTI_PHASE_LIVE)
1740 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1741 return JVMTI_ERROR_NONE;
1745 /* IsMethodObsolete ************************************************************
1747 Determine if a method ID refers to an obsolete method version.
1749 *******************************************************************************/
1752 IsMethodObsolete (jvmtiEnv * env, jmethodID method,
1753 jboolean * is_obsolete_ptr)
1756 CHECK_PHASE(JVMTI_PHASE_START)
1757 CHECK_PHASE(JVMTI_PHASE_LIVE)
1760 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1761 return JVMTI_ERROR_NONE;
1765 /* *****************************************************************************
1769 *******************************************************************************/
1772 SuspendThreadList (jvmtiEnv * env, jint request_count,
1773 const jthread * request_list, jvmtiError * results)
1776 CHECK_PHASE(JVMTI_PHASE_START)
1777 CHECK_PHASE(JVMTI_PHASE_LIVE)
1780 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1781 return JVMTI_ERROR_NONE;
1785 /* *****************************************************************************
1789 *******************************************************************************/
1792 ResumeThreadList (jvmtiEnv * env, jint request_count,
1793 const jthread * request_list, jvmtiError * results)
1796 CHECK_PHASE(JVMTI_PHASE_START)
1797 CHECK_PHASE(JVMTI_PHASE_LIVE)
1800 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1801 return JVMTI_ERROR_NONE;
1805 /* *****************************************************************************
1809 *******************************************************************************/
1812 GetAllStackTraces (jvmtiEnv * env, jint max_frame_count,
1813 jvmtiStackInfo ** stack_info_ptr, jint * thread_count_ptr)
1816 CHECK_PHASE(JVMTI_PHASE_START)
1817 CHECK_PHASE(JVMTI_PHASE_LIVE)
1820 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1821 return JVMTI_ERROR_NONE;
1825 /* *****************************************************************************
1829 *******************************************************************************/
1832 GetThreadListStackTraces (jvmtiEnv * env, jint thread_count,
1833 const jthread * thread_list,
1834 jint max_frame_count,
1835 jvmtiStackInfo ** stack_info_ptr)
1838 CHECK_PHASE(JVMTI_PHASE_START)
1839 CHECK_PHASE(JVMTI_PHASE_LIVE)
1842 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1843 return JVMTI_ERROR_NONE;
1847 /* *****************************************************************************
1851 *******************************************************************************/
1854 GetThreadLocalStorage (jvmtiEnv * env, jthread thread, void **data_ptr)
1857 CHECK_PHASE(JVMTI_PHASE_START)
1858 CHECK_PHASE(JVMTI_PHASE_LIVE)
1861 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1862 return JVMTI_ERROR_NONE;
1866 /* *****************************************************************************
1870 *******************************************************************************/
1873 SetThreadLocalStorage (jvmtiEnv * env, jthread thread, const void *data)
1876 CHECK_PHASE(JVMTI_PHASE_START)
1877 CHECK_PHASE(JVMTI_PHASE_LIVE)
1880 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1881 return JVMTI_ERROR_NONE;
1885 /* *****************************************************************************
1889 *******************************************************************************/
1892 GetStackTrace (jvmtiEnv * env, jthread thread, jint start_depth,
1893 jint max_frame_count, jvmtiFrameInfo * frame_buffer,
1897 CHECK_PHASE(JVMTI_PHASE_START)
1898 CHECK_PHASE(JVMTI_PHASE_LIVE)
1901 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1902 return JVMTI_ERROR_NONE;
1905 /* *****************************************************************************
1909 *******************************************************************************/
1912 GetTag (jvmtiEnv * env, jobject object, jlong * tag_ptr)
1915 CHECK_PHASE(JVMTI_PHASE_START)
1916 CHECK_PHASE(JVMTI_PHASE_LIVE)
1919 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1920 return JVMTI_ERROR_NONE;
1923 /* *****************************************************************************
1927 *******************************************************************************/
1930 SetTag (jvmtiEnv * env, jobject object, jlong tag)
1933 CHECK_PHASE(JVMTI_PHASE_START)
1934 CHECK_PHASE(JVMTI_PHASE_LIVE)
1937 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1938 return JVMTI_ERROR_NONE;
1942 /* *****************************************************************************
1946 *******************************************************************************/
1949 ForceGarbageCollection (jvmtiEnv * env)
1952 CHECK_PHASE(JVMTI_PHASE_START)
1953 CHECK_PHASE(JVMTI_PHASE_LIVE)
1956 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1957 return JVMTI_ERROR_NONE;
1961 /* *****************************************************************************
1965 *******************************************************************************/
1968 IterateOverObjectsReachableFromObject (jvmtiEnv * env, jobject object,
1969 jvmtiObjectReferenceCallback
1970 object_reference_callback,
1974 CHECK_PHASE(JVMTI_PHASE_START)
1975 CHECK_PHASE(JVMTI_PHASE_LIVE)
1978 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1979 return JVMTI_ERROR_NONE;
1983 /* *****************************************************************************
1987 *******************************************************************************/
1990 IterateOverReachableObjects (jvmtiEnv * env, jvmtiHeapRootCallback
1992 jvmtiStackReferenceCallback
1994 jvmtiObjectReferenceCallback
1995 object_ref_callback, void *user_data)
1998 CHECK_PHASE(JVMTI_PHASE_START)
1999 CHECK_PHASE(JVMTI_PHASE_LIVE)
2002 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
2003 return JVMTI_ERROR_NONE;
2007 /* *****************************************************************************
2011 *******************************************************************************/
2014 IterateOverHeap (jvmtiEnv * env, jvmtiHeapObjectFilter object_filter,
2015 jvmtiHeapObjectCallback heap_object_callback,
2019 CHECK_PHASE(JVMTI_PHASE_START)
2020 CHECK_PHASE(JVMTI_PHASE_LIVE)
2023 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
2024 return JVMTI_ERROR_NONE;
2028 /* *****************************************************************************
2032 *******************************************************************************/
2035 IterateOverInstancesOfClass (jvmtiEnv * env, jclass klass,
2036 jvmtiHeapObjectFilter object_filter,
2037 jvmtiHeapObjectCallback
2038 heap_object_callback, void *user_data)
2041 CHECK_PHASE(JVMTI_PHASE_START)
2042 CHECK_PHASE(JVMTI_PHASE_LIVE)
2045 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
2046 return JVMTI_ERROR_NONE;
2050 /* *****************************************************************************
2054 *******************************************************************************/
2057 GetObjectsWithTags (jvmtiEnv * env, jint tag_count, const jlong * tags,
2058 jint * count_ptr, jobject ** object_result_ptr,
2059 jlong ** tag_result_ptr)
2062 CHECK_PHASE(JVMTI_PHASE_START)
2063 CHECK_PHASE(JVMTI_PHASE_LIVE)
2066 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
2067 return JVMTI_ERROR_NONE;
2071 /* SetJNIFunctionTable **********************************************************
2073 Set the JNI function table in all current and future JNI environments
2075 *******************************************************************************/
2078 SetJNIFunctionTable (jvmtiEnv * env,
2079 const jniNativeInterface * function_table)
2082 CHECK_PHASE(JVMTI_PHASE_START)
2083 CHECK_PHASE(JVMTI_PHASE_LIVE)
2086 if (function_table == NULL) return JVMTI_ERROR_NULL_POINTER;
2087 ptr_env = (void*)heap_allocate(sizeof(jniNativeInterface),true,NULL);
2088 memcpy(ptr_env, function_table, sizeof(jniNativeInterface));
2089 return JVMTI_ERROR_NONE;
2093 /* GetJNIFunctionTable *********************************************************
2095 Get the JNI function table. The JNI function table is copied into allocated
2098 *******************************************************************************/
2101 GetJNIFunctionTable (jvmtiEnv * env, jniNativeInterface ** function_table)
2104 CHECK_PHASE(JVMTI_PHASE_START)
2105 CHECK_PHASE(JVMTI_PHASE_LIVE)
2108 if (function_table == NULL) return JVMTI_ERROR_NULL_POINTER;
2109 *function_table = (jniNativeInterface*)
2110 heap_allocate(sizeof(jniNativeInterface),true,NULL);
2111 memcpy(*function_table, ptr_env, sizeof(jniNativeInterface));
2112 return JVMTI_ERROR_NONE;
2116 /* SetEventCallbacks **********************************************************
2118 Set the functions to be called for each event. The callbacks are specified
2119 by supplying a replacement function table.
2121 *******************************************************************************/
2124 SetEventCallbacks (jvmtiEnv * env,
2125 const jvmtiEventCallbacks * callbacks,
2126 jint size_of_callbacks)
2129 CHECK_PHASE(JVMTI_PHASE_ONLOAD)
2130 CHECK_PHASE(JVMTI_PHASE_LIVE)
2133 if (size_of_callbacks < 0) return JVMTI_ERROR_ILLEGAL_ARGUMENT;
2135 if (callbacks == NULL) { /* remove the existing callbacks */
2136 memset(&(((environment* )env)->callbacks), 0, sizeof(jvmtiEventCallbacks));
2139 memcpy (&(((environment* )env)->callbacks),callbacks,size_of_callbacks);
2141 return JVMTI_ERROR_NONE;
2145 /* *****************************************************************************
2149 *******************************************************************************/
2152 GenerateEvents (jvmtiEnv * env, jvmtiEvent event_type)
2155 CHECK_PHASE(JVMTI_PHASE_START)
2156 CHECK_PHASE(JVMTI_PHASE_LIVE)
2159 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
2160 return JVMTI_ERROR_NONE;
2164 /* GetExtensionFunctions ******************************************************
2166 Returns the set of extension functions.
2168 *******************************************************************************/
2171 GetExtensionFunctions (jvmtiEnv * env, jint * extension_count_ptr,
2172 jvmtiExtensionFunctionInfo ** extensions)
2175 CHECK_PHASE(JVMTI_PHASE_ONLOAD)
2176 CHECK_PHASE(JVMTI_PHASE_LIVE)
2179 if ((extension_count_ptr== NULL)||(extensions == NULL))
2180 return JVMTI_ERROR_NULL_POINTER;
2182 /* cacao has no extended functions yet */
2183 *extension_count_ptr = 0;
2185 return JVMTI_ERROR_NONE;
2189 /* GetExtensionEvents *********************************************************
2191 Returns the set of extension events.
2193 *******************************************************************************/
2196 GetExtensionEvents (jvmtiEnv * env, jint * extension_count_ptr,
2197 jvmtiExtensionEventInfo ** extensions)
2200 CHECK_PHASE(JVMTI_PHASE_ONLOAD)
2201 CHECK_PHASE(JVMTI_PHASE_LIVE)
2204 if ((extension_count_ptr== NULL)||(extensions == NULL))
2205 return JVMTI_ERROR_NULL_POINTER;
2207 /* cacao has no extended events yet */
2208 *extension_count_ptr = 0;
2210 return JVMTI_ERROR_NONE;
2214 /* SetExtensionEventCallback **************************************************
2216 Sets the callback function for an extension event and enables the event.
2218 *******************************************************************************/
2221 SetExtensionEventCallback (jvmtiEnv * env, jint extension_event_index,
2222 jvmtiExtensionEvent callback)
2225 CHECK_PHASE(JVMTI_PHASE_ONLOAD)
2226 CHECK_PHASE(JVMTI_PHASE_LIVE)
2229 /* cacao has no extended events yet */
2230 return JVMTI_ERROR_ILLEGAL_ARGUMENT;
2234 /* DisposeEnvironment **********************************************************
2236 Shutdown a JVM TI connection created with JNI GetEnv.
2238 *******************************************************************************/
2241 DisposeEnvironment (jvmtiEnv * env)
2243 ((environment* )env)->events = NULL;
2244 ((environment* )env)->EnvironmentLocalStorage = NULL;
2245 /* let Boehm GC do the rest */
2246 return JVMTI_ERROR_NONE;
2250 /* GetErrorName ***************************************************************
2252 Return the symbolic name for an error code.
2254 *******************************************************************************/
2256 #define COPY_RESPONSE(name_ptr,str) *name_ptr = (char*) heap_allocate(sizeof(str),true,NULL); \
2257 memcpy(*name_ptr, &str, sizeof(str)); \
2261 GetErrorName (jvmtiEnv * env, jvmtiError error, char **name_ptr)
2263 if (name_ptr == NULL) return JVMTI_ERROR_NULL_POINTER;
2266 case JVMTI_ERROR_NONE :
2267 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_NONE");
2268 case JVMTI_ERROR_NULL_POINTER :
2269 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_NULL_POINTER");
2270 case JVMTI_ERROR_OUT_OF_MEMORY :
2271 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_OUT_OF_MEMORY");
2272 case JVMTI_ERROR_ACCESS_DENIED :
2273 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_ACCESS_DENIED");
2274 case JVMTI_ERROR_UNATTACHED_THREAD :
2275 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_UNATTACHED_THREAD");
2276 case JVMTI_ERROR_INVALID_ENVIRONMENT :
2277 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_INVALID_ENVIRONMENT");
2278 case JVMTI_ERROR_WRONG_PHASE :
2279 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_WRONG_PHASE");
2280 case JVMTI_ERROR_INTERNAL :
2281 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_INTERNAL");
2282 case JVMTI_ERROR_INVALID_PRIORITY :
2283 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_INVALID_PRIORITY");
2284 case JVMTI_ERROR_THREAD_NOT_SUSPENDED :
2285 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_THREAD_NOT_SUSPENDED");
2286 case JVMTI_ERROR_THREAD_SUSPENDED :
2287 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_THREAD_SUSPENDED");
2288 case JVMTI_ERROR_THREAD_NOT_ALIVE :
2289 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_THREAD_NOT_ALIVE");
2290 case JVMTI_ERROR_CLASS_NOT_PREPARED :
2291 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_CLASS_NOT_PREPARED");
2292 case JVMTI_ERROR_NO_MORE_FRAMES :
2293 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_NO_MORE_FRAMES");
2294 case JVMTI_ERROR_OPAQUE_FRAME :
2295 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_OPAQUE_FRAME");
2296 case JVMTI_ERROR_DUPLICATE :
2297 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_DUPLICATE");
2298 case JVMTI_ERROR_NOT_FOUND :
2299 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_NOT_FOUND");
2300 case JVMTI_ERROR_NOT_MONITOR_OWNER :
2301 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_NOT_MONITOR_OWNER");
2302 case JVMTI_ERROR_INTERRUPT :
2303 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_INTERRUPT");
2304 case JVMTI_ERROR_UNMODIFIABLE_CLASS :
2305 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_UNMODIFIABLE_CLASS");
2306 case JVMTI_ERROR_NOT_AVAILABLE :
2307 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_NOT_AVAILABLE");
2308 case JVMTI_ERROR_ABSENT_INFORMATION :
2309 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_ABSENT_INFORMATION");
2310 case JVMTI_ERROR_INVALID_EVENT_TYPE :
2311 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_INVALID_EVENT_TYPE");
2312 case JVMTI_ERROR_NATIVE_METHOD :
2313 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_NATIVE_METHOD");
2314 case JVMTI_ERROR_INVALID_THREAD :
2315 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_INVALID_THREAD");
2316 case JVMTI_ERROR_INVALID_FIELDID :
2317 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_INVALID_FIELDID");
2318 case JVMTI_ERROR_INVALID_METHODID :
2319 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_INVALID_METHODID");
2320 case JVMTI_ERROR_INVALID_LOCATION :
2321 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_INVALID_LOCATION");
2322 case JVMTI_ERROR_INVALID_OBJECT :
2323 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_INVALID_OBJECT");
2324 case JVMTI_ERROR_INVALID_CLASS :
2325 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_INVALID_CLASS");
2326 case JVMTI_ERROR_TYPE_MISMATCH :
2327 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_TYPE_MISMATCH");
2328 case JVMTI_ERROR_INVALID_SLOT :
2329 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_INVALID_SLOT");
2330 case JVMTI_ERROR_MUST_POSSESS_CAPABILITY :
2331 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_MUST_POSSESS_CAPABILITY");
2332 case JVMTI_ERROR_INVALID_THREAD_GROUP :
2333 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_INVALID_THREAD_GROUP");
2334 case JVMTI_ERROR_INVALID_MONITOR :
2335 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_INVALID_MONITOR");
2336 case JVMTI_ERROR_ILLEGAL_ARGUMENT :
2337 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_ILLEGAL_ARGUMENT");
2338 case JVMTI_ERROR_INVALID_TYPESTATE :
2339 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_INVALID_TYPESTATE");
2340 case JVMTI_ERROR_UNSUPPORTED_VERSION :
2341 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_UNSUPPORTED_VERSION");
2342 case JVMTI_ERROR_INVALID_CLASS_FORMAT :
2343 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_INVALID_CLASS_FORMAT");
2344 case JVMTI_ERROR_CIRCULAR_CLASS_DEFINITION :
2345 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_CIRCULAR_CLASS_DEFINITION");
2346 case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_ADDED :
2347 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_ADDED");
2348 case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED :
2349 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED");
2350 case JVMTI_ERROR_FAILS_VERIFICATION :
2351 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_FAILS_VERIFICATION");
2352 case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_HIERARCHY_CHANGED :
2353 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_UNSUPPORTED_REDEFINITION_HIERARCHY_CHANGED");
2354 case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_DELETED :
2355 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_DELETED");
2356 case JVMTI_ERROR_NAMES_DONT_MATCH :
2357 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_NAMES_DONT_MATCH");
2358 case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_MODIFIERS_CHANGED :
2359 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_MODIFIERS_CHANGED");
2360 case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_MODIFIERS_CHANGED :
2361 COPY_RESPONSE (name_ptr, "JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_MODIFIERS_CHANGED");
2363 return JVMTI_ERROR_ILLEGAL_ARGUMENT;
2365 return JVMTI_ERROR_NONE;
2368 /* GetJLocationFormat **********************************************************
2370 This function describes the representation of jlocation used in this VM.
2372 *******************************************************************************/
2375 GetJLocationFormat (jvmtiEnv * env, jvmtiJlocationFormat * format_ptr)
2377 *format_ptr = JVMTI_JLOCATION_MACHINEPC;
2378 return JVMTI_ERROR_NONE;
2382 /* GetSystemProperties ********************************************************
2384 The list of VM system property keys which may be used with GetSystemProperty
2387 *******************************************************************************/
2390 GetSystemProperties (jvmtiEnv * env, jint * count_ptr, char ***property_ptr)
2394 classinfo *sysclass, *propclass, *enumclass;
2395 java_objectheader *sysprop, *keys, *obj;
2400 CHECK_PHASE(JVMTI_PHASE_ONLOAD)
2401 CHECK_PHASE(JVMTI_PHASE_LIVE)
2404 if ((count_ptr == NULL) || (property_ptr == NULL))
2405 return JVMTI_ERROR_NULL_POINTER;
2407 sysclass = load_class_from_sysloader(
2408 utf_new_char_classname ("java/lang/System"));
2410 if (!sysclass) throw_main_exception_exit();
2412 mid = class_resolvemethod(sysclass,
2413 utf_new_char("getProperties"),
2414 utf_new_char("()Ljava/util/Properties;"));
2415 if (!mid) throw_main_exception_exit();
2418 sysprop = asm_calljavafunction(mid, sysclass, NULL, NULL, NULL);
2419 if (!sysprop) throw_main_exception_exit();
2421 propclass = sysprop->vftbl->class;
2423 mid = class_resolvemethod(propclass,
2424 utf_new_char("size"),
2425 utf_new_char("()I"));
2426 if (!mid) throw_main_exception_exit();
2429 JNI_JNIEnvTable.CallIntMethod(NULL, sysprop, mid);
2430 *property_ptr = heap_allocate(sizeof(char*) * (*count_ptr) ,true,NULL);
2432 mid = class_resolvemethod(propclass,
2433 utf_new_char("keys"),
2434 utf_new_char("()Ljava/util/Enumeration;"));
2435 if (!mid) throw_main_exception_exit();
2437 keys = JNI_JNIEnvTable.CallObjectMethod(NULL, sysprop, mid);
2438 enumclass = keys->vftbl->class;
2440 moremid = class_resolvemethod(enumclass,
2441 utf_new_char("hasMoreElements"),
2442 utf_new_char("()Z"));
2443 if (!moremid) throw_main_exception_exit();
2445 mid = class_resolvemethod(propclass,
2446 utf_new_char("nextElement"),
2447 utf_new_char("()Ljava/lang/Object;"));
2448 if (!mid) throw_main_exception_exit();
2451 while (JNI_JNIEnvTable.CallBooleanMethod(NULL,keys,(jmethodID)moremid)) {
2452 obj = JNI_JNIEnvTable.CallObjectMethod(NULL, keys, mid);
2453 ch = javastring_tochar(obj);
2454 *property_ptr[i] = heap_allocate(sizeof(char*) * strlen (ch),true,NULL);
2455 memcpy(*property_ptr[i], ch, strlen (ch));
2456 MFREE(ch,char,strlen(ch)+1);
2460 return JVMTI_ERROR_NONE;
2464 /* GetSystemProperty **********************************************************
2466 Return a VM system property value given the property key.
2468 *******************************************************************************/
2471 GetSystemProperty (jvmtiEnv * env, const char *property, char **value_ptr)
2474 classinfo *sysclass, *propclass;
2475 java_objectheader *sysprop, *obj;
2479 CHECK_PHASE(JVMTI_PHASE_ONLOAD)
2480 CHECK_PHASE(JVMTI_PHASE_LIVE)
2483 if ((value_ptr == NULL) || (property == NULL))
2484 return JVMTI_ERROR_NULL_POINTER;
2486 sysclass = load_class_from_sysloader(utf_new_char("java/lang/System"));
2487 if (!sysclass) throw_main_exception_exit();
2489 mid = class_resolvemethod(sysclass,
2490 utf_new_char("getProperties"),
2491 utf_new_char("()Ljava/util/Properties;"));
2492 if (!mid) throw_main_exception_exit();
2494 sysprop = JNI_JNIEnvTable.CallStaticObjectMethod(NULL, (jclass)sysclass, mid);
2496 propclass = sysprop->vftbl->class;
2498 mid = class_resolvemethod(propclass,
2499 utf_new_char("getProperty"),
2500 utf_new_char("(Ljava/lang/String;)Ljava/lang/String;"));
2501 if (!mid) throw_main_exception_exit();
2503 obj = (java_objectheader*)JNI_JNIEnvTable.CallObjectMethod(
2504 NULL, sysprop, mid, javastring_new_char(property));
2505 if (!obj) return JVMTI_ERROR_NOT_AVAILABLE;
2507 ch = javastring_tochar(obj);
2508 *value_ptr = heap_allocate(sizeof(char*) * strlen (ch),true,NULL);
2509 memcpy(*value_ptr, ch, strlen (ch));
2510 MFREE(ch,char,strlen(ch)+1);
2512 return JVMTI_ERROR_NONE;
2516 /* SetSystemProperty **********************************************************
2518 Set a VM system property value.
2520 *******************************************************************************/
2523 SetSystemProperty (jvmtiEnv * env, const char *property, const char *value)
2526 classinfo *sysclass, *propclass;
2527 java_objectheader *sysprop;
2530 CHECK_PHASE(JVMTI_PHASE_START)
2533 if (property == NULL) return JVMTI_ERROR_NULL_POINTER;
2534 if (value == NULL) return JVMTI_ERROR_NOT_AVAILABLE;
2536 sysclass = load_class_from_sysloader(utf_new_char("java/lang/System"));
2537 if (!sysclass) throw_main_exception_exit();
2539 mid = class_resolvemethod(sysclass,
2540 utf_new_char("getProperties"),
2541 utf_new_char("()Ljava/util/Properties;"));
2542 if (!mid) throw_main_exception_exit();
2544 sysprop = JNI_JNIEnvTable.CallStaticObjectMethod(NULL, (jclass)sysclass, mid);
2546 propclass = sysprop->vftbl->class;
2548 mid = class_resolvemethod(propclass,
2549 utf_new_char("setProperty"),
2550 utf_new_char("(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;"));
2551 if (!mid) throw_main_exception_exit();
2553 JNI_JNIEnvTable.CallObjectMethod(
2554 NULL, sysprop, mid, javastring_new_char(property),javastring_new_char(value));
2556 return JVMTI_ERROR_NONE;
2559 /* GetPhase ********************************************************************
2561 Return the current phase of VM execution
2563 *******************************************************************************/
2566 GetPhase (jvmtiEnv * env, jvmtiPhase * phase_ptr)
2568 if (phase_ptr == NULL) return JVMTI_ERROR_NULL_POINTER;
2572 return JVMTI_ERROR_NONE;
2575 /* *****************************************************************************
2579 *******************************************************************************/
2582 GetCurrentThreadCpuTimerInfo (jvmtiEnv * env, jvmtiTimerInfo * info_ptr)
2585 CHECK_PHASE(JVMTI_PHASE_START)
2586 CHECK_PHASE(JVMTI_PHASE_LIVE)
2589 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
2590 return JVMTI_ERROR_NONE;
2593 /* *****************************************************************************
2597 *******************************************************************************/
2600 GetCurrentThreadCpuTime (jvmtiEnv * env, jlong * nanos_ptr)
2603 CHECK_PHASE(JVMTI_PHASE_START)
2604 CHECK_PHASE(JVMTI_PHASE_LIVE)
2607 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
2608 return JVMTI_ERROR_NONE;
2611 /* *****************************************************************************
2615 *******************************************************************************/
2618 GetThreadCpuTimerInfo (jvmtiEnv * env, jvmtiTimerInfo * info_ptr)
2621 CHECK_PHASE(JVMTI_PHASE_START)
2622 CHECK_PHASE(JVMTI_PHASE_LIVE)
2625 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
2626 return JVMTI_ERROR_NONE;
2629 /* *****************************************************************************
2633 *******************************************************************************/
2636 GetThreadCpuTime (jvmtiEnv * env, jthread thread, jlong * nanos_ptr)
2639 CHECK_PHASE(JVMTI_PHASE_START)
2640 CHECK_PHASE(JVMTI_PHASE_LIVE)
2643 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
2644 return JVMTI_ERROR_NONE;
2647 /* *****************************************************************************
2651 *******************************************************************************/
2654 GetTimerInfo (jvmtiEnv * env, jvmtiTimerInfo * info_ptr)
2657 CHECK_PHASE(JVMTI_PHASE_START)
2658 CHECK_PHASE(JVMTI_PHASE_LIVE)
2661 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
2662 return JVMTI_ERROR_NONE;
2665 /* GetTime ********************************************************************
2667 Return the current value of the system timer, in nanoseconds
2669 *******************************************************************************/
2672 GetTime (jvmtiEnv * env, jlong * nanos_ptr)
2674 /* Note: this implementation copied directly from Japhar's, by Chris Toshok. */
2677 if (nanos_ptr == NULL) return JVMTI_ERROR_NULL_POINTER;
2679 if (gettimeofday (&tp, NULL) == -1)
2680 JNI_JNIEnvTable.FatalError (NULL, "gettimeofday call failed.");
2682 *nanos_ptr = (jlong) tp.tv_sec;
2684 *nanos_ptr += (tp.tv_usec / 1000);
2686 return JVMTI_ERROR_NONE;
2689 /* GetPotentialCapabilities ***************************************************
2691 Returns the JVM TI features that can potentially be possessed by this
2692 environment at this time.
2694 *******************************************************************************/
2697 GetPotentialCapabilities (jvmtiEnv * env,
2698 jvmtiCapabilities * capabilities_ptr)
2701 CHECK_PHASE(JVMTI_PHASE_ONLOAD)
2702 CHECK_PHASE(JVMTI_PHASE_LIVE)
2705 if (capabilities_ptr == NULL) return JVMTI_ERROR_NULL_POINTER;
2707 memcpy(capabilities_ptr, &JVMTI_Capabilities, sizeof(JVMTI_Capabilities));
2709 return JVMTI_ERROR_NONE;
2713 jvmtiError static capabilityerror()
2715 return JVMTI_ERROR_MUST_POSSESS_CAPABILITY;
2718 #define CHECK_POTENTIAL_AVAILABLE(CAN) \
2719 if ((capabilities_ptr->CAN == 1) && \
2720 (JVMTI_Capabilities.CAN == 0)) \
2721 return JVMTI_ERROR_NOT_AVAILABLE;
2724 /* AddCapabilities ************************************************************
2726 Set new capabilities by adding the capabilities pointed to by
2727 capabilities_ptr. All previous capabilities are retained.
2729 *******************************************************************************/
2732 AddCapabilities (jvmtiEnv * env, const jvmtiCapabilities * capabilities_ptr)
2734 environment* cacao_env;
2737 CHECK_PHASE(JVMTI_PHASE_ONLOAD)
2738 CHECK_PHASE(JVMTI_PHASE_LIVE)
2741 if ((env == NULL) || (capabilities_ptr == NULL))
2742 return JVMTI_ERROR_NULL_POINTER;
2744 cacao_env = (environment*)env;
2746 CHECK_POTENTIAL_AVAILABLE(can_tag_objects)
2748 cacao_env->capabilities.can_tag_objects = 1;
2749 env->GetTag = &GetTag;
2750 env->SetTag = &SetTag;
2751 env->IterateOverObjectsReachableFromObject =
2752 &IterateOverObjectsReachableFromObject;
2753 env->IterateOverReachableObjects =
2754 &IterateOverReachableObjects;
2755 env->IterateOverHeap = &IterateOverHeap;
2756 env->IterateOverInstancesOfClass = &IterateOverInstancesOfClass;
2757 env->GetObjectsWithTags = &GetObjectsWithTags;
2760 CHECK_POTENTIAL_AVAILABLE(can_generate_field_modification_events)
2762 cacao_env->capabilities.can_generate_field_modification_events = 1;
2763 env->SetFieldModificationWatch = &SetFieldModificationWatch;
2764 env->SetEventNotificationMode = &SetEventNotificationMode;
2767 CHECK_POTENTIAL_AVAILABLE(can_generate_field_access_events)
2769 cacao_env->capabilities.can_generate_field_access_events = 1;
2770 env->SetFieldAccessWatch = &SetFieldAccessWatch;
2773 CHECK_POTENTIAL_AVAILABLE(can_get_bytecodes)
2775 cacao_env->capabilities.can_get_bytecodes = 1;
2776 env->GetBytecodes = &GetBytecodes;
2779 CHECK_POTENTIAL_AVAILABLE(can_get_synthetic_attribute)
2781 cacao_env->capabilities.can_get_synthetic_attribute = 1;
2782 env->IsFieldSynthetic = &IsFieldSynthetic;
2783 env->IsMethodSynthetic = &IsMethodSynthetic;
2786 CHECK_POTENTIAL_AVAILABLE(can_get_owned_monitor_info)
2788 cacao_env->capabilities.can_get_owned_monitor_info = 1;
2789 env->GetOwnedMonitorInfo = &GetOwnedMonitorInfo;
2792 CHECK_POTENTIAL_AVAILABLE(can_get_current_contended_monitor)
2794 cacao_env->capabilities.can_get_current_contended_monitor = 1;
2795 env->GetCurrentContendedMonitor = &GetCurrentContendedMonitor;
2798 CHECK_POTENTIAL_AVAILABLE(can_get_monitor_info)
2800 cacao_env->capabilities.can_get_monitor_info = 1;
2801 env->GetObjectMonitorUsage = &GetObjectMonitorUsage;
2804 CHECK_POTENTIAL_AVAILABLE(can_pop_frame)
2806 cacao_env->capabilities.can_pop_frame = 1;
2807 env->PopFrame = &PopFrame;
2810 CHECK_POTENTIAL_AVAILABLE(can_redefine_classes)
2812 cacao_env->capabilities.can_redefine_classes = 1;
2813 env->RedefineClasses = &RedefineClasses;
2816 CHECK_POTENTIAL_AVAILABLE(can_signal_thread)
2818 cacao_env->capabilities.can_signal_thread = 1;
2819 env->StopThread = &StopThread;
2820 env->InterruptThread = &InterruptThread;
2823 CHECK_POTENTIAL_AVAILABLE(can_get_source_file_name)
2825 cacao_env->capabilities.can_get_source_file_name = 1;
2826 env->GetSourceFileName = &GetSourceFileName;
2829 CHECK_POTENTIAL_AVAILABLE(can_get_line_numbers)
2831 cacao_env->capabilities.can_get_line_numbers = 1;
2832 env->GetLineNumberTable = &GetLineNumberTable;
2835 CHECK_POTENTIAL_AVAILABLE(can_get_source_debug_extension)
2837 cacao_env->capabilities.can_get_source_debug_extension = 1;
2838 env->GetSourceDebugExtension = &GetSourceDebugExtension;
2841 CHECK_POTENTIAL_AVAILABLE(can_access_local_variables)
2843 cacao_env->capabilities.can_access_local_variables = 1;
2844 env->GetLocalObject = &GetLocalObject;
2845 env->GetLocalInt = &GetLocalInt;
2846 env->GetLocalLong = &GetLocalLong;
2847 env->GetLocalFloat = &GetLocalFloat;
2848 env->GetLocalDouble = &GetLocalDouble;
2849 env->SetLocalObject = &SetLocalObject;
2850 env->SetLocalInt = &SetLocalInt;
2851 env->SetLocalLong = &SetLocalLong;
2852 env->SetLocalFloat = &SetLocalFloat;
2853 env->SetLocalDouble = &SetLocalDouble;
2854 env->GetLocalVariableTable = &GetLocalVariableTable;
2857 CHECK_POTENTIAL_AVAILABLE(can_maintain_original_method_order)
2859 cacao_env->capabilities.can_maintain_original_method_order = 1;
2860 env->GetClassMethods = &GetClassMethods;
2863 CHECK_POTENTIAL_AVAILABLE(can_generate_single_step_events)
2865 cacao_env->capabilities.can_generate_single_step_events = 1;
2866 env->SetEventNotificationMode = &SetEventNotificationMode;
2869 CHECK_POTENTIAL_AVAILABLE(can_generate_exception_events)
2871 cacao_env->capabilities.can_generate_exception_events = 1;
2875 CHECK_POTENTIAL_AVAILABLE(can_generate_frame_pop_events)
2877 cacao_env->capabilities.can_generate_frame_pop_events = 1;
2881 CHECK_POTENTIAL_AVAILABLE(can_generate_breakpoint_events)
2883 cacao_env->capabilities.can_generate_breakpoint_events = 1;
2887 CHECK_POTENTIAL_AVAILABLE(can_suspend)
2889 cacao_env->capabilities.can_suspend = 1;
2893 CHECK_POTENTIAL_AVAILABLE(can_redefine_any_class)
2895 cacao_env->capabilities.can_redefine_any_class = 1;
2899 CHECK_POTENTIAL_AVAILABLE(can_get_current_thread_cpu_time)
2901 cacao_env->capabilities.can_get_current_thread_cpu_time = 1;
2905 CHECK_POTENTIAL_AVAILABLE(can_get_thread_cpu_time)
2907 cacao_env->capabilities.can_get_thread_cpu_time = 1;
2911 CHECK_POTENTIAL_AVAILABLE(can_generate_method_entry_events)
2913 cacao_env->capabilities.can_generate_method_entry_events = 1;
2917 CHECK_POTENTIAL_AVAILABLE(can_generate_method_exit_events)
2919 cacao_env->capabilities.can_generate_method_exit_events = 1;
2923 CHECK_POTENTIAL_AVAILABLE(can_generate_all_class_hook_events)
2925 cacao_env->capabilities.can_generate_all_class_hook_events = 1;
2929 CHECK_POTENTIAL_AVAILABLE(can_generate_compiled_method_load_events)
2931 cacao_env->capabilities.can_generate_compiled_method_load_events = 1;
2935 CHECK_POTENTIAL_AVAILABLE(can_generate_monitor_events)
2937 cacao_env->capabilities.can_generate_monitor_events= 1;
2941 CHECK_POTENTIAL_AVAILABLE(can_generate_vm_object_alloc_events)
2943 cacao_env->capabilities.can_generate_vm_object_alloc_events = 1;
2947 CHECK_POTENTIAL_AVAILABLE(can_generate_native_method_bind_events)
2949 cacao_env->capabilities.can_generate_native_method_bind_events = 1;
2953 CHECK_POTENTIAL_AVAILABLE(can_generate_garbage_collection_events)
2955 cacao_env->capabilities.can_generate_garbage_collection_events = 1;
2959 CHECK_POTENTIAL_AVAILABLE(can_generate_object_free_events)
2961 cacao_env->capabilities.can_generate_object_free_events = 1;
2965 return JVMTI_ERROR_NONE;
2968 /* RelinquishCapabilities *****************************************************
2970 Relinquish the capabilities pointed to by capabilities_ptr.
2972 *******************************************************************************/
2975 RelinquishCapabilities (jvmtiEnv * env,
2976 const jvmtiCapabilities * capabilities_ptr)
2978 environment* cacao_env;
2981 CHECK_PHASE(JVMTI_PHASE_ONLOAD)
2982 CHECK_PHASE(JVMTI_PHASE_LIVE)
2985 if ((env == NULL) || (capabilities_ptr == NULL))
2986 return JVMTI_ERROR_NULL_POINTER;
2988 cacao_env = (environment*)env;
2990 if (capabilities_ptr->can_tag_objects == 1) {
2991 cacao_env->capabilities.can_tag_objects = 0;
2992 env->GetTag = &capabilityerror;
2993 env->SetTag = &capabilityerror;
2994 env->IterateOverObjectsReachableFromObject = &capabilityerror;
2995 env->IterateOverReachableObjects = &capabilityerror;
2996 env->IterateOverHeap = &capabilityerror;
2997 env->IterateOverInstancesOfClass = &capabilityerror;
2998 env->GetObjectsWithTags = &capabilityerror;
3001 /* todo if ((capabilities_ptr-> == 1) {
3002 cacao_env->capabilities. = 0;
3003 env->SetFieldModificationWatch = &capabilityerror;
3007 return JVMTI_ERROR_NONE;
3010 /* *****************************************************************************
3014 *******************************************************************************/
3017 GetAvailableProcessors (jvmtiEnv * env, jint * processor_count_ptr)
3020 CHECK_PHASE(JVMTI_PHASE_START)
3021 CHECK_PHASE(JVMTI_PHASE_LIVE)
3024 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
3025 return JVMTI_ERROR_NONE;
3028 /* GetEnvironmentLocalStorage **************************************************
3030 Called by the agent to get the value of the JVM TI environment-local storage.
3032 *******************************************************************************/
3035 GetEnvironmentLocalStorage (jvmtiEnv * env, void **data_ptr)
3037 if ((env == NULL) || (data_ptr == NULL)) return JVMTI_ERROR_NULL_POINTER;
3039 *data_ptr = ((environment*)env)->EnvironmentLocalStorage;
3041 return JVMTI_ERROR_NONE;
3044 /* SetEnvironmentLocalStorage **************************************************
3046 The VM stores a pointer value associated with each environment. Agents can
3047 allocate memory in which they store environment specific information.
3049 *******************************************************************************/
3052 SetEnvironmentLocalStorage (jvmtiEnv * env, const void *data)
3054 if (env == NULL) return JVMTI_ERROR_NULL_POINTER;
3056 ((environment*)env)->EnvironmentLocalStorage = data;
3058 return JVMTI_ERROR_NONE;
3061 /* AddToBootstrapClassLoaderSearch ********************************************
3063 After the bootstrap class loader unsuccessfully searches for a class, the
3064 specified platform-dependent search path segment will be searched as well.
3066 *******************************************************************************/
3069 AddToBootstrapClassLoaderSearch (jvmtiEnv * env, const char *segment)
3075 CHECK_PHASE(JVMTI_PHASE_ONLOAD)
3078 if (segment == NULL) return JVMTI_ERROR_NULL_POINTER;
3080 ln = strlen(bootclasspath) + strlen(":") + strlen(segment);
3081 tmp_bcp = MNEW(char, ln);
3082 strcat(tmp_bcp, bootclasspath);
3083 strcat(tmp_bcp, ":");
3084 strcat(tmp_bcp, segment);
3085 MFREE(bootclasspath,char,ln);
3086 bootclasspath = tmp_bcp;
3088 return JVMTI_ERROR_NONE;
3091 /* SetVerboseFlag *************************************************************
3093 Control verbose output. This is the output which typically is sent to stderr
3095 *******************************************************************************/
3098 SetVerboseFlag (jvmtiEnv * env, jvmtiVerboseFlag flag, jboolean value)
3101 case JVMTI_VERBOSE_OTHER:
3104 case JVMTI_VERBOSE_GC:
3105 opt_verbosegc = value;
3107 case JVMTI_VERBOSE_CLASS:
3108 loadverbose = value;
3110 case JVMTI_VERBOSE_JNI:
3113 return JVMTI_ERROR_ILLEGAL_ARGUMENT;
3115 return JVMTI_ERROR_NONE;
3118 /* GetObjectSize **************************************************************
3120 For the object indicated by object, return the size of the object. This size
3121 is an implementation-specific approximation of the amount of storage consumed
3124 *******************************************************************************/
3127 GetObjectSize (jvmtiEnv * env, jobject object, jlong * size_ptr)
3130 CHECK_PHASE(JVMTI_PHASE_START)
3131 CHECK_PHASE(JVMTI_PHASE_LIVE)
3134 log_text ("JVMTI-Call: IMPLEMENT ME!!!");
3135 return JVMTI_ERROR_NONE;
3139 /* *****************************************************************************
3141 Environment variables
3143 *******************************************************************************/
3145 jvmtiCapabilities JVMTI_Capabilities = {
3146 0, /* can_tag_objects */
3147 0, /* can_generate_field_modification_events */
3148 0, /* can_generate_field_access_events */
3149 1, /* can_get_bytecodes */
3150 0, /* can_get_synthetic_attribute */
3151 0, /* can_get_owned_monitor_info */
3152 0, /* can_get_current_contended_monitor */
3153 0, /* can_get_monitor_info */
3154 0, /* can_pop_frame */
3155 0, /* can_redefine_classes */
3156 0, /* can_signal_thread */
3157 1, /* can_get_source_file_name */
3158 1, /* can_get_line_numbers */
3159 0, /* can_get_source_debug_extension */
3160 0, /* can_access_local_variables */
3161 0, /* can_maintain_original_method_order */
3162 0, /* can_generate_single_step_events */
3163 0, /* can_generate_exception_events */
3164 0, /* can_generate_frame_pop_events */
3165 0, /* can_generate_breakpoint_events */
3166 0, /* can_suspend */
3167 0, /* can_redefine_any_class */
3168 0, /* can_get_current_thread_cpu_time */
3169 0, /* can_get_thread_cpu_time */
3170 0, /* can_generate_method_entry_events */
3171 0, /* can_generate_method_exit_events */
3172 0, /* can_generate_all_class_hook_events */
3173 0, /* can_generate_compiled_method_load_events */
3174 0, /* can_generate_monitor_events */
3175 0, /* can_generate_vm_object_alloc_events */
3176 0, /* can_generate_native_method_bind_events */
3177 0, /* can_generate_garbage_collection_events */
3178 0, /* can_generate_object_free_events */
3181 jvmtiEnv JVMTI_EnvTable = {
3183 &SetEventNotificationMode,
3191 &GetOwnedMonitorInfo,
3192 &GetCurrentContendedMonitor,
3194 &GetTopThreadGroups,
3195 &GetThreadGroupInfo,
3196 &GetThreadGroupChildren,
3218 &RawMonitorNotifyAll,
3222 &SetFieldAccessWatch,
3223 &ClearFieldAccessWatch,
3224 &SetFieldModificationWatch,
3225 &ClearFieldModificationWatch,
3235 &GetImplementedInterfaces,
3240 &GetObjectMonitorUsage,
3242 &GetFieldDeclaringClass,
3246 &GetMethodDeclaringClass,
3247 &GetMethodModifiers,
3251 &GetLineNumberTable,
3253 &GetLocalVariableTable,
3260 &GetClassLoaderClasses,
3271 &GetSourceDebugExtension,
3282 &GetThreadListStackTraces,
3283 &GetThreadLocalStorage,
3284 &SetThreadLocalStorage,
3289 &ForceGarbageCollection,
3290 &IterateOverObjectsReachableFromObject,
3291 &IterateOverReachableObjects,
3293 &IterateOverInstancesOfClass,
3295 &GetObjectsWithTags,
3301 &SetJNIFunctionTable,
3302 &GetJNIFunctionTable,
3305 &GetExtensionFunctions,
3306 &GetExtensionEvents,
3307 &SetExtensionEventCallback,
3308 &DisposeEnvironment,
3310 &GetJLocationFormat,
3311 &GetSystemProperties,
3315 &GetCurrentThreadCpuTimerInfo,
3316 &GetCurrentThreadCpuTime,
3317 &GetThreadCpuTimerInfo,
3321 &GetPotentialCapabilities,
3324 &RelinquishCapabilities,
3325 &GetAvailableProcessors,
3328 &GetEnvironmentLocalStorage,
3329 &SetEnvironmentLocalStorage,
3330 &AddToBootstrapClassLoaderSearch,
3339 ihmclass = load_class_from_sysloader(
3340 utf_new_char_classname ("java/util/IdentityHashMap"));
3341 if (ihmclass == NULL) {
3342 log_text("JVMTI-Init: unable to find java.util.IdentityHashMap");
3345 ihmmid = class_resolvemethod(ihmclass,
3346 utf_new_char("<init>"),
3347 utf_new_char("()V"));
3348 if (ihmmid == NULL) {
3349 log_text("JVMTI-Init: unable to find constructor in java.util.IdentityHashMap");
3353 void set_jvmti_phase(jvmtiPhase p) {
3356 case JVMTI_PHASE_ONLOAD:
3359 case JVMTI_PHASE_PRIMORDIAL:
3362 case JVMTI_PHASE_START:
3363 /* todo: send VM Start Event*/
3365 case JVMTI_PHASE_LIVE:
3366 /* todo: send VMInit Event */
3368 case JVMTI_PHASE_DEAD:
3369 /* todo: send VMDeath Event */
3374 jvmtiEnv* new_jvmtienv() {
3376 java_objectheader *o;
3378 env = heap_allocate(sizeof(environment),true,NULL);
3379 memcpy(&(env->env),&JVMTI_EnvTable,sizeof(jvmtiEnv));
3380 env->events = (jobject*)builtin_new(ihmclass);
3381 asm_calljavafunction(ihmmid, o, NULL, NULL, NULL);
3382 /* To possess a capability, the agent must add the capability.*/
3383 memset(&(env->capabilities), 1, sizeof(jvmtiCapabilities));
3384 RelinquishCapabilities(&(env->env),&(env->capabilities));
3385 env->EnvironmentLocalStorage = NULL;