src/native/jvmti/jvmti.c

   1 /* src/native/jvmti.c - implementation of the Java Virtual Machine Tool
   2                         Interface functions
   3
   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
   8
   9    This file is part of CACAO.
  10
  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.
  15
  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.
  20
  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
  24    02111-1307, USA.
  25
  26    Contact: cacao@complang.tuwien.ac.at
  27
  28    Author: Martin Platter
  29
  30    Changes:
  31
  32
  33    $Id: jvmti.c 3066 2005-07-19 12:35:37Z twisti $
  34
  35 */
  36
  37
  38 #include "native/jni.h"
  39 #include "native/jvmti/jvmti.h"
  40 #include "vm/global.h"
  41 #include "vm/loader.h"
  42 #include "vm/builtin.h"
  43 #include "vm/jit/asmpart.h"
  44 #include "mm/boehm.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"
  52
  53 #include <string.h>
  54 #include <linux/unistd.h>
  55 #include <sys/time.h>
  56
  57 static jvmtiPhase phase;
  58
  59 typedef struct {
  60     jvmtiEnv env;
  61     jvmtiEventCallbacks callbacks;
  62     jobject *events;   /* hashtable for enabled/disabled jvmtiEvents */
  63     jvmtiCapabilities capabilities;
  64     void *EnvironmentLocalStorage;
  65 } environment;
  66
  67
  68 /* jmethodID and jclass caching */
  69 static jclass ihmclass = NULL;
  70 static jmethodID ihmmid = NULL;
  71
  72 jvmtiEnv JVMTI_EnvTable;
  73 jvmtiCapabilities JVMTI_Capabilities;
  74
  75 #define CHECK_PHASE_START  if (!(0
  76 #define CHECK_PHASE(chkphase) || (phase == chkphase)
  77 #define CHECK_PHASE_END  )) return JVMTI_ERROR_WRONG_PHASE
  78
  79
  80 /* SetEventNotificationMode ****************************************************
  81
  82    Control the generation of events
  83
  84 *******************************************************************************/
  85
  86 jvmtiError
  87 SetEventNotificationMode (jvmtiEnv * env, jvmtiEventMode mode,
  88                           jvmtiEvent event_type, jthread event_thread, ...)
  89 {
  90     CHECK_PHASE_START
  91     CHECK_PHASE(JVMTI_PHASE_ONLOAD)
  92     CHECK_PHASE(JVMTI_PHASE_LIVE)
  93     CHECK_PHASE_END;
  94
  95   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
  96
  97     return JVMTI_ERROR_NONE;
  98 }
  99
 100
 101 /* GetAllThreads ***************************************************************
 102
 103    Get all live threads
 104
 105 *******************************************************************************/
 106
 107 jvmtiError
 108 GetAllThreads (jvmtiEnv * env, jint * threads_count_ptr,
 109                jthread ** threads_ptr)
 110 {
 111     int i = 0;
 112     threadobject* thread;
 113
 114     CHECK_PHASE_START
 115     CHECK_PHASE(JVMTI_PHASE_LIVE)
 116     CHECK_PHASE_END;
 117
 118     if ((threads_count_ptr == NULL) || (threads_ptr == NULL))
 119         return JVMTI_ERROR_NULL_POINTER;
 120
 121     thread = mainthreadobj;
 122     do {
 123         i++;
 124         thread = thread->info.prev;
 125     } while (thread != mainthreadobj);
 126
 127     *threads_count_ptr = i;
 128
 129     *threads_ptr = (jthread*) heap_allocate(sizeof(jthread) * i,true,NULL);
 130     i=0;
 131     do {
 132         memcpy(*threads_ptr[i],thread,sizeof(jthread));
 133         thread = thread->info.prev;
 134         i++;
 135     } while (thread != mainthreadobj);
 136
 137     return JVMTI_ERROR_NONE;
 138 }
 139
 140
 141 /* SuspendThread ***************************************************************
 142
 143
 144
 145 *******************************************************************************/
 146
 147 jvmtiError
 148 SuspendThread (jvmtiEnv * env, jthread thread)
 149 {
 150       CHECK_PHASE_START
 151     CHECK_PHASE(JVMTI_PHASE_START)
 152     CHECK_PHASE(JVMTI_PHASE_LIVE)
 153     CHECK_PHASE_END;
 154
 155   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 156     return JVMTI_ERROR_NONE;
 157 }
 158
 159 /* *****************************************************************************
 160
 161
 162
 163 *******************************************************************************/
 164
 165 jvmtiError
 166 ResumeThread (jvmtiEnv * env, jthread thread)
 167 {
 168       CHECK_PHASE_START
 169     CHECK_PHASE(JVMTI_PHASE_START)
 170     CHECK_PHASE(JVMTI_PHASE_LIVE)
 171     CHECK_PHASE_END;
 172
 173   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 174     return JVMTI_ERROR_NONE;
 175 }
 176
 177 /* *****************************************************************************
 178
 179
 180
 181 *******************************************************************************/
 182
 183 jvmtiError
 184 StopThread (jvmtiEnv * env, jthread thread, jobject exception)
 185 {
 186       CHECK_PHASE_START
 187     CHECK_PHASE(JVMTI_PHASE_START)
 188     CHECK_PHASE(JVMTI_PHASE_LIVE)
 189     CHECK_PHASE_END;
 190
 191   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 192     return JVMTI_ERROR_NONE;
 193 }
 194
 195 /* *****************************************************************************
 196
 197
 198
 199 *******************************************************************************/
 200
 201 jvmtiError
 202 InterruptThread (jvmtiEnv * env, jthread thread)
 203 {
 204       CHECK_PHASE_START
 205     CHECK_PHASE(JVMTI_PHASE_START)
 206     CHECK_PHASE(JVMTI_PHASE_LIVE)
 207     CHECK_PHASE_END;
 208
 209   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 210     return JVMTI_ERROR_NONE;
 211 }
 212
 213 /* GetThreadInfo ***************************************************************
 214
 215    Get thread information. The fields of the jvmtiThreadInfo structure are
 216    filled in with details of the specified thread.
 217
 218 *******************************************************************************/
 219
 220 jvmtiError
 221 GetThreadInfo (jvmtiEnv * env, jthread thread, jvmtiThreadInfo * info_ptr)
 222 {
 223     CHECK_PHASE_START
 224     CHECK_PHASE(JVMTI_PHASE_LIVE)
 225     CHECK_PHASE_END;
 226
 227   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 228     return JVMTI_ERROR_NONE;
 229 }
 230
 231 /* GetOwnedMonitorInfo *********************************************************
 232
 233
 234
 235 *******************************************************************************/
 236
 237 jvmtiError
 238 GetOwnedMonitorInfo (jvmtiEnv * env, jthread thread,
 239                      jint * owned_monitor_count_ptr,
 240                      jobject ** owned_monitors_ptr)
 241 {
 242       CHECK_PHASE_START
 243     CHECK_PHASE(JVMTI_PHASE_START)
 244     CHECK_PHASE(JVMTI_PHASE_LIVE)
 245     CHECK_PHASE_END;
 246
 247   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 248     return JVMTI_ERROR_NONE;
 249 }
 250
 251 /* *****************************************************************************
 252
 253
 254
 255 *******************************************************************************/
 256
 257 jvmtiError
 258 GetCurrentContendedMonitor (jvmtiEnv * env, jthread thread,
 259                             jobject * monitor_ptr)
 260 {
 261       CHECK_PHASE_START
 262     CHECK_PHASE(JVMTI_PHASE_START)
 263     CHECK_PHASE(JVMTI_PHASE_LIVE)
 264     CHECK_PHASE_END;
 265
 266   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 267     return JVMTI_ERROR_NONE;
 268 }
 269
 270
 271 /* *****************************************************************************
 272
 273
 274
 275 *******************************************************************************/
 276
 277 jvmtiError
 278 RunAgentThread (jvmtiEnv * env, jthread thread, jvmtiStartFunction proc,
 279                 const void *arg, jint priority)
 280 {
 281       CHECK_PHASE_START
 282     CHECK_PHASE(JVMTI_PHASE_START)
 283     CHECK_PHASE(JVMTI_PHASE_LIVE)
 284     CHECK_PHASE_END;
 285
 286   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 287     return JVMTI_ERROR_NONE;
 288 }
 289
 290
 291 /* *****************************************************************************
 292
 293
 294
 295 *******************************************************************************/
 296
 297 jvmtiError
 298 GetTopThreadGroups (jvmtiEnv * env, jint * group_count_ptr,
 299                     jthreadGroup ** groups_ptr)
 300 {
 301       CHECK_PHASE_START
 302     CHECK_PHASE(JVMTI_PHASE_START)
 303     CHECK_PHASE(JVMTI_PHASE_LIVE)
 304     CHECK_PHASE_END;
 305
 306   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 307     return JVMTI_ERROR_NONE;
 308 }
 309
 310
 311 /* *****************************************************************************
 312
 313
 314
 315 *******************************************************************************/
 316
 317 jvmtiError
 318 GetThreadGroupInfo (jvmtiEnv * env, jthreadGroup group,
 319                     jvmtiThreadGroupInfo * info_ptr)
 320 {
 321       CHECK_PHASE_START
 322     CHECK_PHASE(JVMTI_PHASE_START)
 323     CHECK_PHASE(JVMTI_PHASE_LIVE)
 324     CHECK_PHASE_END;
 325
 326   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 327     return JVMTI_ERROR_NONE;
 328 }
 329
 330
 331 /* *****************************************************************************
 332
 333
 334
 335 *******************************************************************************/
 336
 337 jvmtiError
 338 GetThreadGroupChildren (jvmtiEnv * env, jthreadGroup group,
 339                         jint * thread_count_ptr, jthread ** threads_ptr,
 340                         jint * group_count_ptr, jthreadGroup ** groups_ptr)
 341 {
 342     CHECK_PHASE_START
 343     CHECK_PHASE(JVMTI_PHASE_START)
 344     CHECK_PHASE(JVMTI_PHASE_LIVE)
 345     CHECK_PHASE_END;
 346
 347   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 348     return JVMTI_ERROR_NONE;
 349 }
 350
 351
 352 /* *****************************************************************************
 353
 354
 355
 356 *******************************************************************************/
 357
 358 jvmtiError
 359 GetFrameCount (jvmtiEnv * env, jthread thread, jint * count_ptr)
 360 {
 361       CHECK_PHASE_START
 362     CHECK_PHASE(JVMTI_PHASE_START)
 363     CHECK_PHASE(JVMTI_PHASE_LIVE)
 364     CHECK_PHASE_END;
 365
 366   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 367     return JVMTI_ERROR_NONE;
 368 }
 369
 370
 371 /* GetThreadState **************************************************************
 372
 373    Get the state of a thread.
 374
 375 *******************************************************************************/
 376
 377 jvmtiError
 378 GetThreadState (jvmtiEnv * env, jthread thread, jint * thread_state_ptr)
 379 {
 380     CHECK_PHASE_START
 381     CHECK_PHASE(JVMTI_PHASE_LIVE)
 382     CHECK_PHASE_END;
 383
 384   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 385     return JVMTI_ERROR_NONE;
 386 }
 387
 388
 389 /* *****************************************************************************
 390
 391
 392
 393 *******************************************************************************/
 394
 395 jvmtiError
 396 GetFrameLocation (jvmtiEnv * env, jthread thread, jint depth,
 397                   jmethodID * method_ptr, jlocation * location_ptr)
 398 {
 399       CHECK_PHASE_START
 400     CHECK_PHASE(JVMTI_PHASE_START)
 401     CHECK_PHASE(JVMTI_PHASE_LIVE)
 402     CHECK_PHASE_END;
 403
 404   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 405     return JVMTI_ERROR_NONE;
 406 }
 407
 408
 409 /* *****************************************************************************
 410
 411
 412
 413 *******************************************************************************/
 414
 415 jvmtiError
 416 NotifyFramePop (jvmtiEnv * env, jthread thread, jint depth)
 417 {
 418       CHECK_PHASE_START
 419     CHECK_PHASE(JVMTI_PHASE_START)
 420     CHECK_PHASE(JVMTI_PHASE_LIVE)
 421     CHECK_PHASE_END;
 422
 423   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 424     return JVMTI_ERROR_NONE;
 425 }
 426
 427 /* *****************************************************************************
 428
 429
 430
 431 *******************************************************************************/
 432
 433 jvmtiError
 434 GetLocalObject (jvmtiEnv * env,
 435                 jthread thread, jint depth, jint slot, jobject * value_ptr)
 436 {
 437       CHECK_PHASE_START
 438     CHECK_PHASE(JVMTI_PHASE_START)
 439     CHECK_PHASE(JVMTI_PHASE_LIVE)
 440     CHECK_PHASE_END;
 441
 442   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 443     return JVMTI_ERROR_NONE;
 444 }
 445
 446 /* *****************************************************************************
 447
 448
 449
 450 *******************************************************************************/
 451
 452 jvmtiError
 453 GetLocalInt (jvmtiEnv * env,
 454              jthread thread, jint depth, jint slot, jint * value_ptr)
 455 {
 456       CHECK_PHASE_START
 457     CHECK_PHASE(JVMTI_PHASE_START)
 458     CHECK_PHASE(JVMTI_PHASE_LIVE)
 459     CHECK_PHASE_END;
 460
 461   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 462     return JVMTI_ERROR_NONE;
 463 }
 464
 465 /* *****************************************************************************
 466
 467
 468
 469 *******************************************************************************/
 470
 471 jvmtiError
 472 GetLocalLong (jvmtiEnv * env, jthread thread, jint depth, jint slot,
 473               jlong * value_ptr)
 474 {
 475       CHECK_PHASE_START
 476     CHECK_PHASE(JVMTI_PHASE_START)
 477     CHECK_PHASE(JVMTI_PHASE_LIVE)
 478     CHECK_PHASE_END;
 479
 480   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 481     return JVMTI_ERROR_NONE;
 482 }
 483
 484
 485 /* *****************************************************************************
 486
 487
 488
 489 *******************************************************************************/
 490
 491 jvmtiError
 492 GetLocalFloat (jvmtiEnv * env, jthread thread, jint depth, jint slot,
 493                jfloat * value_ptr)
 494 {
 495     CHECK_PHASE_START
 496     CHECK_PHASE(JVMTI_PHASE_START)
 497     CHECK_PHASE(JVMTI_PHASE_LIVE)
 498     CHECK_PHASE_END;
 499
 500   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 501     return JVMTI_ERROR_NONE;
 502 }
 503
 504
 505 /* *****************************************************************************
 506
 507
 508
 509 *******************************************************************************/
 510
 511 jvmtiError
 512 GetLocalDouble (jvmtiEnv * env, jthread thread, jint depth, jint slot,
 513                 jdouble * value_ptr)
 514 {
 515     CHECK_PHASE_START
 516     CHECK_PHASE(JVMTI_PHASE_START)
 517     CHECK_PHASE(JVMTI_PHASE_LIVE)
 518     CHECK_PHASE_END;
 519
 520   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 521     return JVMTI_ERROR_NONE;
 522 }
 523
 524
 525 /* *****************************************************************************
 526
 527
 528
 529 *******************************************************************************/
 530
 531 jvmtiError
 532 SetLocalObject (jvmtiEnv * env, jthread thread, jint depth, jint slot,
 533                 jobject value)
 534 {
 535       CHECK_PHASE_START
 536     CHECK_PHASE(JVMTI_PHASE_START)
 537     CHECK_PHASE(JVMTI_PHASE_LIVE)
 538     CHECK_PHASE_END;
 539
 540   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 541     return JVMTI_ERROR_NONE;
 542 }
 543
 544
 545 /* *****************************************************************************
 546
 547
 548
 549 *******************************************************************************/
 550
 551 jvmtiError
 552 SetLocalInt (jvmtiEnv * env, jthread thread, jint depth, jint slot,
 553              jint value)
 554 {
 555       CHECK_PHASE_START
 556     CHECK_PHASE(JVMTI_PHASE_START)
 557     CHECK_PHASE(JVMTI_PHASE_LIVE)
 558     CHECK_PHASE_END;
 559
 560   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 561     return JVMTI_ERROR_NONE;
 562 }
 563
 564
 565 /* *****************************************************************************
 566
 567
 568
 569 *******************************************************************************/
 570
 571 jvmtiError
 572 SetLocalLong (jvmtiEnv * env, jthread thread, jint depth, jint slot,
 573               jlong value)
 574 {
 575       CHECK_PHASE_START
 576     CHECK_PHASE(JVMTI_PHASE_START)
 577     CHECK_PHASE(JVMTI_PHASE_LIVE)
 578     CHECK_PHASE_END;
 579
 580   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 581     return JVMTI_ERROR_NONE;
 582 }
 583
 584
 585 /* *****************************************************************************
 586
 587
 588
 589 *******************************************************************************/
 590
 591 jvmtiError
 592 SetLocalFloat (jvmtiEnv * env, jthread thread, jint depth, jint slot,
 593                jfloat value)
 594 {
 595       CHECK_PHASE_START
 596     CHECK_PHASE(JVMTI_PHASE_START)
 597     CHECK_PHASE(JVMTI_PHASE_LIVE)
 598     CHECK_PHASE_END;
 599
 600   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 601     return JVMTI_ERROR_NONE;
 602 }
 603
 604
 605 /* *****************************************************************************
 606
 607
 608
 609 *******************************************************************************/
 610
 611 jvmtiError
 612 SetLocalDouble (jvmtiEnv * env, jthread thread, jint depth, jint slot,
 613                 jdouble value)
 614 {
 615       CHECK_PHASE_START
 616     CHECK_PHASE(JVMTI_PHASE_START)
 617     CHECK_PHASE(JVMTI_PHASE_LIVE)
 618     CHECK_PHASE_END;
 619
 620   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 621     return JVMTI_ERROR_NONE;
 622 }
 623
 624
 625 /* *****************************************************************************
 626
 627
 628
 629 *******************************************************************************/
 630
 631 jvmtiError
 632 CreateRawMonitor (jvmtiEnv * env, const char *name,
 633                   jrawMonitorID * monitor_ptr)
 634 {
 635       CHECK_PHASE_START
 636     CHECK_PHASE(JVMTI_PHASE_START)
 637     CHECK_PHASE(JVMTI_PHASE_LIVE)
 638     CHECK_PHASE_END;
 639
 640   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 641     return JVMTI_ERROR_NONE;
 642 }
 643
 644
 645 /* *****************************************************************************
 646
 647
 648
 649 *******************************************************************************/
 650
 651 jvmtiError
 652 DestroyRawMonitor (jvmtiEnv * env, jrawMonitorID monitor)
 653 {
 654       CHECK_PHASE_START
 655     CHECK_PHASE(JVMTI_PHASE_START)
 656     CHECK_PHASE(JVMTI_PHASE_LIVE)
 657     CHECK_PHASE_END;
 658
 659   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 660     return JVMTI_ERROR_NONE;
 661 }
 662
 663
 664 /* *****************************************************************************
 665
 666
 667
 668 *******************************************************************************/
 669
 670 jvmtiError
 671 RawMonitorEnter (jvmtiEnv * env, jrawMonitorID monitor)
 672 {
 673       CHECK_PHASE_START
 674     CHECK_PHASE(JVMTI_PHASE_START)
 675     CHECK_PHASE(JVMTI_PHASE_LIVE)
 676     CHECK_PHASE_END;
 677
 678   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 679     return JVMTI_ERROR_NONE;
 680 }
 681
 682
 683 /* *****************************************************************************
 684
 685
 686
 687 *******************************************************************************/
 688
 689 jvmtiError
 690 RawMonitorExit (jvmtiEnv * env, jrawMonitorID monitor)
 691 {
 692       CHECK_PHASE_START
 693     CHECK_PHASE(JVMTI_PHASE_START)
 694     CHECK_PHASE(JVMTI_PHASE_LIVE)
 695     CHECK_PHASE_END;
 696
 697   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 698     return JVMTI_ERROR_NONE;
 699 }
 700
 701
 702 /* *****************************************************************************
 703
 704
 705
 706 *******************************************************************************/
 707
 708 jvmtiError
 709 RawMonitorWait (jvmtiEnv * env, jrawMonitorID monitor, jlong millis)
 710 {
 711       CHECK_PHASE_START
 712     CHECK_PHASE(JVMTI_PHASE_START)
 713     CHECK_PHASE(JVMTI_PHASE_LIVE)
 714     CHECK_PHASE_END;
 715
 716   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 717     return JVMTI_ERROR_NONE;
 718 }
 719
 720
 721 /* *****************************************************************************
 722
 723
 724
 725 *******************************************************************************/
 726
 727 jvmtiError
 728 RawMonitorNotify (jvmtiEnv * env, jrawMonitorID monitor)
 729 {
 730       CHECK_PHASE_START
 731     CHECK_PHASE(JVMTI_PHASE_START)
 732     CHECK_PHASE(JVMTI_PHASE_LIVE)
 733     CHECK_PHASE_END;
 734
 735   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 736     return JVMTI_ERROR_NONE;
 737 }
 738
 739
 740 /* *****************************************************************************
 741
 742
 743
 744 *******************************************************************************/
 745
 746 jvmtiError
 747 RawMonitorNotifyAll (jvmtiEnv * env, jrawMonitorID monitor)
 748 {
 749       CHECK_PHASE_START
 750     CHECK_PHASE(JVMTI_PHASE_START)
 751     CHECK_PHASE(JVMTI_PHASE_LIVE)
 752     CHECK_PHASE_END;
 753
 754   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 755     return JVMTI_ERROR_NONE;
 756 }
 757
 758
 759 /* *****************************************************************************
 760
 761
 762
 763 *******************************************************************************/
 764
 765 jvmtiError
 766 SetBreakpoint (jvmtiEnv * env, jmethodID method, jlocation location)
 767 {
 768       CHECK_PHASE_START
 769     CHECK_PHASE(JVMTI_PHASE_START)
 770     CHECK_PHASE(JVMTI_PHASE_LIVE)
 771     CHECK_PHASE_END;
 772
 773   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 774     return JVMTI_ERROR_NONE;
 775 }
 776
 777
 778 /* *****************************************************************************
 779
 780
 781
 782 *******************************************************************************/
 783
 784 jvmtiError
 785 ClearBreakpoint (jvmtiEnv * env, jmethodID method, jlocation location)
 786 {
 787       CHECK_PHASE_START
 788     CHECK_PHASE(JVMTI_PHASE_START)
 789     CHECK_PHASE(JVMTI_PHASE_LIVE)
 790     CHECK_PHASE_END;
 791
 792   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 793     return JVMTI_ERROR_NONE;
 794 }
 795
 796
 797 /* *****************************************************************************
 798
 799
 800
 801 *******************************************************************************/
 802
 803 jvmtiError
 804 SetFieldAccessWatch (jvmtiEnv * env, jclass klass, jfieldID field)
 805 {
 806       CHECK_PHASE_START
 807     CHECK_PHASE(JVMTI_PHASE_START)
 808     CHECK_PHASE(JVMTI_PHASE_LIVE)
 809     CHECK_PHASE_END;
 810
 811   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 812     return JVMTI_ERROR_NONE;
 813 }
 814
 815
 816 /* *****************************************************************************
 817
 818
 819
 820 *******************************************************************************/
 821
 822 jvmtiError
 823 ClearFieldAccessWatch (jvmtiEnv * env, jclass klass, jfieldID field)
 824 {
 825       CHECK_PHASE_START
 826     CHECK_PHASE(JVMTI_PHASE_START)
 827     CHECK_PHASE(JVMTI_PHASE_LIVE)
 828     CHECK_PHASE_END;
 829
 830   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 831     return JVMTI_ERROR_NONE;
 832 }
 833
 834
 835 /* *****************************************************************************
 836
 837
 838
 839 *******************************************************************************/
 840
 841 jvmtiError
 842 SetFieldModificationWatch (jvmtiEnv * env, jclass klass, jfieldID field)
 843 {
 844       CHECK_PHASE_START
 845     CHECK_PHASE(JVMTI_PHASE_START)
 846     CHECK_PHASE(JVMTI_PHASE_LIVE)
 847     CHECK_PHASE_END;
 848
 849   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 850     return JVMTI_ERROR_NONE;
 851 }
 852
 853
 854 /* *****************************************************************************
 855
 856
 857
 858 *******************************************************************************/
 859
 860 jvmtiError
 861 ClearFieldModificationWatch (jvmtiEnv * env, jclass klass, jfieldID field)
 862 {
 863       CHECK_PHASE_START
 864     CHECK_PHASE(JVMTI_PHASE_START)
 865     CHECK_PHASE(JVMTI_PHASE_LIVE)
 866     CHECK_PHASE_END;
 867
 868   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 869     return JVMTI_ERROR_NONE;
 870 }
 871
 872
 873 /* Allocate ********************************************************************
 874
 875    Allocate an area of memory through the JVM TI allocator. The allocated
 876    memory should be freed with Deallocate
 877
 878 *******************************************************************************/
 879
 880 jvmtiError
 881 Allocate (jvmtiEnv * env, jlong size, unsigned char **mem_ptr)
 882 {
 883
 884     if (mem_ptr == NULL) return JVMTI_ERROR_NULL_POINTER;
 885     if (size < 0) return JVMTI_ERROR_ILLEGAL_ARGUMENT;
 886
 887     *mem_ptr = heap_allocate(sizeof(size),true,NULL);
 888     if (*mem_ptr == NULL)
 889         return JVMTI_ERROR_OUT_OF_MEMORY;
 890     else
 891         return JVMTI_ERROR_NONE;
 892
 893 }
 894
 895
 896 /* Deallocate ******************************************************************
 897
 898    Deallocate mem using the JVM TI allocator.
 899
 900 *******************************************************************************/
 901
 902 jvmtiError
 903 Deallocate (jvmtiEnv * env, unsigned char *mem)
 904 {
 905     /* let Boehm GC do the job */
 906     return JVMTI_ERROR_NONE;
 907 }
 908
 909
 910 /* GetClassSignature ************************************************************
 911
 912    For the class indicated by klass, return the JNI type signature and the
 913    generic signature of the class.
 914
 915 *******************************************************************************/
 916
 917 jvmtiError
 918 GetClassSignature (jvmtiEnv * env, jclass klass, char **signature_ptr,
 919                    char **generic_ptr)
 920 {
 921     int nsize,psize;
 922
 923     CHECK_PHASE_START
 924     CHECK_PHASE(JVMTI_PHASE_START)
 925     CHECK_PHASE(JVMTI_PHASE_LIVE)
 926     CHECK_PHASE_END;
 927
 928     if ((generic_ptr== NULL)||(signature_ptr == NULL))
 929         return JVMTI_ERROR_NULL_POINTER;
 930
 931     nsize=((classinfo*)klass)->name->blength;
 932     psize=((classinfo*)klass)->packagename->blength;
 933
 934     *signature_ptr = (char*)
 935         heap_allocate(sizeof(char)* nsize+psize+4,true,NULL);
 936
 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';
 943
 944     *generic_ptr = NULL;
 945
 946     return JVMTI_ERROR_NONE;
 947 }
 948
 949 /* *****************************************************************************
 950
 951
 952
 953 *******************************************************************************/
 954
 955 jvmtiError
 956 GetClassStatus (jvmtiEnv * env, jclass klass, jint * status_ptr)
 957 {
 958     CHECK_PHASE_START
 959     CHECK_PHASE(JVMTI_PHASE_START)
 960     CHECK_PHASE(JVMTI_PHASE_LIVE)
 961     CHECK_PHASE_END;
 962
 963   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
 964     return JVMTI_ERROR_NONE;
 965 }
 966
 967
 968 /* GetSourceFileName **********************************************************
 969
 970    For the class indicated by klass, return the source file name.
 971
 972 *******************************************************************************/
 973
 974 jvmtiError
 975 GetSourceFileName (jvmtiEnv * env, jclass klass, char **source_name_ptr)
 976 {
 977     int size;
 978
 979     CHECK_PHASE_START
 980     CHECK_PHASE(JVMTI_PHASE_START)
 981     CHECK_PHASE(JVMTI_PHASE_LIVE)
 982     CHECK_PHASE_END;
 983
 984     if ((klass == NULL)||(source_name_ptr == NULL))
 985         return JVMTI_ERROR_NULL_POINTER;
 986
 987     size = (((classinfo*)klass)->sourcefile->blength);
 988
 989     *source_name_ptr = (char*) heap_allocate(sizeof(char)* size,true,NULL);
 990
 991     memcpy(*source_name_ptr,((classinfo*)klass)->sourcefile->text, size);
 992
 993     return JVMTI_ERROR_NONE;
 994 }
 995
 996
 997 /* *****************************************************************************
 998
 999
1000
1001 *******************************************************************************/
1002
1003 jvmtiError
1004 GetClassModifiers (jvmtiEnv * env, jclass klass, jint * modifiers_ptr)
1005 {
1006       CHECK_PHASE_START
1007     CHECK_PHASE(JVMTI_PHASE_START)
1008     CHECK_PHASE(JVMTI_PHASE_LIVE)
1009     CHECK_PHASE_END;
1010
1011   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1012     return JVMTI_ERROR_NONE;
1013 }
1014
1015
1016 /* GetClassMethods *************************************************************
1017
1018    For the class indicated by klass, return a count of methods and a list of
1019    method IDs
1020
1021 *******************************************************************************/
1022
1023 jvmtiError
1024 GetClassMethods (jvmtiEnv * env, jclass klass, jint * method_count_ptr,
1025                  jmethodID ** methods_ptr)
1026 {
1027     CHECK_PHASE_START
1028     CHECK_PHASE(JVMTI_PHASE_START)
1029     CHECK_PHASE(JVMTI_PHASE_LIVE)
1030     CHECK_PHASE_END;
1031
1032     if ((klass == NULL)||(methods_ptr == NULL)||(method_count_ptr == NULL))
1033         return JVMTI_ERROR_NULL_POINTER;
1034
1035     *method_count_ptr = (jint)((classinfo*)klass)->methodscount;
1036     *methods_ptr = (jmethodID*)
1037         heap_allocate(sizeof(jmethodID) * (*method_count_ptr),true,NULL);
1038
1039     memcpy (*methods_ptr, ((classinfo*)klass)->methods,
1040             sizeof(jmethodID) * (*method_count_ptr));
1041
1042     return JVMTI_ERROR_NONE;
1043 }
1044
1045
1046 /* GetClassFields *************************************************************
1047
1048    For the class indicated by klass, return a count of fields and a list of
1049    field IDs.
1050
1051 *******************************************************************************/
1052
1053 jvmtiError
1054 GetClassFields (jvmtiEnv * env, jclass klass, jint * field_count_ptr,
1055                 jfieldID ** fields_ptr)
1056 {
1057     CHECK_PHASE_START
1058     CHECK_PHASE(JVMTI_PHASE_START)
1059     CHECK_PHASE(JVMTI_PHASE_LIVE)
1060     CHECK_PHASE_END;
1061
1062     if ((klass == NULL)||(fields_ptr == NULL)||(field_count_ptr == NULL))
1063         return JVMTI_ERROR_NULL_POINTER;
1064
1065     *field_count_ptr = (jint)((classinfo*)klass)->fieldscount;
1066     *fields_ptr = (jfieldID*)
1067         heap_allocate(sizeof(jfieldID) * (*field_count_ptr),true,NULL);
1068
1069     memcpy (*fields_ptr, ((classinfo*)klass)->fields,
1070             sizeof(jfieldID) * (*field_count_ptr));
1071
1072     return JVMTI_ERROR_NONE;
1073 }
1074
1075
1076 /* *****************************************************************************
1077
1078
1079
1080 *******************************************************************************/
1081
1082 jvmtiError
1083 GetImplementedInterfaces (jvmtiEnv * env, jclass klass,
1084                           jint * interface_count_ptr,
1085                           jclass ** interfaces_ptr)
1086 {
1087       CHECK_PHASE_START
1088     CHECK_PHASE(JVMTI_PHASE_START)
1089     CHECK_PHASE(JVMTI_PHASE_LIVE)
1090     CHECK_PHASE_END;
1091
1092   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1093     return JVMTI_ERROR_NONE;
1094 }
1095
1096
1097 /* IsInterface ****************************************************************
1098
1099    Determines whether a class object reference represents an interface.
1100
1101 *******************************************************************************/
1102
1103 jvmtiError
1104 IsInterface (jvmtiEnv * env, jclass klass, jboolean * is_interface_ptr)
1105 {
1106     CHECK_PHASE_START
1107     CHECK_PHASE(JVMTI_PHASE_START)
1108     CHECK_PHASE(JVMTI_PHASE_LIVE)
1109     CHECK_PHASE_END;
1110
1111     if ((klass == NULL)||(is_interface_ptr == NULL))
1112         return JVMTI_ERROR_NULL_POINTER;
1113
1114     *is_interface_ptr = (((classinfo*)klass)->flags & ACC_INTERFACE);
1115
1116     return JVMTI_ERROR_NONE;
1117 }
1118
1119 /* IsArrayClass ***************************************************************
1120
1121    Determines whether a class object reference represents an array.
1122
1123 *******************************************************************************/
1124
1125 jvmtiError
1126 IsArrayClass (jvmtiEnv * env, jclass klass, jboolean * is_array_class_ptr)
1127 {
1128     CHECK_PHASE_START
1129     CHECK_PHASE(JVMTI_PHASE_START)
1130     CHECK_PHASE(JVMTI_PHASE_LIVE)
1131     CHECK_PHASE_END;
1132
1133     if (is_array_class_ptr == NULL)
1134         return JVMTI_ERROR_NULL_POINTER;
1135
1136     *is_array_class_ptr = ((classinfo*)klass)->name->text[0] == '[';
1137
1138     return JVMTI_ERROR_NONE;
1139 }
1140
1141
1142 /* GetClassLoader *************************************************************
1143
1144    For the class indicated by klass, return via classloader_ptr a reference to
1145    the class loader for the class.
1146
1147 *******************************************************************************/
1148
1149 jvmtiError
1150 GetClassLoader (jvmtiEnv * env, jclass klass, jobject * classloader_ptr)
1151 {
1152     CHECK_PHASE_START
1153     CHECK_PHASE(JVMTI_PHASE_START)
1154     CHECK_PHASE(JVMTI_PHASE_LIVE)
1155     CHECK_PHASE_END;
1156
1157     if ((klass == NULL)||(classloader_ptr == NULL))
1158         return JVMTI_ERROR_NULL_POINTER;
1159
1160     *classloader_ptr = (jobject)((classinfo*)klass)->classloader;
1161
1162     return JVMTI_ERROR_NONE;
1163 }
1164
1165
1166 /* *****************************************************************************
1167
1168
1169
1170 *******************************************************************************/
1171
1172 jvmtiError
1173 GetObjectHashCode (jvmtiEnv * env, jobject object, jint * hash_code_ptr)
1174 {
1175       CHECK_PHASE_START
1176     CHECK_PHASE(JVMTI_PHASE_START)
1177     CHECK_PHASE(JVMTI_PHASE_LIVE)
1178     CHECK_PHASE_END;
1179
1180   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1181     return JVMTI_ERROR_NONE;
1182 }
1183
1184
1185 /* *****************************************************************************
1186
1187
1188
1189 *******************************************************************************/
1190
1191 jvmtiError
1192 GetObjectMonitorUsage (jvmtiEnv * env, jobject object,
1193                        jvmtiMonitorUsage * info_ptr)
1194 {
1195       CHECK_PHASE_START
1196     CHECK_PHASE(JVMTI_PHASE_START)
1197     CHECK_PHASE(JVMTI_PHASE_LIVE)
1198     CHECK_PHASE_END;
1199
1200   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1201     return JVMTI_ERROR_NONE;
1202 }
1203
1204
1205 /* GetFieldName ***************************************************************
1206
1207    For the field indicated by klass and field, return the field name and
1208    signature.
1209
1210 *******************************************************************************/
1211
1212 jvmtiError
1213 GetFieldName (jvmtiEnv * env, jclass klass, jfieldID field,
1214               char **name_ptr, char **signature_ptr, char **generic_ptr)
1215 {
1216     int size;
1217
1218     CHECK_PHASE_START
1219     CHECK_PHASE(JVMTI_PHASE_START)
1220     CHECK_PHASE(JVMTI_PHASE_LIVE)
1221     CHECK_PHASE_END;
1222
1223     if ((field == NULL)||(name_ptr == NULL)||(signature_ptr == NULL))
1224         return JVMTI_ERROR_NULL_POINTER;
1225
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);
1229
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);
1233
1234     *generic_ptr = NULL;
1235
1236     return JVMTI_ERROR_NONE;
1237 }
1238
1239
1240 /* GetFieldDeclaringClass *****************************************************
1241
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
1244    interface.
1245
1246 *******************************************************************************/
1247
1248 jvmtiError
1249 GetFieldDeclaringClass (jvmtiEnv * env, jclass klass, jfieldID field,
1250                         jclass * declaring_class_ptr)
1251 {
1252     CHECK_PHASE_START
1253     CHECK_PHASE(JVMTI_PHASE_START)
1254     CHECK_PHASE(JVMTI_PHASE_LIVE)
1255     CHECK_PHASE_END;
1256
1257     /* todo: find declaring class  */
1258
1259     return JVMTI_ERROR_NONE;
1260 }
1261
1262
1263 /* *****************************************************************************
1264
1265
1266
1267 *******************************************************************************/
1268
1269 jvmtiError
1270 GetFieldModifiers (jvmtiEnv * env, jclass klass, jfieldID field,
1271                    jint * modifiers_ptr)
1272 {
1273       CHECK_PHASE_START
1274     CHECK_PHASE(JVMTI_PHASE_START)
1275     CHECK_PHASE(JVMTI_PHASE_LIVE)
1276     CHECK_PHASE_END;
1277
1278   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1279     return JVMTI_ERROR_NONE;
1280 }
1281
1282
1283 /* *****************************************************************************
1284
1285
1286
1287 *******************************************************************************/
1288
1289 jvmtiError
1290 IsFieldSynthetic (jvmtiEnv * env, jclass klass, jfieldID field,
1291                   jboolean * is_synthetic_ptr)
1292 {
1293       CHECK_PHASE_START
1294     CHECK_PHASE(JVMTI_PHASE_START)
1295     CHECK_PHASE(JVMTI_PHASE_LIVE)
1296     CHECK_PHASE_END;
1297
1298   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1299     return JVMTI_ERROR_NONE;
1300 }
1301
1302
1303 /* GetMethodName ***************************************************************
1304
1305    For the method indicated by method, return the method name via name_ptr and
1306    method signature via signature_ptr.
1307
1308 *******************************************************************************/
1309
1310 jvmtiError
1311 GetMethodName (jvmtiEnv * env, jmethodID method, char **name_ptr,
1312                char **signature_ptr, char **generic_ptr)
1313 {
1314     methodinfo* m = (methodinfo*)method;
1315
1316     CHECK_PHASE_START
1317     CHECK_PHASE(JVMTI_PHASE_START)
1318     CHECK_PHASE(JVMTI_PHASE_LIVE)
1319     CHECK_PHASE_END;
1320
1321     if ((method == NULL) || (name_ptr == NULL) || (signature_ptr == NULL)
1322         || (generic_ptr == NULL)) return JVMTI_ERROR_NULL_POINTER;
1323
1324     *name_ptr = (char*)heap_allocate(m->name->blength,true,NULL);
1325     memcpy(*name_ptr, m->name->text, m->name->blength);
1326
1327     *signature_ptr = (char*)heap_allocate(m->descriptor->blength,true,NULL);
1328     memcpy(*signature_ptr, m->descriptor->text, m->descriptor->blength);
1329
1330     /* there is no generic signature attribute */
1331     *generic_ptr = NULL;
1332
1333     return JVMTI_ERROR_NONE;
1334 }
1335
1336
1337 /* GetMethodDeclaringClass *****************************************************
1338
1339   For the method indicated by method, return the class that defined it.
1340
1341 *******************************************************************************/
1342
1343 jvmtiError
1344 GetMethodDeclaringClass (jvmtiEnv * env, jmethodID method,
1345                          jclass * declaring_class_ptr)
1346 {
1347     CHECK_PHASE_START
1348     CHECK_PHASE(JVMTI_PHASE_START)
1349     CHECK_PHASE(JVMTI_PHASE_LIVE)
1350     CHECK_PHASE_END;
1351
1352     if ((method == NULL) || (declaring_class_ptr == NULL))
1353         return JVMTI_ERROR_NULL_POINTER;
1354
1355     *declaring_class_ptr = (jclass)((methodinfo*)method)->class;
1356
1357     return JVMTI_ERROR_NONE;
1358 }
1359
1360
1361 /* GetMethodModifiers **********************************************************
1362
1363    For the method indicated by method, return the access flags.
1364
1365 *******************************************************************************/
1366
1367 jvmtiError
1368 GetMethodModifiers (jvmtiEnv * env, jmethodID method, jint * modifiers_ptr)
1369 {
1370     CHECK_PHASE_START
1371     CHECK_PHASE(JVMTI_PHASE_START)
1372     CHECK_PHASE(JVMTI_PHASE_LIVE)
1373     CHECK_PHASE_END;
1374
1375     if ((method == NULL) || (modifiers_ptr == NULL))
1376         return JVMTI_ERROR_NULL_POINTER;
1377
1378     *modifiers_ptr = (jint) (((methodinfo*)method)->flags);
1379
1380     return JVMTI_ERROR_NONE;
1381 }
1382
1383
1384 /* GetMaxLocals ****************************************************************
1385
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.
1389
1390 *******************************************************************************/
1391
1392 jvmtiError
1393 GetMaxLocals (jvmtiEnv * env, jmethodID method, jint * max_ptr)
1394 {
1395     CHECK_PHASE_START
1396     CHECK_PHASE(JVMTI_PHASE_START)
1397     CHECK_PHASE(JVMTI_PHASE_LIVE)
1398     CHECK_PHASE_END;
1399
1400     if ((method == NULL)||(max_ptr == NULL))
1401         return JVMTI_ERROR_NULL_POINTER;
1402
1403     if (((methodinfo*)method)->flags & ACC_NATIVE)
1404         return JVMTI_ERROR_NATIVE_METHOD;
1405
1406     *max_ptr = (jint) ((methodinfo*)method)->maxlocals;
1407
1408     return JVMTI_ERROR_NONE;
1409 }
1410
1411
1412
1413 /* GetArgumentsSize ************************************************************
1414
1415    Return the number of local variable slots used by the method's arguments.
1416
1417 *******************************************************************************/
1418
1419 jvmtiError
1420 GetArgumentsSize (jvmtiEnv * env, jmethodID method, jint * size_ptr)
1421 {
1422     CHECK_PHASE_START
1423     CHECK_PHASE(JVMTI_PHASE_START)
1424     CHECK_PHASE(JVMTI_PHASE_LIVE)
1425     CHECK_PHASE_END;
1426
1427     if ((method == NULL)||(size_ptr == NULL))
1428         return JVMTI_ERROR_NULL_POINTER;
1429
1430     if (((methodinfo*)method)->flags & ACC_NATIVE)
1431         return JVMTI_ERROR_NATIVE_METHOD;
1432
1433     *size_ptr = (jint)((methodinfo*)method)->paramcount;
1434     return JVMTI_ERROR_NONE;
1435 }
1436
1437
1438
1439 /* GetLineNumberTable ***********************************************************
1440
1441    For the method indicated by method, return a table of source line number
1442    entries.
1443
1444 *******************************************************************************/
1445
1446 jvmtiError
1447 GetLineNumberTable (jvmtiEnv * env, jmethodID method,
1448                     jint * entry_count_ptr, jvmtiLineNumberEntry ** table_ptr)
1449 {
1450     int i;
1451
1452     CHECK_PHASE_START
1453     CHECK_PHASE(JVMTI_PHASE_START)
1454     CHECK_PHASE(JVMTI_PHASE_LIVE)
1455     CHECK_PHASE_END;
1456
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;
1463
1464     *entry_count_ptr= (jint)((methodinfo*)method)->linenumbercount;
1465     *table_ptr = (jvmtiLineNumberEntry*) heap_allocate(
1466         sizeof(jvmtiLineNumberEntry) * (*entry_count_ptr),true,NULL);
1467
1468
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;
1474     }
1475
1476     return JVMTI_ERROR_NONE;
1477 }
1478
1479
1480 /* GetMethodLocation ***********************************************************
1481
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
1485
1486 *******************************************************************************/
1487
1488 jvmtiError
1489 GetMethodLocation (jvmtiEnv * env, jmethodID method,
1490                    jlocation * start_location_ptr,
1491                    jlocation * end_location_ptr)
1492 {
1493     methodinfo* m = (methodinfo*)method;
1494
1495     CHECK_PHASE_START
1496     CHECK_PHASE(JVMTI_PHASE_START)
1497     CHECK_PHASE(JVMTI_PHASE_LIVE)
1498     CHECK_PHASE_END;
1499
1500     if ((method == NULL) || (start_location_ptr == NULL) ||
1501         (end_location_ptr == NULL)) return JVMTI_ERROR_NULL_POINTER;
1502
1503     *start_location_ptr = (jlocation)m->mcode;
1504     *end_location_ptr = (jlocation)(m->mcode)+m->mcodelength;
1505     return JVMTI_ERROR_NONE;
1506 }
1507
1508
1509 /* GetLocalVariableTable *******************************************************
1510
1511    Return local variable information.
1512
1513 *******************************************************************************/
1514
1515 jvmtiError
1516 GetLocalVariableTable (jvmtiEnv * env, jmethodID method,
1517                        jint * entry_count_ptr,
1518                        jvmtiLocalVariableEntry ** table_ptr)
1519 {
1520     CHECK_PHASE_START
1521     CHECK_PHASE(JVMTI_PHASE_LIVE)
1522     CHECK_PHASE_END;
1523
1524   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1525
1526     return JVMTI_ERROR_NONE;
1527 }
1528
1529
1530 /* GetBytecode *****************************************************************
1531
1532    For the method indicated by method, return the byte codes that implement the
1533    method.
1534
1535 *******************************************************************************/
1536
1537 jvmtiError
1538 GetBytecodes (jvmtiEnv * env, jmethodID method,
1539               jint * bytecode_count_ptr, unsigned char **bytecodes_ptr)
1540 {
1541     methodinfo* m = (methodinfo*)method;;
1542
1543     CHECK_PHASE_START
1544     CHECK_PHASE(JVMTI_PHASE_START)
1545     CHECK_PHASE(JVMTI_PHASE_LIVE)
1546     CHECK_PHASE_END;
1547
1548     if ((method == NULL) || (bytecode_count_ptr == NULL) ||
1549         (bytecodes_ptr == NULL)) return JVMTI_ERROR_NULL_POINTER;
1550
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);
1554
1555     return JVMTI_ERROR_NONE;
1556 }
1557
1558
1559 /* IsMethodNative **************************************************************
1560
1561    For the method indicated by method, return a value indicating whether the
1562    method is a native function
1563
1564 *******************************************************************************/
1565
1566 jvmtiError
1567 IsMethodNative (jvmtiEnv * env, jmethodID method, jboolean * is_native_ptr)
1568 {
1569     CHECK_PHASE_START
1570     CHECK_PHASE(JVMTI_PHASE_START)
1571     CHECK_PHASE(JVMTI_PHASE_LIVE)
1572     CHECK_PHASE_END;
1573
1574     if ((method == NULL)||(is_native_ptr == NULL))
1575         return JVMTI_ERROR_NULL_POINTER;
1576
1577     if (((methodinfo*)method)->flags & ACC_NATIVE)
1578         *is_native_ptr = JNI_TRUE;
1579     else
1580         *is_native_ptr = JNI_FALSE;
1581
1582     return JVMTI_ERROR_NONE;
1583 }
1584
1585
1586 /* IsMethodSynthetic ***********************************************************
1587
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.
1590
1591 *******************************************************************************/
1592
1593 jvmtiError
1594 IsMethodSynthetic (jvmtiEnv * env, jmethodID method,
1595                    jboolean * is_synthetic_ptr)
1596 {
1597     CHECK_PHASE_START
1598     CHECK_PHASE(JVMTI_PHASE_START)
1599     CHECK_PHASE(JVMTI_PHASE_LIVE)
1600     CHECK_PHASE_END;
1601
1602   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1603     return JVMTI_ERROR_NONE;
1604 }
1605
1606
1607 /* GetLoadedClasses ************************************************************
1608
1609    Return an array of all classes loaded in the virtual machine.
1610
1611 *******************************************************************************/
1612
1613 jvmtiError
1614 GetLoadedClasses (jvmtiEnv * env, jint * class_count_ptr,
1615                   jclass ** classes_ptr)
1616 {
1617     CHECK_PHASE_START
1618     CHECK_PHASE(JVMTI_PHASE_LIVE)
1619     CHECK_PHASE_END;
1620
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;
1625 }
1626
1627
1628 /* GetClassLoaderClasses *******************************************************
1629
1630    Returns an array of those classes for which this class loader has been
1631    recorded as an initiating loader.
1632
1633 *******************************************************************************/
1634
1635 jvmtiError
1636 GetClassLoaderClasses (jvmtiEnv * env, jobject initiating_loader,
1637                        jint * class_count_ptr, jclass ** classes_ptr)
1638 {
1639     CHECK_PHASE_START
1640     CHECK_PHASE(JVMTI_PHASE_LIVE)
1641     CHECK_PHASE_END;
1642
1643     if (class_count_ptr == NULL) return JVMTI_ERROR_NULL_POINTER;
1644     if (classes_ptr == NULL) return JVMTI_ERROR_NULL_POINTER;
1645
1646     log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1647     return JVMTI_ERROR_NONE;
1648 }
1649
1650
1651 /* *****************************************************************************
1652
1653
1654
1655 *******************************************************************************/
1656
1657 jvmtiError
1658 PopFrame (jvmtiEnv * env, jthread thread)
1659 {
1660     CHECK_PHASE_START
1661     CHECK_PHASE(JVMTI_PHASE_START)
1662     CHECK_PHASE(JVMTI_PHASE_LIVE)
1663     CHECK_PHASE_END;
1664
1665   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1666     return JVMTI_ERROR_NONE;
1667 }
1668
1669
1670 /* *****************************************************************************
1671
1672
1673
1674 *******************************************************************************/
1675
1676 jvmtiError
1677 RedefineClasses (jvmtiEnv * env, jint class_count,
1678                  const jvmtiClassDefinition * class_definitions)
1679 {
1680       CHECK_PHASE_START
1681     CHECK_PHASE(JVMTI_PHASE_START)
1682     CHECK_PHASE(JVMTI_PHASE_LIVE)
1683     CHECK_PHASE_END;
1684
1685   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1686     return JVMTI_ERROR_NONE;
1687 }
1688
1689
1690 /* GetVersionNumber ***********************************************************
1691
1692    Return the JVM TI version identifier.
1693
1694 *******************************************************************************/
1695
1696 jvmtiError
1697 GetVersionNumber (jvmtiEnv * env, jint * version_ptr)
1698 {
1699     if (version_ptr == NULL) return JVMTI_ERROR_NULL_POINTER;
1700
1701     *version_ptr = JVMTI_VERSION_1_0;
1702
1703     return JVMTI_ERROR_NONE;
1704 }
1705
1706
1707 /* GetCapabilities ************************************************************
1708
1709    Returns via capabilities_ptr the optional JVM TI features which this
1710    environment currently possesses.
1711
1712 *******************************************************************************/
1713
1714 jvmtiError
1715 GetCapabilities (jvmtiEnv * env, jvmtiCapabilities * capabilities_ptr)
1716 {
1717     if (capabilities_ptr == NULL) return JVMTI_ERROR_NULL_POINTER;
1718
1719     memcpy(capabilities_ptr, &(((environment*) env)->capabilities), sizeof(JVMTI_Capabilities));
1720
1721     return JVMTI_ERROR_NONE;
1722 }
1723
1724
1725 /* *****************************************************************************
1726
1727
1728
1729 *******************************************************************************/
1730
1731 jvmtiError
1732 GetSourceDebugExtension (jvmtiEnv * env, jclass klass,
1733                          char **source_debug_extension_ptr)
1734 {
1735     CHECK_PHASE_START
1736     CHECK_PHASE(JVMTI_PHASE_START)
1737     CHECK_PHASE(JVMTI_PHASE_LIVE)
1738     CHECK_PHASE_END;
1739
1740     log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1741     return JVMTI_ERROR_NONE;
1742 }
1743
1744
1745 /* IsMethodObsolete ************************************************************
1746
1747    Determine if a method ID refers to an obsolete method version.
1748
1749 *******************************************************************************/
1750
1751 jvmtiError
1752 IsMethodObsolete (jvmtiEnv * env, jmethodID method,
1753                   jboolean * is_obsolete_ptr)
1754 {
1755     CHECK_PHASE_START
1756     CHECK_PHASE(JVMTI_PHASE_START)
1757     CHECK_PHASE(JVMTI_PHASE_LIVE)
1758     CHECK_PHASE_END;
1759
1760     log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1761     return JVMTI_ERROR_NONE;
1762 }
1763
1764
1765 /* *****************************************************************************
1766
1767
1768
1769 *******************************************************************************/
1770
1771 jvmtiError
1772 SuspendThreadList (jvmtiEnv * env, jint request_count,
1773                    const jthread * request_list, jvmtiError * results)
1774 {
1775       CHECK_PHASE_START
1776     CHECK_PHASE(JVMTI_PHASE_START)
1777     CHECK_PHASE(JVMTI_PHASE_LIVE)
1778     CHECK_PHASE_END;
1779
1780   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1781     return JVMTI_ERROR_NONE;
1782 }
1783
1784
1785 /* *****************************************************************************
1786
1787
1788
1789 *******************************************************************************/
1790
1791 jvmtiError
1792 ResumeThreadList (jvmtiEnv * env, jint request_count,
1793                   const jthread * request_list, jvmtiError * results)
1794 {
1795       CHECK_PHASE_START
1796     CHECK_PHASE(JVMTI_PHASE_START)
1797     CHECK_PHASE(JVMTI_PHASE_LIVE)
1798     CHECK_PHASE_END;
1799
1800   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1801     return JVMTI_ERROR_NONE;
1802 }
1803
1804
1805 /* *****************************************************************************
1806
1807
1808
1809 *******************************************************************************/
1810
1811 jvmtiError
1812 GetAllStackTraces (jvmtiEnv * env, jint max_frame_count,
1813                    jvmtiStackInfo ** stack_info_ptr, jint * thread_count_ptr)
1814 {
1815       CHECK_PHASE_START
1816     CHECK_PHASE(JVMTI_PHASE_START)
1817     CHECK_PHASE(JVMTI_PHASE_LIVE)
1818     CHECK_PHASE_END;
1819
1820   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1821     return JVMTI_ERROR_NONE;
1822 }
1823
1824
1825 /* *****************************************************************************
1826
1827
1828
1829 *******************************************************************************/
1830
1831 jvmtiError
1832 GetThreadListStackTraces (jvmtiEnv * env, jint thread_count,
1833                           const jthread * thread_list,
1834                           jint max_frame_count,
1835                           jvmtiStackInfo ** stack_info_ptr)
1836 {
1837       CHECK_PHASE_START
1838     CHECK_PHASE(JVMTI_PHASE_START)
1839     CHECK_PHASE(JVMTI_PHASE_LIVE)
1840     CHECK_PHASE_END;
1841
1842   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1843     return JVMTI_ERROR_NONE;
1844 }
1845
1846
1847 /* *****************************************************************************
1848
1849
1850
1851 *******************************************************************************/
1852
1853 jvmtiError
1854 GetThreadLocalStorage (jvmtiEnv * env, jthread thread, void **data_ptr)
1855 {
1856       CHECK_PHASE_START
1857     CHECK_PHASE(JVMTI_PHASE_START)
1858     CHECK_PHASE(JVMTI_PHASE_LIVE)
1859     CHECK_PHASE_END;
1860
1861   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1862     return JVMTI_ERROR_NONE;
1863 }
1864
1865
1866 /* *****************************************************************************
1867
1868
1869
1870 *******************************************************************************/
1871
1872 jvmtiError
1873 SetThreadLocalStorage (jvmtiEnv * env, jthread thread, const void *data)
1874 {
1875       CHECK_PHASE_START
1876     CHECK_PHASE(JVMTI_PHASE_START)
1877     CHECK_PHASE(JVMTI_PHASE_LIVE)
1878     CHECK_PHASE_END;
1879
1880   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1881     return JVMTI_ERROR_NONE;
1882 }
1883
1884
1885 /* *****************************************************************************
1886
1887
1888
1889 *******************************************************************************/
1890
1891 jvmtiError
1892 GetStackTrace (jvmtiEnv * env, jthread thread, jint start_depth,
1893                jint max_frame_count, jvmtiFrameInfo * frame_buffer,
1894                jint * count_ptr)
1895 {
1896       CHECK_PHASE_START
1897     CHECK_PHASE(JVMTI_PHASE_START)
1898     CHECK_PHASE(JVMTI_PHASE_LIVE)
1899     CHECK_PHASE_END;
1900
1901   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1902     return JVMTI_ERROR_NONE;
1903 }
1904
1905 /* *****************************************************************************
1906
1907
1908
1909 *******************************************************************************/
1910
1911 jvmtiError
1912 GetTag (jvmtiEnv * env, jobject object, jlong * tag_ptr)
1913 {
1914       CHECK_PHASE_START
1915     CHECK_PHASE(JVMTI_PHASE_START)
1916     CHECK_PHASE(JVMTI_PHASE_LIVE)
1917     CHECK_PHASE_END;
1918
1919   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1920     return JVMTI_ERROR_NONE;
1921 }
1922
1923 /* *****************************************************************************
1924
1925
1926
1927 *******************************************************************************/
1928
1929 jvmtiError
1930 SetTag (jvmtiEnv * env, jobject object, jlong tag)
1931 {
1932       CHECK_PHASE_START
1933     CHECK_PHASE(JVMTI_PHASE_START)
1934     CHECK_PHASE(JVMTI_PHASE_LIVE)
1935     CHECK_PHASE_END;
1936
1937   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1938     return JVMTI_ERROR_NONE;
1939 }
1940
1941
1942 /* *****************************************************************************
1943
1944
1945
1946 *******************************************************************************/
1947
1948 jvmtiError
1949 ForceGarbageCollection (jvmtiEnv * env)
1950 {
1951       CHECK_PHASE_START
1952     CHECK_PHASE(JVMTI_PHASE_START)
1953     CHECK_PHASE(JVMTI_PHASE_LIVE)
1954     CHECK_PHASE_END;
1955
1956   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1957     return JVMTI_ERROR_NONE;
1958 }
1959
1960
1961 /* *****************************************************************************
1962
1963
1964
1965 *******************************************************************************/
1966
1967 jvmtiError
1968 IterateOverObjectsReachableFromObject (jvmtiEnv * env, jobject object,
1969                                        jvmtiObjectReferenceCallback
1970                                        object_reference_callback,
1971                                        void *user_data)
1972 {
1973       CHECK_PHASE_START
1974     CHECK_PHASE(JVMTI_PHASE_START)
1975     CHECK_PHASE(JVMTI_PHASE_LIVE)
1976     CHECK_PHASE_END;
1977
1978   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
1979     return JVMTI_ERROR_NONE;
1980 }
1981
1982
1983 /* *****************************************************************************
1984
1985
1986
1987 *******************************************************************************/
1988
1989 jvmtiError
1990 IterateOverReachableObjects (jvmtiEnv * env, jvmtiHeapRootCallback
1991                              heap_root_callback,
1992                              jvmtiStackReferenceCallback
1993                              stack_ref_callback,
1994                              jvmtiObjectReferenceCallback
1995                              object_ref_callback, void *user_data)
1996 {
1997       CHECK_PHASE_START
1998     CHECK_PHASE(JVMTI_PHASE_START)
1999     CHECK_PHASE(JVMTI_PHASE_LIVE)
2000     CHECK_PHASE_END;
2001
2002   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
2003     return JVMTI_ERROR_NONE;
2004 }
2005
2006
2007 /* *****************************************************************************
2008
2009
2010
2011 *******************************************************************************/
2012
2013 jvmtiError
2014 IterateOverHeap (jvmtiEnv * env, jvmtiHeapObjectFilter object_filter,
2015                  jvmtiHeapObjectCallback heap_object_callback,
2016                  void *user_data)
2017 {
2018       CHECK_PHASE_START
2019     CHECK_PHASE(JVMTI_PHASE_START)
2020     CHECK_PHASE(JVMTI_PHASE_LIVE)
2021     CHECK_PHASE_END;
2022
2023   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
2024     return JVMTI_ERROR_NONE;
2025 }
2026
2027
2028 /* *****************************************************************************
2029
2030
2031
2032 *******************************************************************************/
2033
2034 jvmtiError
2035 IterateOverInstancesOfClass (jvmtiEnv * env, jclass klass,
2036                              jvmtiHeapObjectFilter object_filter,
2037                              jvmtiHeapObjectCallback
2038                              heap_object_callback, void *user_data)
2039 {
2040       CHECK_PHASE_START
2041     CHECK_PHASE(JVMTI_PHASE_START)
2042     CHECK_PHASE(JVMTI_PHASE_LIVE)
2043     CHECK_PHASE_END;
2044
2045   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
2046     return JVMTI_ERROR_NONE;
2047 }
2048
2049
2050 /* *****************************************************************************
2051
2052
2053
2054 *******************************************************************************/
2055
2056 jvmtiError
2057 GetObjectsWithTags (jvmtiEnv * env, jint tag_count, const jlong * tags,
2058                     jint * count_ptr, jobject ** object_result_ptr,
2059                     jlong ** tag_result_ptr)
2060 {
2061       CHECK_PHASE_START
2062     CHECK_PHASE(JVMTI_PHASE_START)
2063     CHECK_PHASE(JVMTI_PHASE_LIVE)
2064     CHECK_PHASE_END;
2065
2066   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
2067     return JVMTI_ERROR_NONE;
2068 }
2069
2070
2071 /* SetJNIFunctionTable **********************************************************
2072
2073    Set the JNI function table in all current and future JNI environments
2074
2075 *******************************************************************************/
2076
2077 jvmtiError
2078 SetJNIFunctionTable (jvmtiEnv * env,
2079                      const jniNativeInterface * function_table)
2080 {
2081     CHECK_PHASE_START
2082     CHECK_PHASE(JVMTI_PHASE_START)
2083     CHECK_PHASE(JVMTI_PHASE_LIVE)
2084     CHECK_PHASE_END;;
2085
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;
2090 }
2091
2092
2093 /* GetJNIFunctionTable *********************************************************
2094
2095    Get the JNI function table. The JNI function table is copied into allocated
2096    memory.
2097
2098 *******************************************************************************/
2099
2100 jvmtiError
2101 GetJNIFunctionTable (jvmtiEnv * env, jniNativeInterface ** function_table)
2102 {
2103     CHECK_PHASE_START
2104     CHECK_PHASE(JVMTI_PHASE_START)
2105     CHECK_PHASE(JVMTI_PHASE_LIVE)
2106     CHECK_PHASE_END;
2107
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;
2113 }
2114
2115
2116 /* SetEventCallbacks **********************************************************
2117
2118    Set the functions to be called for each event. The callbacks are specified
2119    by supplying a replacement function table.
2120
2121 *******************************************************************************/
2122
2123 jvmtiError
2124 SetEventCallbacks (jvmtiEnv * env,
2125                    const jvmtiEventCallbacks * callbacks,
2126                    jint size_of_callbacks)
2127 {
2128     CHECK_PHASE_START
2129     CHECK_PHASE(JVMTI_PHASE_ONLOAD)
2130     CHECK_PHASE(JVMTI_PHASE_LIVE)
2131     CHECK_PHASE_END;
2132
2133     if (size_of_callbacks < 0) return JVMTI_ERROR_ILLEGAL_ARGUMENT;
2134
2135     if (callbacks == NULL) { /* remove the existing callbacks */
2136         memset(&(((environment* )env)->callbacks), 0, sizeof(jvmtiEventCallbacks));
2137     }
2138
2139     memcpy (&(((environment* )env)->callbacks),callbacks,size_of_callbacks);
2140
2141     return JVMTI_ERROR_NONE;
2142 }
2143
2144
2145 /* *****************************************************************************
2146
2147
2148
2149 *******************************************************************************/
2150
2151 jvmtiError
2152 GenerateEvents (jvmtiEnv * env, jvmtiEvent event_type)
2153 {
2154     CHECK_PHASE_START
2155     CHECK_PHASE(JVMTI_PHASE_START)
2156     CHECK_PHASE(JVMTI_PHASE_LIVE)
2157     CHECK_PHASE_END;
2158
2159   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
2160     return JVMTI_ERROR_NONE;
2161 }
2162
2163
2164 /* GetExtensionFunctions ******************************************************
2165
2166    Returns the set of extension functions.
2167
2168 *******************************************************************************/
2169
2170 jvmtiError
2171 GetExtensionFunctions (jvmtiEnv * env, jint * extension_count_ptr,
2172                        jvmtiExtensionFunctionInfo ** extensions)
2173 {
2174     CHECK_PHASE_START
2175     CHECK_PHASE(JVMTI_PHASE_ONLOAD)
2176     CHECK_PHASE(JVMTI_PHASE_LIVE)
2177     CHECK_PHASE_END;
2178
2179     if ((extension_count_ptr== NULL)||(extensions == NULL))
2180         return JVMTI_ERROR_NULL_POINTER;
2181
2182     /* cacao has no extended functions yet */
2183     *extension_count_ptr = 0;
2184
2185     return JVMTI_ERROR_NONE;
2186 }
2187
2188
2189 /* GetExtensionEvents *********************************************************
2190
2191    Returns the set of extension events.
2192
2193 *******************************************************************************/
2194
2195 jvmtiError
2196 GetExtensionEvents (jvmtiEnv * env, jint * extension_count_ptr,
2197                     jvmtiExtensionEventInfo ** extensions)
2198 {
2199     CHECK_PHASE_START
2200     CHECK_PHASE(JVMTI_PHASE_ONLOAD)
2201     CHECK_PHASE(JVMTI_PHASE_LIVE)
2202     CHECK_PHASE_END;
2203
2204     if ((extension_count_ptr== NULL)||(extensions == NULL))
2205         return JVMTI_ERROR_NULL_POINTER;
2206
2207     /* cacao has no extended events yet */
2208     *extension_count_ptr = 0;
2209
2210     return JVMTI_ERROR_NONE;
2211 }
2212
2213
2214 /* SetExtensionEventCallback **************************************************
2215
2216    Sets the callback function for an extension event and enables the event.
2217
2218 *******************************************************************************/
2219
2220 jvmtiError
2221 SetExtensionEventCallback (jvmtiEnv * env, jint extension_event_index,
2222                            jvmtiExtensionEvent callback)
2223 {
2224     CHECK_PHASE_START
2225     CHECK_PHASE(JVMTI_PHASE_ONLOAD)
2226     CHECK_PHASE(JVMTI_PHASE_LIVE)
2227     CHECK_PHASE_END;
2228
2229     /* cacao has no extended events yet */
2230     return JVMTI_ERROR_ILLEGAL_ARGUMENT;
2231 }
2232
2233
2234 /* DisposeEnvironment **********************************************************
2235
2236    Shutdown a JVM TI connection created with JNI GetEnv.
2237
2238 *******************************************************************************/
2239
2240 jvmtiError
2241 DisposeEnvironment (jvmtiEnv * env)
2242 {
2243     ((environment* )env)->events = NULL;
2244     ((environment* )env)->EnvironmentLocalStorage = NULL;
2245     /* let Boehm GC do the rest */
2246     return JVMTI_ERROR_NONE;
2247 }
2248
2249
2250 /* GetErrorName ***************************************************************
2251
2252    Return the symbolic name for an error code.
2253
2254 *******************************************************************************/
2255
2256 #define COPY_RESPONSE(name_ptr,str) *name_ptr = (char*) heap_allocate(sizeof(str),true,NULL); \
2257                                     memcpy(*name_ptr, &str, sizeof(str)); \
2258                                     break
2259
2260 jvmtiError
2261 GetErrorName (jvmtiEnv * env, jvmtiError error, char **name_ptr)
2262 {
2263     if (name_ptr == NULL) return JVMTI_ERROR_NULL_POINTER;
2264
2265     switch (error) {
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");
2362     default:
2363         return JVMTI_ERROR_ILLEGAL_ARGUMENT;
2364     }
2365     return JVMTI_ERROR_NONE;
2366 }
2367
2368 /* GetJLocationFormat **********************************************************
2369
2370    This function describes the representation of jlocation used in this VM.
2371
2372 *******************************************************************************/
2373
2374 jvmtiError
2375 GetJLocationFormat (jvmtiEnv * env, jvmtiJlocationFormat * format_ptr)
2376 {
2377     *format_ptr = JVMTI_JLOCATION_MACHINEPC;
2378     return JVMTI_ERROR_NONE;
2379 }
2380
2381
2382 /* GetSystemProperties ********************************************************
2383
2384    The list of VM system property keys which may be used with GetSystemProperty
2385    is returned.
2386
2387 *******************************************************************************/
2388
2389 jvmtiError
2390 GetSystemProperties (jvmtiEnv * env, jint * count_ptr, char ***property_ptr)
2391 {
2392     jmethodID mid;
2393     jmethodID moremid;
2394     classinfo *sysclass, *propclass, *enumclass;
2395     java_objectheader *sysprop, *keys, *obj;
2396     char* ch;
2397     int i;
2398
2399     CHECK_PHASE_START
2400     CHECK_PHASE(JVMTI_PHASE_ONLOAD)
2401     CHECK_PHASE(JVMTI_PHASE_LIVE)
2402     CHECK_PHASE_END;
2403
2404     if ((count_ptr == NULL) || (property_ptr == NULL))
2405         return JVMTI_ERROR_NULL_POINTER;
2406
2407     sysclass = load_class_from_sysloader(
2408         utf_new_char_classname ("java/lang/System"));
2409
2410     if (!sysclass) throw_main_exception_exit();
2411
2412     mid = class_resolvemethod(sysclass,
2413                               utf_new_char("getProperties"),
2414                               utf_new_char("()Ljava/util/Properties;"));
2415     if (!mid) throw_main_exception_exit();
2416
2417
2418     sysprop = asm_calljavafunction(mid, sysclass, NULL, NULL, NULL);
2419     if (!sysprop) throw_main_exception_exit();
2420
2421     propclass = sysprop->vftbl->class;
2422
2423     mid = class_resolvemethod(propclass,
2424                               utf_new_char("size"),
2425                               utf_new_char("()I"));
2426     if (!mid) throw_main_exception_exit();
2427
2428     *count_ptr =
2429         JNI_JNIEnvTable.CallIntMethod(NULL, sysprop, mid);
2430     *property_ptr = heap_allocate(sizeof(char*) * (*count_ptr) ,true,NULL);
2431
2432     mid = class_resolvemethod(propclass,
2433                               utf_new_char("keys"),
2434                               utf_new_char("()Ljava/util/Enumeration;"));
2435     if (!mid) throw_main_exception_exit();
2436
2437     keys = JNI_JNIEnvTable.CallObjectMethod(NULL, sysprop, mid);
2438     enumclass = keys->vftbl->class;
2439
2440     moremid = class_resolvemethod(enumclass,
2441                                   utf_new_char("hasMoreElements"),
2442                                   utf_new_char("()Z"));
2443     if (!moremid) throw_main_exception_exit();
2444
2445     mid = class_resolvemethod(propclass,
2446                               utf_new_char("nextElement"),
2447                               utf_new_char("()Ljava/lang/Object;"));
2448     if (!mid) throw_main_exception_exit();
2449
2450     i = 0;
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);
2457         i++;
2458     }
2459
2460     return JVMTI_ERROR_NONE;
2461 }
2462
2463
2464 /* GetSystemProperty **********************************************************
2465
2466    Return a VM system property value given the property key.
2467
2468 *******************************************************************************/
2469
2470 jvmtiError
2471 GetSystemProperty (jvmtiEnv * env, const char *property, char **value_ptr)
2472 {
2473     jmethodID mid;
2474     classinfo *sysclass, *propclass;
2475     java_objectheader *sysprop, *obj;
2476     char* ch;
2477
2478     CHECK_PHASE_START
2479     CHECK_PHASE(JVMTI_PHASE_ONLOAD)
2480     CHECK_PHASE(JVMTI_PHASE_LIVE)
2481     CHECK_PHASE_END;
2482
2483     if ((value_ptr == NULL) || (property == NULL))
2484         return JVMTI_ERROR_NULL_POINTER;
2485
2486     sysclass = load_class_from_sysloader(utf_new_char("java/lang/System"));
2487     if (!sysclass) throw_main_exception_exit();
2488
2489     mid = class_resolvemethod(sysclass,
2490                               utf_new_char("getProperties"),
2491                               utf_new_char("()Ljava/util/Properties;"));
2492     if (!mid) throw_main_exception_exit();
2493
2494     sysprop = JNI_JNIEnvTable.CallStaticObjectMethod(NULL, (jclass)sysclass, mid);
2495
2496     propclass = sysprop->vftbl->class;
2497
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();
2502
2503     obj = (java_objectheader*)JNI_JNIEnvTable.CallObjectMethod(
2504         NULL, sysprop, mid, javastring_new_char(property));
2505     if (!obj) return JVMTI_ERROR_NOT_AVAILABLE;
2506
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);
2511
2512     return JVMTI_ERROR_NONE;
2513 }
2514
2515
2516 /* SetSystemProperty **********************************************************
2517
2518    Set a VM system property value.
2519
2520 *******************************************************************************/
2521
2522 jvmtiError
2523 SetSystemProperty (jvmtiEnv * env, const char *property, const char *value)
2524 {
2525     jmethodID mid;
2526     classinfo *sysclass, *propclass;
2527     java_objectheader *sysprop;
2528
2529     CHECK_PHASE_START
2530     CHECK_PHASE(JVMTI_PHASE_START)
2531     CHECK_PHASE_END;
2532
2533     if (property == NULL) return JVMTI_ERROR_NULL_POINTER;
2534     if (value == NULL) return JVMTI_ERROR_NOT_AVAILABLE;
2535
2536     sysclass = load_class_from_sysloader(utf_new_char("java/lang/System"));
2537     if (!sysclass) throw_main_exception_exit();
2538
2539     mid = class_resolvemethod(sysclass,
2540                               utf_new_char("getProperties"),
2541                               utf_new_char("()Ljava/util/Properties;"));
2542     if (!mid) throw_main_exception_exit();
2543
2544     sysprop = JNI_JNIEnvTable.CallStaticObjectMethod(NULL, (jclass)sysclass, mid);
2545
2546     propclass = sysprop->vftbl->class;
2547
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();
2552
2553     JNI_JNIEnvTable.CallObjectMethod(
2554         NULL, sysprop, mid, javastring_new_char(property),javastring_new_char(value));
2555
2556     return JVMTI_ERROR_NONE;
2557 }
2558
2559 /* GetPhase ********************************************************************
2560
2561    Return the current phase of VM execution
2562
2563 *******************************************************************************/
2564
2565 jvmtiError
2566 GetPhase (jvmtiEnv * env, jvmtiPhase * phase_ptr)
2567 {
2568     if (phase_ptr == NULL) return JVMTI_ERROR_NULL_POINTER;
2569
2570     *phase_ptr = phase;
2571
2572     return JVMTI_ERROR_NONE;
2573 }
2574
2575 /* *****************************************************************************
2576
2577
2578
2579 *******************************************************************************/
2580
2581 jvmtiError
2582 GetCurrentThreadCpuTimerInfo (jvmtiEnv * env, jvmtiTimerInfo * info_ptr)
2583 {
2584       CHECK_PHASE_START
2585     CHECK_PHASE(JVMTI_PHASE_START)
2586     CHECK_PHASE(JVMTI_PHASE_LIVE)
2587     CHECK_PHASE_END;
2588
2589   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
2590     return JVMTI_ERROR_NONE;
2591 }
2592
2593 /* *****************************************************************************
2594
2595
2596
2597 *******************************************************************************/
2598
2599 jvmtiError
2600 GetCurrentThreadCpuTime (jvmtiEnv * env, jlong * nanos_ptr)
2601 {
2602       CHECK_PHASE_START
2603     CHECK_PHASE(JVMTI_PHASE_START)
2604     CHECK_PHASE(JVMTI_PHASE_LIVE)
2605     CHECK_PHASE_END;
2606
2607   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
2608     return JVMTI_ERROR_NONE;
2609 }
2610
2611 /* *****************************************************************************
2612
2613
2614
2615 *******************************************************************************/
2616
2617 jvmtiError
2618 GetThreadCpuTimerInfo (jvmtiEnv * env, jvmtiTimerInfo * info_ptr)
2619 {
2620       CHECK_PHASE_START
2621     CHECK_PHASE(JVMTI_PHASE_START)
2622     CHECK_PHASE(JVMTI_PHASE_LIVE)
2623     CHECK_PHASE_END;
2624
2625   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
2626     return JVMTI_ERROR_NONE;
2627 }
2628
2629 /* *****************************************************************************
2630
2631
2632
2633 *******************************************************************************/
2634
2635 jvmtiError
2636 GetThreadCpuTime (jvmtiEnv * env, jthread thread, jlong * nanos_ptr)
2637 {
2638       CHECK_PHASE_START
2639     CHECK_PHASE(JVMTI_PHASE_START)
2640     CHECK_PHASE(JVMTI_PHASE_LIVE)
2641     CHECK_PHASE_END;
2642
2643   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
2644     return JVMTI_ERROR_NONE;
2645 }
2646
2647 /* *****************************************************************************
2648
2649
2650
2651 *******************************************************************************/
2652
2653 jvmtiError
2654 GetTimerInfo (jvmtiEnv * env, jvmtiTimerInfo * info_ptr)
2655 {
2656       CHECK_PHASE_START
2657     CHECK_PHASE(JVMTI_PHASE_START)
2658     CHECK_PHASE(JVMTI_PHASE_LIVE)
2659     CHECK_PHASE_END;
2660
2661   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
2662     return JVMTI_ERROR_NONE;
2663 }
2664
2665 /* GetTime ********************************************************************
2666
2667    Return the current value of the system timer, in nanoseconds
2668
2669 *******************************************************************************/
2670
2671 jvmtiError
2672 GetTime (jvmtiEnv * env, jlong * nanos_ptr)
2673 {
2674     /* Note: this implementation copied directly from Japhar's, by Chris Toshok. */
2675     struct timeval tp;
2676
2677     if (nanos_ptr == NULL) return JVMTI_ERROR_NULL_POINTER;
2678
2679     if (gettimeofday (&tp, NULL) == -1)
2680         JNI_JNIEnvTable.FatalError (NULL, "gettimeofday call failed.");
2681
2682     *nanos_ptr = (jlong) tp.tv_sec;
2683     *nanos_ptr *= 1000;
2684     *nanos_ptr += (tp.tv_usec / 1000);
2685
2686     return JVMTI_ERROR_NONE;
2687 }
2688
2689 /* GetPotentialCapabilities ***************************************************
2690
2691    Returns the JVM TI features that can potentially be possessed by this
2692    environment at this time.
2693
2694 *******************************************************************************/
2695
2696 jvmtiError
2697 GetPotentialCapabilities (jvmtiEnv * env,
2698                           jvmtiCapabilities * capabilities_ptr)
2699 {
2700     CHECK_PHASE_START
2701     CHECK_PHASE(JVMTI_PHASE_ONLOAD)
2702     CHECK_PHASE(JVMTI_PHASE_LIVE)
2703     CHECK_PHASE_END;
2704
2705     if (capabilities_ptr == NULL) return JVMTI_ERROR_NULL_POINTER;
2706
2707     memcpy(capabilities_ptr, &JVMTI_Capabilities, sizeof(JVMTI_Capabilities));
2708
2709     return JVMTI_ERROR_NONE;
2710 }
2711
2712
2713 jvmtiError static capabilityerror()
2714 {
2715     return JVMTI_ERROR_MUST_POSSESS_CAPABILITY;
2716 }
2717
2718 #define CHECK_POTENTIAL_AVAILABLE(CAN)      \
2719         if ((capabilities_ptr->CAN == 1) && \
2720            (JVMTI_Capabilities.CAN == 0))   \
2721            return JVMTI_ERROR_NOT_AVAILABLE;
2722
2723
2724 /* AddCapabilities ************************************************************
2725
2726    Set new capabilities by adding the capabilities pointed to by
2727    capabilities_ptr. All previous capabilities are retained.
2728
2729 *******************************************************************************/
2730
2731 jvmtiError
2732 AddCapabilities (jvmtiEnv * env, const jvmtiCapabilities * capabilities_ptr)
2733 {
2734     environment* cacao_env;
2735
2736     CHECK_PHASE_START
2737     CHECK_PHASE(JVMTI_PHASE_ONLOAD)
2738     CHECK_PHASE(JVMTI_PHASE_LIVE)
2739     CHECK_PHASE_END;
2740
2741     if ((env == NULL) || (capabilities_ptr == NULL))
2742         return JVMTI_ERROR_NULL_POINTER;
2743
2744     cacao_env = (environment*)env;
2745
2746     CHECK_POTENTIAL_AVAILABLE(can_tag_objects)
2747     else {
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;
2758     }
2759
2760     CHECK_POTENTIAL_AVAILABLE(can_generate_field_modification_events)
2761     else {
2762         cacao_env->capabilities.can_generate_field_modification_events = 1;
2763         env->SetFieldModificationWatch = &SetFieldModificationWatch;
2764         env->SetEventNotificationMode = &SetEventNotificationMode;
2765     }
2766
2767     CHECK_POTENTIAL_AVAILABLE(can_generate_field_access_events)
2768     else {
2769         cacao_env->capabilities.can_generate_field_access_events = 1;
2770         env->SetFieldAccessWatch = &SetFieldAccessWatch;
2771     }
2772
2773     CHECK_POTENTIAL_AVAILABLE(can_get_bytecodes)
2774     else {
2775         cacao_env->capabilities.can_get_bytecodes  = 1;
2776         env->GetBytecodes = &GetBytecodes;
2777     }
2778
2779     CHECK_POTENTIAL_AVAILABLE(can_get_synthetic_attribute)
2780     else {
2781         cacao_env->capabilities.can_get_synthetic_attribute  = 1;
2782         env->IsFieldSynthetic = &IsFieldSynthetic;
2783         env->IsMethodSynthetic = &IsMethodSynthetic;
2784     }
2785
2786     CHECK_POTENTIAL_AVAILABLE(can_get_owned_monitor_info)
2787     else {
2788         cacao_env->capabilities.can_get_owned_monitor_info  = 1;
2789         env->GetOwnedMonitorInfo = &GetOwnedMonitorInfo;
2790     }
2791
2792     CHECK_POTENTIAL_AVAILABLE(can_get_current_contended_monitor)
2793     else {
2794         cacao_env->capabilities.can_get_current_contended_monitor  = 1;
2795         env->GetCurrentContendedMonitor = &GetCurrentContendedMonitor;
2796     }
2797
2798     CHECK_POTENTIAL_AVAILABLE(can_get_monitor_info)
2799     else {
2800         cacao_env->capabilities.can_get_monitor_info  = 1;
2801         env->GetObjectMonitorUsage  = &GetObjectMonitorUsage;
2802     }
2803
2804     CHECK_POTENTIAL_AVAILABLE(can_pop_frame)
2805     else {
2806         cacao_env->capabilities.can_pop_frame  = 1;
2807         env->PopFrame  = &PopFrame;
2808     }
2809
2810     CHECK_POTENTIAL_AVAILABLE(can_redefine_classes)
2811     else {
2812         cacao_env->capabilities.can_redefine_classes  = 1;
2813         env->RedefineClasses = &RedefineClasses;
2814     }
2815
2816     CHECK_POTENTIAL_AVAILABLE(can_signal_thread)
2817     else {
2818         cacao_env->capabilities.can_signal_thread  = 1;
2819         env->StopThread = &StopThread;
2820         env->InterruptThread = &InterruptThread;
2821     }
2822
2823     CHECK_POTENTIAL_AVAILABLE(can_get_source_file_name)
2824     else {
2825         cacao_env->capabilities.can_get_source_file_name  = 1;
2826         env->GetSourceFileName = &GetSourceFileName;
2827     }
2828
2829     CHECK_POTENTIAL_AVAILABLE(can_get_line_numbers)
2830     else {
2831         cacao_env->capabilities.can_get_line_numbers  = 1;
2832         env->GetLineNumberTable = &GetLineNumberTable;
2833     }
2834
2835     CHECK_POTENTIAL_AVAILABLE(can_get_source_debug_extension)
2836     else {
2837         cacao_env->capabilities.can_get_source_debug_extension  = 1;
2838         env->GetSourceDebugExtension = &GetSourceDebugExtension;
2839     }
2840
2841     CHECK_POTENTIAL_AVAILABLE(can_access_local_variables)
2842     else {
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;
2855     }
2856
2857     CHECK_POTENTIAL_AVAILABLE(can_maintain_original_method_order)
2858     else {
2859         cacao_env->capabilities.can_maintain_original_method_order  = 1;
2860         env->GetClassMethods  = &GetClassMethods;
2861     }
2862
2863     CHECK_POTENTIAL_AVAILABLE(can_generate_single_step_events)
2864     else {
2865         cacao_env->capabilities.can_generate_single_step_events  = 1;
2866         env->SetEventNotificationMode = &SetEventNotificationMode;
2867     }
2868
2869     CHECK_POTENTIAL_AVAILABLE(can_generate_exception_events)
2870     else {
2871         cacao_env->capabilities.can_generate_exception_events  = 1;
2872         /* env->  = &; */
2873     }
2874
2875     CHECK_POTENTIAL_AVAILABLE(can_generate_frame_pop_events)
2876     else {
2877         cacao_env->capabilities.can_generate_frame_pop_events  = 1;
2878         /* env->  = &; */
2879     }
2880
2881     CHECK_POTENTIAL_AVAILABLE(can_generate_breakpoint_events)
2882     else {
2883         cacao_env->capabilities.can_generate_breakpoint_events  = 1;
2884         /* env->  = &; */
2885     }
2886
2887     CHECK_POTENTIAL_AVAILABLE(can_suspend)
2888     else {
2889         cacao_env->capabilities.can_suspend  = 1;
2890         /* env->  = &; */
2891     }
2892
2893     CHECK_POTENTIAL_AVAILABLE(can_redefine_any_class)
2894     else {
2895         cacao_env->capabilities.can_redefine_any_class  = 1;
2896         /* env->  = &; */
2897     }
2898
2899     CHECK_POTENTIAL_AVAILABLE(can_get_current_thread_cpu_time)
2900     else {
2901         cacao_env->capabilities.can_get_current_thread_cpu_time  = 1;
2902         /* env->  = &; */
2903     }
2904
2905     CHECK_POTENTIAL_AVAILABLE(can_get_thread_cpu_time)
2906     else {
2907         cacao_env->capabilities.can_get_thread_cpu_time  = 1;
2908         /* env->  = &; */
2909     }
2910
2911     CHECK_POTENTIAL_AVAILABLE(can_generate_method_entry_events)
2912     else {
2913         cacao_env->capabilities.can_generate_method_entry_events  = 1;
2914         /* env->  = &; */
2915     }
2916
2917     CHECK_POTENTIAL_AVAILABLE(can_generate_method_exit_events)
2918     else {
2919         cacao_env->capabilities.can_generate_method_exit_events  = 1;
2920         /* env->  = &; */
2921     }
2922
2923     CHECK_POTENTIAL_AVAILABLE(can_generate_all_class_hook_events)
2924     else {
2925         cacao_env->capabilities.can_generate_all_class_hook_events  = 1;
2926         /* env->  = &; */
2927     }
2928
2929     CHECK_POTENTIAL_AVAILABLE(can_generate_compiled_method_load_events)
2930     else {
2931         cacao_env->capabilities.can_generate_compiled_method_load_events  = 1;
2932         /* env->  = &; */
2933     }
2934
2935     CHECK_POTENTIAL_AVAILABLE(can_generate_monitor_events)
2936     else {
2937         cacao_env->capabilities.can_generate_monitor_events= 1;
2938         /* env->  = &; */
2939     }
2940
2941     CHECK_POTENTIAL_AVAILABLE(can_generate_vm_object_alloc_events)
2942     else {
2943         cacao_env->capabilities.can_generate_vm_object_alloc_events  = 1;
2944         /* env->  = &; */
2945     }
2946
2947     CHECK_POTENTIAL_AVAILABLE(can_generate_native_method_bind_events)
2948     else {
2949         cacao_env->capabilities.can_generate_native_method_bind_events  = 1;
2950         /* env->  = &; */
2951     }
2952
2953     CHECK_POTENTIAL_AVAILABLE(can_generate_garbage_collection_events)
2954     else {
2955         cacao_env->capabilities.can_generate_garbage_collection_events  = 1;
2956         /* env->  = &; */
2957     }
2958
2959     CHECK_POTENTIAL_AVAILABLE(can_generate_object_free_events)
2960     else {
2961         cacao_env->capabilities.can_generate_object_free_events  = 1;
2962         /* env->  = &; */
2963     }
2964
2965     return JVMTI_ERROR_NONE;
2966 }
2967
2968 /* RelinquishCapabilities *****************************************************
2969
2970    Relinquish the capabilities pointed to by capabilities_ptr.
2971
2972 *******************************************************************************/
2973
2974 jvmtiError
2975 RelinquishCapabilities (jvmtiEnv * env,
2976                         const jvmtiCapabilities * capabilities_ptr)
2977 {
2978     environment* cacao_env;
2979
2980     CHECK_PHASE_START
2981     CHECK_PHASE(JVMTI_PHASE_ONLOAD)
2982     CHECK_PHASE(JVMTI_PHASE_LIVE)
2983     CHECK_PHASE_END;
2984
2985     if ((env == NULL) || (capabilities_ptr == NULL))
2986         return JVMTI_ERROR_NULL_POINTER;
2987
2988     cacao_env = (environment*)env;
2989
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;
2999     }
3000
3001 /*    todo if ((capabilities_ptr->  == 1) {
3002         cacao_env->capabilities.  = 0;
3003         env->SetFieldModificationWatch = &capabilityerror;
3004         }*/
3005
3006
3007     return JVMTI_ERROR_NONE;
3008 }
3009
3010 /* *****************************************************************************
3011
3012
3013
3014 *******************************************************************************/
3015
3016 jvmtiError
3017 GetAvailableProcessors (jvmtiEnv * env, jint * processor_count_ptr)
3018 {
3019       CHECK_PHASE_START
3020     CHECK_PHASE(JVMTI_PHASE_START)
3021     CHECK_PHASE(JVMTI_PHASE_LIVE)
3022     CHECK_PHASE_END;
3023
3024   log_text ("JVMTI-Call: IMPLEMENT ME!!!");
3025     return JVMTI_ERROR_NONE;
3026 }
3027
3028 /* GetEnvironmentLocalStorage **************************************************
3029
3030    Called by the agent to get the value of the JVM TI environment-local storage.
3031
3032 *******************************************************************************/
3033
3034 jvmtiError
3035 GetEnvironmentLocalStorage (jvmtiEnv * env, void **data_ptr)
3036 {
3037     if ((env == NULL) || (data_ptr == NULL)) return JVMTI_ERROR_NULL_POINTER;
3038
3039     *data_ptr = ((environment*)env)->EnvironmentLocalStorage;
3040
3041     return JVMTI_ERROR_NONE;
3042 }
3043
3044 /* SetEnvironmentLocalStorage **************************************************
3045
3046    The VM stores a pointer value associated with each environment. Agents can
3047    allocate memory in which they store environment specific information.
3048
3049 *******************************************************************************/
3050
3051 jvmtiError
3052 SetEnvironmentLocalStorage (jvmtiEnv * env, const void *data)
3053 {
3054     if (env == NULL) return JVMTI_ERROR_NULL_POINTER;
3055
3056     ((environment*)env)->EnvironmentLocalStorage = data;
3057
3058     return JVMTI_ERROR_NONE;
3059 }
3060
3061 /* AddToBootstrapClassLoaderSearch ********************************************
3062
3063    After the bootstrap class loader unsuccessfully searches for a class, the
3064    specified platform-dependent search path segment will be searched as well.
3065
3066 *******************************************************************************/
3067
3068 jvmtiError
3069 AddToBootstrapClassLoaderSearch (jvmtiEnv * env, const char *segment)
3070 {
3071     char* tmp_bcp;
3072     int ln;
3073
3074     CHECK_PHASE_START
3075     CHECK_PHASE(JVMTI_PHASE_ONLOAD)
3076     CHECK_PHASE_END;
3077
3078     if (segment == NULL) return JVMTI_ERROR_NULL_POINTER;
3079
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;
3087
3088     return JVMTI_ERROR_NONE;
3089 }
3090
3091 /* SetVerboseFlag *************************************************************
3092
3093    Control verbose output. This is the output which typically is sent to stderr
3094
3095 *******************************************************************************/
3096
3097 jvmtiError
3098 SetVerboseFlag (jvmtiEnv * env, jvmtiVerboseFlag flag, jboolean value)
3099 {
3100     switch (flag) {
3101     case JVMTI_VERBOSE_OTHER:
3102         runverbose = value;
3103         break;
3104     case JVMTI_VERBOSE_GC:
3105         opt_verbosegc = value;
3106         break;
3107     case JVMTI_VERBOSE_CLASS:
3108         loadverbose = value;
3109         break;
3110     case JVMTI_VERBOSE_JNI:
3111         break;
3112     default:
3113         return JVMTI_ERROR_ILLEGAL_ARGUMENT;
3114     }
3115     return JVMTI_ERROR_NONE;
3116 }
3117
3118 /* GetObjectSize **************************************************************
3119
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
3122    by this object.
3123
3124 *******************************************************************************/
3125
3126 jvmtiError
3127 GetObjectSize (jvmtiEnv * env, jobject object, jlong * size_ptr)
3128 {
3129     CHECK_PHASE_START
3130     CHECK_PHASE(JVMTI_PHASE_START)
3131     CHECK_PHASE(JVMTI_PHASE_LIVE)
3132     CHECK_PHASE_END;
3133
3134     log_text ("JVMTI-Call: IMPLEMENT ME!!!");
3135     return JVMTI_ERROR_NONE;
3136 }
3137
3138
3139 /* *****************************************************************************
3140
3141    Environment variables
3142
3143 *******************************************************************************/
3144
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 */
3179 };
3180
3181 jvmtiEnv JVMTI_EnvTable = {
3182     NULL,
3183     &SetEventNotificationMode,
3184     NULL,
3185     &GetAllThreads,
3186     &SuspendThread,
3187     &ResumeThread,
3188     &StopThread,
3189     &InterruptThread,
3190     &GetThreadInfo,
3191     &GetOwnedMonitorInfo,
3192     &GetCurrentContendedMonitor,
3193     &RunAgentThread,
3194     &GetTopThreadGroups,
3195     &GetThreadGroupInfo,
3196     &GetThreadGroupChildren,
3197     &GetFrameCount,
3198     &GetThreadState,
3199     NULL,
3200     &GetFrameLocation,
3201     &NotifyFramePop,
3202     &GetLocalObject,
3203     &GetLocalInt,
3204     &GetLocalLong,
3205     &GetLocalFloat,
3206     &GetLocalDouble,
3207     &SetLocalObject,
3208     &SetLocalInt,
3209     &SetLocalLong,
3210     &SetLocalFloat,
3211     &SetLocalDouble,
3212     &CreateRawMonitor,
3213     &DestroyRawMonitor,
3214     &RawMonitorEnter,
3215     &RawMonitorExit,
3216     &RawMonitorWait,
3217     &RawMonitorNotify,
3218     &RawMonitorNotifyAll,
3219     &SetBreakpoint,
3220     &ClearBreakpoint,
3221     NULL,
3222     &SetFieldAccessWatch,
3223     &ClearFieldAccessWatch,
3224     &SetFieldModificationWatch,
3225     &ClearFieldModificationWatch,
3226     NULL,
3227     &Allocate,
3228     &Deallocate,
3229     &GetClassSignature,
3230     &GetClassStatus,
3231     &GetSourceFileName,
3232     &GetClassModifiers,
3233     &GetClassMethods,
3234     &GetClassFields,
3235     &GetImplementedInterfaces,
3236     &IsInterface,
3237     &IsArrayClass,
3238     &GetClassLoader,
3239     &GetObjectHashCode,
3240     &GetObjectMonitorUsage,
3241     &GetFieldName,
3242     &GetFieldDeclaringClass,
3243     &GetFieldModifiers,
3244     &IsFieldSynthetic,
3245     &GetMethodName,
3246     &GetMethodDeclaringClass,
3247     &GetMethodModifiers,
3248     NULL,
3249     &GetMaxLocals,
3250     &GetArgumentsSize,
3251     &GetLineNumberTable,
3252     &GetMethodLocation,
3253     &GetLocalVariableTable,
3254     NULL,
3255     NULL,
3256     &GetBytecodes,
3257     &IsMethodNative,
3258     &IsMethodSynthetic,
3259     &GetLoadedClasses,
3260     &GetClassLoaderClasses,
3261     &PopFrame,
3262     NULL,
3263     NULL,
3264     NULL,
3265     NULL,
3266     NULL,
3267     NULL,
3268     &RedefineClasses,
3269     &GetVersionNumber,
3270     &GetCapabilities,
3271     &GetSourceDebugExtension,
3272     &IsMethodObsolete,
3273     &SuspendThreadList,
3274     &ResumeThreadList,
3275     NULL,
3276     NULL,
3277     NULL,
3278     NULL,
3279     NULL,
3280     NULL,
3281     &GetAllStackTraces,
3282     &GetThreadListStackTraces,
3283     &GetThreadLocalStorage,
3284     &SetThreadLocalStorage,
3285     &GetStackTrace,
3286     NULL,
3287     &GetTag,
3288     &SetTag,
3289     &ForceGarbageCollection,
3290     &IterateOverObjectsReachableFromObject,
3291     &IterateOverReachableObjects,
3292     &IterateOverHeap,
3293     &IterateOverInstancesOfClass,
3294     NULL,
3295     &GetObjectsWithTags,
3296     NULL,
3297     NULL,
3298     NULL,
3299     NULL,
3300     NULL,
3301     &SetJNIFunctionTable,
3302     &GetJNIFunctionTable,
3303     &SetEventCallbacks,
3304     &GenerateEvents,
3305     &GetExtensionFunctions,
3306     &GetExtensionEvents,
3307     &SetExtensionEventCallback,
3308     &DisposeEnvironment,
3309     &GetErrorName,
3310     &GetJLocationFormat,
3311     &GetSystemProperties,
3312     &GetSystemProperty,
3313     &SetSystemProperty,
3314     &GetPhase,
3315     &GetCurrentThreadCpuTimerInfo,
3316     &GetCurrentThreadCpuTime,
3317     &GetThreadCpuTimerInfo,
3318     &GetThreadCpuTime,
3319     &GetTimerInfo,
3320     &GetTime,
3321     &GetPotentialCapabilities,
3322     NULL,
3323     &AddCapabilities,
3324     &RelinquishCapabilities,
3325     &GetAvailableProcessors,
3326     NULL,
3327     NULL,
3328     &GetEnvironmentLocalStorage,
3329     &SetEnvironmentLocalStorage,
3330     &AddToBootstrapClassLoaderSearch,
3331     &SetVerboseFlag,
3332     NULL,
3333     NULL,
3334     NULL,
3335     &GetObjectSize
3336 };
3337
3338 void jvmti_init() {
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");
3343     }
3344
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");
3350     }
3351 }
3352
3353 void set_jvmti_phase(jvmtiPhase p) {
3354     phase = p;
3355     switch (p) {
3356     case JVMTI_PHASE_ONLOAD:
3357         /* todo */
3358         break;
3359     case JVMTI_PHASE_PRIMORDIAL:
3360         /* todo */
3361         break;
3362     case JVMTI_PHASE_START:
3363         /* todo: send VM Start Event*/
3364         break;
3365     case JVMTI_PHASE_LIVE:
3366         /* todo: send VMInit Event */
3367         break;
3368     case JVMTI_PHASE_DEAD:
3369         /* todo: send VMDeath Event */
3370         break;
3371     }
3372 }
3373
3374 jvmtiEnv* new_jvmtienv() {
3375     environment* env;
3376     java_objectheader *o;
3377
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;
3386     return &(env->env);
3387 }
3388
3389 /*
3390  * These are local overrides for various environment variables in Emacs.
3391  * Please do not remove this and leave it at the end of the file, where
3392  * Emacs will automagically detect them.
3393  * ---------------------------------------------------------------------
3394  * Local variables:
3395  * mode: c
3396  * indent-tabs-mode: t
3397  * c-basic-offset: 4
3398  * tab-width: 4
3399  * End:
3400  */