1/* Copyright (C) 2016 The Android Open Source Project 2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 3 * 4 * This file implements interfaces from the file jvmti.h. This implementation 5 * is licensed under the same terms as the file jvmti.h. The 6 * copyright and license information for the file jvmti.h follows. 7 * 8 * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved. 9 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 10 * 11 * This code is free software; you can redistribute it and/or modify it 12 * under the terms of the GNU General Public License version 2 only, as 13 * published by the Free Software Foundation. Oracle designates this 14 * particular file as subject to the "Classpath" exception as provided 15 * by Oracle in the LICENSE file that accompanied this code. 16 * 17 * This code is distributed in the hope that it will be useful, but WITHOUT 18 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 19 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 20 * version 2 for more details (a copy is included in the LICENSE file that 21 * accompanied this code). 22 * 23 * You should have received a copy of the GNU General Public License version 24 * 2 along with this work; if not, write to the Free Software Foundation, 25 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 26 * 27 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 28 * or visit www.oracle.com if you need additional information or have any 29 * questions. 30 */ 31 32#include <string> 33#include <type_traits> 34#include <vector> 35 36#include <android-base/logging.h> 37 38#include <jni.h> 39 40#include "jvmti.h" 41 42#include "art_jvmti.h" 43#include "base/logging.h" // For gLogVerbosity. 44#include "base/mutex.h" 45#include "events-inl.h" 46#include "jni_env_ext-inl.h" 47#include "obj_ptr-inl.h" 48#include "object_tagging.h" 49#include "runtime.h" 50#include "scoped_thread_state_change-inl.h" 51#include "thread-current-inl.h" 52#include "thread_list.h" 53#include "ti_allocator.h" 54#include "ti_breakpoint.h" 55#include "ti_class.h" 56#include "ti_dump.h" 57#include "ti_extension.h" 58#include "ti_field.h" 59#include "ti_heap.h" 60#include "ti_jni.h" 61#include "ti_method.h" 62#include "ti_monitor.h" 63#include "ti_object.h" 64#include "ti_phase.h" 65#include "ti_properties.h" 66#include "ti_redefine.h" 67#include "ti_search.h" 68#include "ti_stack.h" 69#include "ti_thread.h" 70#include "ti_threadgroup.h" 71#include "ti_timers.h" 72#include "transform.h" 73 74namespace openjdkjvmti { 75 76// NB These are heap allocated to avoid the static destructors being run if an agent calls exit(3). 77// These should never be null. 78EventHandler* gEventHandler; 79DeoptManager* gDeoptManager; 80 81#define ENSURE_NON_NULL(n) \ 82 do { \ 83 if ((n) == nullptr) { \ 84 return ERR(NULL_POINTER); \ 85 } \ 86 } while (false) 87 88// Returns whether we are able to use all jvmti features. 89static bool IsFullJvmtiAvailable() { 90 art::Runtime* runtime = art::Runtime::Current(); 91 return runtime->GetInstrumentation()->IsForcedInterpretOnly() || runtime->IsJavaDebuggable(); 92} 93 94class JvmtiFunctions { 95 private: 96 static jvmtiError getEnvironmentError(jvmtiEnv* env) { 97 if (env == nullptr) { 98 return ERR(INVALID_ENVIRONMENT); 99 } else if (art::Thread::Current() == nullptr) { 100 return ERR(UNATTACHED_THREAD); 101 } else { 102 return OK; 103 } 104 } 105 106#define ENSURE_VALID_ENV(env) \ 107 do { \ 108 jvmtiError ensure_valid_env_ ## __LINE__ = getEnvironmentError(env); \ 109 if (ensure_valid_env_ ## __LINE__ != OK) { \ 110 return ensure_valid_env_ ## __LINE__ ; \ 111 } \ 112 } while (false) 113 114#define ENSURE_HAS_CAP(env, cap) \ 115 do { \ 116 if (ArtJvmTiEnv::AsArtJvmTiEnv(env)->capabilities.cap != 1) { \ 117 return ERR(MUST_POSSESS_CAPABILITY); \ 118 } \ 119 } while (false) 120 121 public: 122 static jvmtiError Allocate(jvmtiEnv* env, jlong size, unsigned char** mem_ptr) { 123 ENSURE_VALID_ENV(env); 124 ENSURE_NON_NULL(mem_ptr); 125 return AllocUtil::Allocate(env, size, mem_ptr); 126 } 127 128 static jvmtiError Deallocate(jvmtiEnv* env, unsigned char* mem) { 129 ENSURE_VALID_ENV(env); 130 return AllocUtil::Deallocate(env, mem); 131 } 132 133 static jvmtiError GetThreadState(jvmtiEnv* env, jthread thread, jint* thread_state_ptr) { 134 ENSURE_VALID_ENV(env); 135 return ThreadUtil::GetThreadState(env, thread, thread_state_ptr); 136 } 137 138 static jvmtiError GetCurrentThread(jvmtiEnv* env, jthread* thread_ptr) { 139 ENSURE_VALID_ENV(env); 140 return ThreadUtil::GetCurrentThread(env, thread_ptr); 141 } 142 143 static jvmtiError GetAllThreads(jvmtiEnv* env, jint* threads_count_ptr, jthread** threads_ptr) { 144 ENSURE_VALID_ENV(env); 145 return ThreadUtil::GetAllThreads(env, threads_count_ptr, threads_ptr); 146 } 147 148 static jvmtiError SuspendThread(jvmtiEnv* env, jthread thread) { 149 ENSURE_VALID_ENV(env); 150 ENSURE_HAS_CAP(env, can_suspend); 151 return ThreadUtil::SuspendThread(env, thread); 152 } 153 154 static jvmtiError SuspendThreadList(jvmtiEnv* env, 155 jint request_count, 156 const jthread* request_list, 157 jvmtiError* results) { 158 ENSURE_VALID_ENV(env); 159 ENSURE_HAS_CAP(env, can_suspend); 160 return ThreadUtil::SuspendThreadList(env, request_count, request_list, results); 161 } 162 163 static jvmtiError ResumeThread(jvmtiEnv* env, jthread thread) { 164 ENSURE_VALID_ENV(env); 165 ENSURE_HAS_CAP(env, can_suspend); 166 return ThreadUtil::ResumeThread(env, thread); 167 } 168 169 static jvmtiError ResumeThreadList(jvmtiEnv* env, 170 jint request_count, 171 const jthread* request_list, 172 jvmtiError* results) { 173 ENSURE_VALID_ENV(env); 174 ENSURE_HAS_CAP(env, can_suspend); 175 return ThreadUtil::ResumeThreadList(env, request_count, request_list, results); 176 } 177 178 static jvmtiError StopThread(jvmtiEnv* env, jthread thread, jobject exception) { 179 ENSURE_VALID_ENV(env); 180 ENSURE_HAS_CAP(env, can_signal_thread); 181 return ThreadUtil::StopThread(env, thread, exception); 182 } 183 184 static jvmtiError InterruptThread(jvmtiEnv* env, jthread thread) { 185 ENSURE_VALID_ENV(env); 186 ENSURE_HAS_CAP(env, can_signal_thread); 187 return ThreadUtil::InterruptThread(env, thread); 188 } 189 190 static jvmtiError GetThreadInfo(jvmtiEnv* env, jthread thread, jvmtiThreadInfo* info_ptr) { 191 ENSURE_VALID_ENV(env); 192 return ThreadUtil::GetThreadInfo(env, thread, info_ptr); 193 } 194 195 static jvmtiError GetOwnedMonitorInfo(jvmtiEnv* env, 196 jthread thread, 197 jint* owned_monitor_count_ptr, 198 jobject** owned_monitors_ptr) { 199 ENSURE_VALID_ENV(env); 200 ENSURE_HAS_CAP(env, can_get_owned_monitor_info); 201 return StackUtil::GetOwnedMonitorInfo(env, 202 thread, 203 owned_monitor_count_ptr, 204 owned_monitors_ptr); 205 } 206 207 static jvmtiError GetOwnedMonitorStackDepthInfo(jvmtiEnv* env, 208 jthread thread, 209 jint* monitor_info_count_ptr, 210 jvmtiMonitorStackDepthInfo** monitor_info_ptr) { 211 ENSURE_VALID_ENV(env); 212 ENSURE_HAS_CAP(env, can_get_owned_monitor_stack_depth_info); 213 return StackUtil::GetOwnedMonitorStackDepthInfo(env, 214 thread, 215 monitor_info_count_ptr, 216 monitor_info_ptr); 217 } 218 219 static jvmtiError GetCurrentContendedMonitor(jvmtiEnv* env, 220 jthread thread, 221 jobject* monitor_ptr) { 222 ENSURE_VALID_ENV(env); 223 ENSURE_HAS_CAP(env, can_get_current_contended_monitor); 224 return MonitorUtil::GetCurrentContendedMonitor(env, thread, monitor_ptr); 225 } 226 227 static jvmtiError RunAgentThread(jvmtiEnv* env, 228 jthread thread, 229 jvmtiStartFunction proc, 230 const void* arg, 231 jint priority) { 232 ENSURE_VALID_ENV(env); 233 return ThreadUtil::RunAgentThread(env, thread, proc, arg, priority); 234 } 235 236 static jvmtiError SetThreadLocalStorage(jvmtiEnv* env, jthread thread, const void* data) { 237 ENSURE_VALID_ENV(env); 238 return ThreadUtil::SetThreadLocalStorage(env, thread, data); 239 } 240 241 static jvmtiError GetThreadLocalStorage(jvmtiEnv* env, jthread thread, void** data_ptr) { 242 ENSURE_VALID_ENV(env); 243 return ThreadUtil::GetThreadLocalStorage(env, thread, data_ptr); 244 } 245 246 static jvmtiError GetTopThreadGroups(jvmtiEnv* env, 247 jint* group_count_ptr, 248 jthreadGroup** groups_ptr) { 249 ENSURE_VALID_ENV(env); 250 return ThreadGroupUtil::GetTopThreadGroups(env, group_count_ptr, groups_ptr); 251 } 252 253 static jvmtiError GetThreadGroupInfo(jvmtiEnv* env, 254 jthreadGroup group, 255 jvmtiThreadGroupInfo* info_ptr) { 256 ENSURE_VALID_ENV(env); 257 return ThreadGroupUtil::GetThreadGroupInfo(env, group, info_ptr); 258 } 259 260 static jvmtiError GetThreadGroupChildren(jvmtiEnv* env, 261 jthreadGroup group, 262 jint* thread_count_ptr, 263 jthread** threads_ptr, 264 jint* group_count_ptr, 265 jthreadGroup** groups_ptr) { 266 ENSURE_VALID_ENV(env); 267 return ThreadGroupUtil::GetThreadGroupChildren(env, 268 group, 269 thread_count_ptr, 270 threads_ptr, 271 group_count_ptr, 272 groups_ptr); 273 } 274 275 static jvmtiError GetStackTrace(jvmtiEnv* env, 276 jthread thread, 277 jint start_depth, 278 jint max_frame_count, 279 jvmtiFrameInfo* frame_buffer, 280 jint* count_ptr) { 281 ENSURE_VALID_ENV(env); 282 return StackUtil::GetStackTrace(env, 283 thread, 284 start_depth, 285 max_frame_count, 286 frame_buffer, 287 count_ptr); 288 } 289 290 static jvmtiError GetAllStackTraces(jvmtiEnv* env, 291 jint max_frame_count, 292 jvmtiStackInfo** stack_info_ptr, 293 jint* thread_count_ptr) { 294 ENSURE_VALID_ENV(env); 295 return StackUtil::GetAllStackTraces(env, max_frame_count, stack_info_ptr, thread_count_ptr); 296 } 297 298 static jvmtiError GetThreadListStackTraces(jvmtiEnv* env, 299 jint thread_count, 300 const jthread* thread_list, 301 jint max_frame_count, 302 jvmtiStackInfo** stack_info_ptr) { 303 ENSURE_VALID_ENV(env); 304 return StackUtil::GetThreadListStackTraces(env, 305 thread_count, 306 thread_list, 307 max_frame_count, 308 stack_info_ptr); 309 } 310 311 static jvmtiError GetFrameCount(jvmtiEnv* env, jthread thread, jint* count_ptr) { 312 ENSURE_VALID_ENV(env); 313 return StackUtil::GetFrameCount(env, thread, count_ptr); 314 } 315 316 static jvmtiError PopFrame(jvmtiEnv* env, jthread thread ATTRIBUTE_UNUSED) { 317 ENSURE_VALID_ENV(env); 318 ENSURE_HAS_CAP(env, can_pop_frame); 319 return ERR(NOT_IMPLEMENTED); 320 } 321 322 static jvmtiError GetFrameLocation(jvmtiEnv* env, 323 jthread thread, 324 jint depth, 325 jmethodID* method_ptr, 326 jlocation* location_ptr) { 327 ENSURE_VALID_ENV(env); 328 return StackUtil::GetFrameLocation(env, thread, depth, method_ptr, location_ptr); 329 } 330 331 static jvmtiError NotifyFramePop(jvmtiEnv* env, jthread thread, jint depth) { 332 ENSURE_VALID_ENV(env); 333 ENSURE_HAS_CAP(env, can_generate_frame_pop_events); 334 return StackUtil::NotifyFramePop(env, thread, depth); 335 } 336 337 static jvmtiError ForceEarlyReturnObject(jvmtiEnv* env, 338 jthread thread ATTRIBUTE_UNUSED, 339 jobject value ATTRIBUTE_UNUSED) { 340 ENSURE_VALID_ENV(env); 341 ENSURE_HAS_CAP(env, can_force_early_return); 342 return ERR(NOT_IMPLEMENTED); 343 } 344 345 static jvmtiError ForceEarlyReturnInt(jvmtiEnv* env, 346 jthread thread ATTRIBUTE_UNUSED, 347 jint value ATTRIBUTE_UNUSED) { 348 ENSURE_VALID_ENV(env); 349 ENSURE_HAS_CAP(env, can_force_early_return); 350 return ERR(NOT_IMPLEMENTED); 351 } 352 353 static jvmtiError ForceEarlyReturnLong(jvmtiEnv* env, 354 jthread thread ATTRIBUTE_UNUSED, 355 jlong value ATTRIBUTE_UNUSED) { 356 ENSURE_VALID_ENV(env); 357 ENSURE_HAS_CAP(env, can_force_early_return); 358 return ERR(NOT_IMPLEMENTED); 359 } 360 361 static jvmtiError ForceEarlyReturnFloat(jvmtiEnv* env, 362 jthread thread ATTRIBUTE_UNUSED, 363 jfloat value ATTRIBUTE_UNUSED) { 364 ENSURE_VALID_ENV(env); 365 ENSURE_HAS_CAP(env, can_force_early_return); 366 return ERR(NOT_IMPLEMENTED); 367 } 368 369 static jvmtiError ForceEarlyReturnDouble(jvmtiEnv* env, 370 jthread thread ATTRIBUTE_UNUSED, 371 jdouble value ATTRIBUTE_UNUSED) { 372 ENSURE_VALID_ENV(env); 373 ENSURE_HAS_CAP(env, can_force_early_return); 374 return ERR(NOT_IMPLEMENTED); 375 } 376 377 static jvmtiError ForceEarlyReturnVoid(jvmtiEnv* env, jthread thread ATTRIBUTE_UNUSED) { 378 ENSURE_VALID_ENV(env); 379 ENSURE_HAS_CAP(env, can_force_early_return); 380 return ERR(NOT_IMPLEMENTED); 381 } 382 383 static jvmtiError FollowReferences(jvmtiEnv* env, 384 jint heap_filter, 385 jclass klass, 386 jobject initial_object, 387 const jvmtiHeapCallbacks* callbacks, 388 const void* user_data) { 389 ENSURE_VALID_ENV(env); 390 ENSURE_HAS_CAP(env, can_tag_objects); 391 HeapUtil heap_util(ArtJvmTiEnv::AsArtJvmTiEnv(env)->object_tag_table.get()); 392 return heap_util.FollowReferences(env, 393 heap_filter, 394 klass, 395 initial_object, 396 callbacks, 397 user_data); 398 } 399 400 static jvmtiError IterateThroughHeap(jvmtiEnv* env, 401 jint heap_filter, 402 jclass klass, 403 const jvmtiHeapCallbacks* callbacks, 404 const void* user_data) { 405 ENSURE_VALID_ENV(env); 406 ENSURE_HAS_CAP(env, can_tag_objects); 407 HeapUtil heap_util(ArtJvmTiEnv::AsArtJvmTiEnv(env)->object_tag_table.get()); 408 return heap_util.IterateThroughHeap(env, heap_filter, klass, callbacks, user_data); 409 } 410 411 static jvmtiError GetTag(jvmtiEnv* env, jobject object, jlong* tag_ptr) { 412 ENSURE_VALID_ENV(env); 413 ENSURE_HAS_CAP(env, can_tag_objects); 414 415 JNIEnv* jni_env = GetJniEnv(env); 416 if (jni_env == nullptr) { 417 return ERR(INTERNAL); 418 } 419 420 art::ScopedObjectAccess soa(jni_env); 421 art::ObjPtr<art::mirror::Object> obj = soa.Decode<art::mirror::Object>(object); 422 if (!ArtJvmTiEnv::AsArtJvmTiEnv(env)->object_tag_table->GetTag(obj.Ptr(), tag_ptr)) { 423 *tag_ptr = 0; 424 } 425 426 return ERR(NONE); 427 } 428 429 static jvmtiError SetTag(jvmtiEnv* env, jobject object, jlong tag) { 430 ENSURE_VALID_ENV(env); 431 ENSURE_HAS_CAP(env, can_tag_objects); 432 433 if (object == nullptr) { 434 return ERR(NULL_POINTER); 435 } 436 437 JNIEnv* jni_env = GetJniEnv(env); 438 if (jni_env == nullptr) { 439 return ERR(INTERNAL); 440 } 441 442 art::ScopedObjectAccess soa(jni_env); 443 art::ObjPtr<art::mirror::Object> obj = soa.Decode<art::mirror::Object>(object); 444 ArtJvmTiEnv::AsArtJvmTiEnv(env)->object_tag_table->Set(obj.Ptr(), tag); 445 446 return ERR(NONE); 447 } 448 449 static jvmtiError GetObjectsWithTags(jvmtiEnv* env, 450 jint tag_count, 451 const jlong* tags, 452 jint* count_ptr, 453 jobject** object_result_ptr, 454 jlong** tag_result_ptr) { 455 ENSURE_VALID_ENV(env); 456 ENSURE_HAS_CAP(env, can_tag_objects); 457 458 JNIEnv* jni_env = GetJniEnv(env); 459 if (jni_env == nullptr) { 460 return ERR(INTERNAL); 461 } 462 463 art::ScopedObjectAccess soa(jni_env); 464 return ArtJvmTiEnv::AsArtJvmTiEnv(env)->object_tag_table->GetTaggedObjects(env, 465 tag_count, 466 tags, 467 count_ptr, 468 object_result_ptr, 469 tag_result_ptr); 470 } 471 472 static jvmtiError ForceGarbageCollection(jvmtiEnv* env) { 473 ENSURE_VALID_ENV(env); 474 return HeapUtil::ForceGarbageCollection(env); 475 } 476 477 static jvmtiError IterateOverObjectsReachableFromObject( 478 jvmtiEnv* env, 479 jobject object ATTRIBUTE_UNUSED, 480 jvmtiObjectReferenceCallback object_reference_callback ATTRIBUTE_UNUSED, 481 const void* user_data ATTRIBUTE_UNUSED) { 482 ENSURE_VALID_ENV(env); 483 ENSURE_HAS_CAP(env, can_tag_objects); 484 return ERR(NOT_IMPLEMENTED); 485 } 486 487 static jvmtiError IterateOverReachableObjects( 488 jvmtiEnv* env, 489 jvmtiHeapRootCallback heap_root_callback ATTRIBUTE_UNUSED, 490 jvmtiStackReferenceCallback stack_ref_callback ATTRIBUTE_UNUSED, 491 jvmtiObjectReferenceCallback object_ref_callback ATTRIBUTE_UNUSED, 492 const void* user_data ATTRIBUTE_UNUSED) { 493 ENSURE_VALID_ENV(env); 494 ENSURE_HAS_CAP(env, can_tag_objects); 495 return ERR(NOT_IMPLEMENTED); 496 } 497 498 static jvmtiError IterateOverHeap(jvmtiEnv* env, 499 jvmtiHeapObjectFilter object_filter ATTRIBUTE_UNUSED, 500 jvmtiHeapObjectCallback heap_object_callback ATTRIBUTE_UNUSED, 501 const void* user_data ATTRIBUTE_UNUSED) { 502 ENSURE_VALID_ENV(env); 503 ENSURE_HAS_CAP(env, can_tag_objects); 504 return ERR(NOT_IMPLEMENTED); 505 } 506 507 static jvmtiError IterateOverInstancesOfClass( 508 jvmtiEnv* env, 509 jclass klass ATTRIBUTE_UNUSED, 510 jvmtiHeapObjectFilter object_filter ATTRIBUTE_UNUSED, 511 jvmtiHeapObjectCallback heap_object_callback ATTRIBUTE_UNUSED, 512 const void* user_data ATTRIBUTE_UNUSED) { 513 ENSURE_VALID_ENV(env); 514 ENSURE_HAS_CAP(env, can_tag_objects); 515 return ERR(NOT_IMPLEMENTED); 516 } 517 518 static jvmtiError GetLocalObject(jvmtiEnv* env, 519 jthread thread, 520 jint depth, 521 jint slot, 522 jobject* value_ptr) { 523 ENSURE_VALID_ENV(env); 524 ENSURE_HAS_CAP(env, can_access_local_variables); 525 return MethodUtil::GetLocalVariable(env, thread, depth, slot, value_ptr); 526 } 527 528 static jvmtiError GetLocalInstance(jvmtiEnv* env, 529 jthread thread, 530 jint depth, 531 jobject* value_ptr) { 532 ENSURE_VALID_ENV(env); 533 ENSURE_HAS_CAP(env, can_access_local_variables); 534 return MethodUtil::GetLocalInstance(env, thread, depth, value_ptr); 535 } 536 537 static jvmtiError GetLocalInt(jvmtiEnv* env, 538 jthread thread, 539 jint depth, 540 jint slot, 541 jint* value_ptr) { 542 ENSURE_VALID_ENV(env); 543 ENSURE_HAS_CAP(env, can_access_local_variables); 544 return MethodUtil::GetLocalVariable(env, thread, depth, slot, value_ptr); 545 } 546 547 static jvmtiError GetLocalLong(jvmtiEnv* env, 548 jthread thread, 549 jint depth, 550 jint slot, 551 jlong* value_ptr) { 552 ENSURE_VALID_ENV(env); 553 ENSURE_HAS_CAP(env, can_access_local_variables); 554 return MethodUtil::GetLocalVariable(env, thread, depth, slot, value_ptr); 555 } 556 557 static jvmtiError GetLocalFloat(jvmtiEnv* env, 558 jthread thread, 559 jint depth, 560 jint slot, 561 jfloat* value_ptr) { 562 ENSURE_VALID_ENV(env); 563 ENSURE_HAS_CAP(env, can_access_local_variables); 564 return MethodUtil::GetLocalVariable(env, thread, depth, slot, value_ptr); 565 } 566 567 static jvmtiError GetLocalDouble(jvmtiEnv* env, 568 jthread thread, 569 jint depth, 570 jint slot, 571 jdouble* value_ptr) { 572 ENSURE_VALID_ENV(env); 573 ENSURE_HAS_CAP(env, can_access_local_variables); 574 return MethodUtil::GetLocalVariable(env, thread, depth, slot, value_ptr); 575 } 576 577 static jvmtiError SetLocalObject(jvmtiEnv* env, 578 jthread thread, 579 jint depth, 580 jint slot, 581 jobject value) { 582 ENSURE_VALID_ENV(env); 583 ENSURE_HAS_CAP(env, can_access_local_variables); 584 return MethodUtil::SetLocalVariable(env, thread, depth, slot, value); 585 } 586 587 static jvmtiError SetLocalInt(jvmtiEnv* env, 588 jthread thread, 589 jint depth, 590 jint slot, 591 jint value) { 592 ENSURE_VALID_ENV(env); 593 ENSURE_HAS_CAP(env, can_access_local_variables); 594 return MethodUtil::SetLocalVariable(env, thread, depth, slot, value); 595 } 596 597 static jvmtiError SetLocalLong(jvmtiEnv* env, 598 jthread thread, 599 jint depth, 600 jint slot, 601 jlong value) { 602 ENSURE_VALID_ENV(env); 603 ENSURE_HAS_CAP(env, can_access_local_variables); 604 return MethodUtil::SetLocalVariable(env, thread, depth, slot, value); 605 } 606 607 static jvmtiError SetLocalFloat(jvmtiEnv* env, 608 jthread thread, 609 jint depth, 610 jint slot, 611 jfloat value) { 612 ENSURE_VALID_ENV(env); 613 ENSURE_HAS_CAP(env, can_access_local_variables); 614 return MethodUtil::SetLocalVariable(env, thread, depth, slot, value); 615 } 616 617 static jvmtiError SetLocalDouble(jvmtiEnv* env, 618 jthread thread, 619 jint depth, 620 jint slot, 621 jdouble value) { 622 ENSURE_VALID_ENV(env); 623 ENSURE_HAS_CAP(env, can_access_local_variables); 624 return MethodUtil::SetLocalVariable(env, thread, depth, slot, value); 625 } 626 627 628 static jvmtiError SetBreakpoint(jvmtiEnv* env, jmethodID method, jlocation location) { 629 ENSURE_VALID_ENV(env); 630 ENSURE_HAS_CAP(env, can_generate_breakpoint_events); 631 return BreakpointUtil::SetBreakpoint(env, method, location); 632 } 633 634 static jvmtiError ClearBreakpoint(jvmtiEnv* env, jmethodID method, jlocation location) { 635 ENSURE_VALID_ENV(env); 636 ENSURE_HAS_CAP(env, can_generate_breakpoint_events); 637 return BreakpointUtil::ClearBreakpoint(env, method, location); 638 } 639 640 static jvmtiError SetFieldAccessWatch(jvmtiEnv* env, jclass klass, jfieldID field) { 641 ENSURE_VALID_ENV(env); 642 ENSURE_HAS_CAP(env, can_generate_field_access_events); 643 return FieldUtil::SetFieldAccessWatch(env, klass, field); 644 } 645 646 static jvmtiError ClearFieldAccessWatch(jvmtiEnv* env, jclass klass, jfieldID field) { 647 ENSURE_VALID_ENV(env); 648 ENSURE_HAS_CAP(env, can_generate_field_access_events); 649 return FieldUtil::ClearFieldAccessWatch(env, klass, field); 650 } 651 652 static jvmtiError SetFieldModificationWatch(jvmtiEnv* env, jclass klass, jfieldID field) { 653 ENSURE_VALID_ENV(env); 654 ENSURE_HAS_CAP(env, can_generate_field_modification_events); 655 return FieldUtil::SetFieldModificationWatch(env, klass, field); 656 } 657 658 static jvmtiError ClearFieldModificationWatch(jvmtiEnv* env, jclass klass, jfieldID field) { 659 ENSURE_VALID_ENV(env); 660 ENSURE_HAS_CAP(env, can_generate_field_modification_events); 661 return FieldUtil::ClearFieldModificationWatch(env, klass, field); 662 } 663 664 static jvmtiError GetLoadedClasses(jvmtiEnv* env, jint* class_count_ptr, jclass** classes_ptr) { 665 ENSURE_VALID_ENV(env); 666 HeapUtil heap_util(ArtJvmTiEnv::AsArtJvmTiEnv(env)->object_tag_table.get()); 667 return heap_util.GetLoadedClasses(env, class_count_ptr, classes_ptr); 668 } 669 670 static jvmtiError GetClassLoaderClasses(jvmtiEnv* env, 671 jobject initiating_loader, 672 jint* class_count_ptr, 673 jclass** classes_ptr) { 674 ENSURE_VALID_ENV(env); 675 return ClassUtil::GetClassLoaderClasses(env, initiating_loader, class_count_ptr, classes_ptr); 676 } 677 678 static jvmtiError GetClassSignature(jvmtiEnv* env, 679 jclass klass, 680 char** signature_ptr, 681 char** generic_ptr) { 682 ENSURE_VALID_ENV(env); 683 return ClassUtil::GetClassSignature(env, klass, signature_ptr, generic_ptr); 684 } 685 686 static jvmtiError GetClassStatus(jvmtiEnv* env, jclass klass, jint* status_ptr) { 687 ENSURE_VALID_ENV(env); 688 return ClassUtil::GetClassStatus(env, klass, status_ptr); 689 } 690 691 static jvmtiError GetSourceFileName(jvmtiEnv* env, jclass klass, char** source_name_ptr) { 692 ENSURE_VALID_ENV(env); 693 ENSURE_HAS_CAP(env, can_get_source_file_name); 694 return ClassUtil::GetSourceFileName(env, klass, source_name_ptr); 695 } 696 697 static jvmtiError GetClassModifiers(jvmtiEnv* env, jclass klass, jint* modifiers_ptr) { 698 ENSURE_VALID_ENV(env); 699 return ClassUtil::GetClassModifiers(env, klass, modifiers_ptr); 700 } 701 702 static jvmtiError GetClassMethods(jvmtiEnv* env, 703 jclass klass, 704 jint* method_count_ptr, 705 jmethodID** methods_ptr) { 706 ENSURE_VALID_ENV(env); 707 return ClassUtil::GetClassMethods(env, klass, method_count_ptr, methods_ptr); 708 } 709 710 static jvmtiError GetClassFields(jvmtiEnv* env, 711 jclass klass, 712 jint* field_count_ptr, 713 jfieldID** fields_ptr) { 714 ENSURE_VALID_ENV(env); 715 return ClassUtil::GetClassFields(env, klass, field_count_ptr, fields_ptr); 716 } 717 718 static jvmtiError GetImplementedInterfaces(jvmtiEnv* env, 719 jclass klass, 720 jint* interface_count_ptr, 721 jclass** interfaces_ptr) { 722 ENSURE_VALID_ENV(env); 723 return ClassUtil::GetImplementedInterfaces(env, klass, interface_count_ptr, interfaces_ptr); 724 } 725 726 static jvmtiError GetClassVersionNumbers(jvmtiEnv* env, 727 jclass klass, 728 jint* minor_version_ptr, 729 jint* major_version_ptr) { 730 ENSURE_VALID_ENV(env); 731 return ClassUtil::GetClassVersionNumbers(env, klass, minor_version_ptr, major_version_ptr); 732 } 733 734 static jvmtiError GetConstantPool(jvmtiEnv* env, 735 jclass klass ATTRIBUTE_UNUSED, 736 jint* constant_pool_count_ptr ATTRIBUTE_UNUSED, 737 jint* constant_pool_byte_count_ptr ATTRIBUTE_UNUSED, 738 unsigned char** constant_pool_bytes_ptr ATTRIBUTE_UNUSED) { 739 ENSURE_VALID_ENV(env); 740 ENSURE_HAS_CAP(env, can_get_constant_pool); 741 return ERR(NOT_IMPLEMENTED); 742 } 743 744 static jvmtiError IsInterface(jvmtiEnv* env, jclass klass, jboolean* is_interface_ptr) { 745 ENSURE_VALID_ENV(env); 746 return ClassUtil::IsInterface(env, klass, is_interface_ptr); 747 } 748 749 static jvmtiError IsArrayClass(jvmtiEnv* env, 750 jclass klass, 751 jboolean* is_array_class_ptr) { 752 ENSURE_VALID_ENV(env); 753 return ClassUtil::IsArrayClass(env, klass, is_array_class_ptr); 754 } 755 756 static jvmtiError IsModifiableClass(jvmtiEnv* env, 757 jclass klass, 758 jboolean* is_modifiable_class_ptr) { 759 ENSURE_VALID_ENV(env); 760 return Redefiner::IsModifiableClass(env, klass, is_modifiable_class_ptr); 761 } 762 763 static jvmtiError GetClassLoader(jvmtiEnv* env, jclass klass, jobject* classloader_ptr) { 764 ENSURE_VALID_ENV(env); 765 return ClassUtil::GetClassLoader(env, klass, classloader_ptr); 766 } 767 768 static jvmtiError GetSourceDebugExtension(jvmtiEnv* env, 769 jclass klass, 770 char** source_debug_extension_ptr) { 771 ENSURE_VALID_ENV(env); 772 ENSURE_HAS_CAP(env, can_get_source_debug_extension); 773 return ClassUtil::GetSourceDebugExtension(env, klass, source_debug_extension_ptr); 774 } 775 776 static jvmtiError RetransformClasses(jvmtiEnv* env, jint class_count, const jclass* classes) { 777 ENSURE_VALID_ENV(env); 778 ENSURE_HAS_CAP(env, can_retransform_classes); 779 std::string error_msg; 780 jvmtiError res = Transformer::RetransformClasses(ArtJvmTiEnv::AsArtJvmTiEnv(env), 781 gEventHandler, 782 art::Runtime::Current(), 783 art::Thread::Current(), 784 class_count, 785 classes, 786 &error_msg); 787 if (res != OK) { 788 LOG(WARNING) << "FAILURE TO RETRANFORM " << error_msg; 789 } 790 return res; 791 } 792 793 static jvmtiError RedefineClasses(jvmtiEnv* env, 794 jint class_count, 795 const jvmtiClassDefinition* class_definitions) { 796 ENSURE_VALID_ENV(env); 797 ENSURE_HAS_CAP(env, can_redefine_classes); 798 std::string error_msg; 799 jvmtiError res = Redefiner::RedefineClasses(ArtJvmTiEnv::AsArtJvmTiEnv(env), 800 gEventHandler, 801 art::Runtime::Current(), 802 art::Thread::Current(), 803 class_count, 804 class_definitions, 805 &error_msg); 806 if (res != OK) { 807 LOG(WARNING) << "FAILURE TO REDEFINE " << error_msg; 808 } 809 return res; 810 } 811 812 static jvmtiError GetObjectSize(jvmtiEnv* env, jobject object, jlong* size_ptr) { 813 ENSURE_VALID_ENV(env); 814 return ObjectUtil::GetObjectSize(env, object, size_ptr); 815 } 816 817 static jvmtiError GetObjectHashCode(jvmtiEnv* env, jobject object, jint* hash_code_ptr) { 818 ENSURE_VALID_ENV(env); 819 return ObjectUtil::GetObjectHashCode(env, object, hash_code_ptr); 820 } 821 822 static jvmtiError GetObjectMonitorUsage(jvmtiEnv* env, 823 jobject object, 824 jvmtiMonitorUsage* info_ptr) { 825 ENSURE_VALID_ENV(env); 826 ENSURE_HAS_CAP(env, can_get_monitor_info); 827 return ObjectUtil::GetObjectMonitorUsage(env, object, info_ptr); 828 } 829 830 static jvmtiError GetFieldName(jvmtiEnv* env, 831 jclass klass, 832 jfieldID field, 833 char** name_ptr, 834 char** signature_ptr, 835 char** generic_ptr) { 836 ENSURE_VALID_ENV(env); 837 return FieldUtil::GetFieldName(env, klass, field, name_ptr, signature_ptr, generic_ptr); 838 } 839 840 static jvmtiError GetFieldDeclaringClass(jvmtiEnv* env, 841 jclass klass, 842 jfieldID field, 843 jclass* declaring_class_ptr) { 844 ENSURE_VALID_ENV(env); 845 return FieldUtil::GetFieldDeclaringClass(env, klass, field, declaring_class_ptr); 846 } 847 848 static jvmtiError GetFieldModifiers(jvmtiEnv* env, 849 jclass klass, 850 jfieldID field, 851 jint* modifiers_ptr) { 852 ENSURE_VALID_ENV(env); 853 return FieldUtil::GetFieldModifiers(env, klass, field, modifiers_ptr); 854 } 855 856 static jvmtiError IsFieldSynthetic(jvmtiEnv* env, 857 jclass klass, 858 jfieldID field, 859 jboolean* is_synthetic_ptr) { 860 ENSURE_VALID_ENV(env); 861 ENSURE_HAS_CAP(env, can_get_synthetic_attribute); 862 return FieldUtil::IsFieldSynthetic(env, klass, field, is_synthetic_ptr); 863 } 864 865 static jvmtiError GetMethodName(jvmtiEnv* env, 866 jmethodID method, 867 char** name_ptr, 868 char** signature_ptr, 869 char** generic_ptr) { 870 ENSURE_VALID_ENV(env); 871 return MethodUtil::GetMethodName(env, method, name_ptr, signature_ptr, generic_ptr); 872 } 873 874 static jvmtiError GetMethodDeclaringClass(jvmtiEnv* env, 875 jmethodID method, 876 jclass* declaring_class_ptr) { 877 ENSURE_VALID_ENV(env); 878 return MethodUtil::GetMethodDeclaringClass(env, method, declaring_class_ptr); 879 } 880 881 static jvmtiError GetMethodModifiers(jvmtiEnv* env, 882 jmethodID method, 883 jint* modifiers_ptr) { 884 ENSURE_VALID_ENV(env); 885 return MethodUtil::GetMethodModifiers(env, method, modifiers_ptr); 886 } 887 888 static jvmtiError GetMaxLocals(jvmtiEnv* env, 889 jmethodID method, 890 jint* max_ptr) { 891 ENSURE_VALID_ENV(env); 892 return MethodUtil::GetMaxLocals(env, method, max_ptr); 893 } 894 895 static jvmtiError GetArgumentsSize(jvmtiEnv* env, 896 jmethodID method, 897 jint* size_ptr) { 898 ENSURE_VALID_ENV(env); 899 return MethodUtil::GetArgumentsSize(env, method, size_ptr); 900 } 901 902 static jvmtiError GetLineNumberTable(jvmtiEnv* env, 903 jmethodID method, 904 jint* entry_count_ptr, 905 jvmtiLineNumberEntry** table_ptr) { 906 ENSURE_VALID_ENV(env); 907 ENSURE_HAS_CAP(env, can_get_line_numbers); 908 return MethodUtil::GetLineNumberTable(env, method, entry_count_ptr, table_ptr); 909 } 910 911 static jvmtiError GetMethodLocation(jvmtiEnv* env, 912 jmethodID method, 913 jlocation* start_location_ptr, 914 jlocation* end_location_ptr) { 915 ENSURE_VALID_ENV(env); 916 return MethodUtil::GetMethodLocation(env, method, start_location_ptr, end_location_ptr); 917 } 918 919 static jvmtiError GetLocalVariableTable(jvmtiEnv* env, 920 jmethodID method, 921 jint* entry_count_ptr, 922 jvmtiLocalVariableEntry** table_ptr) { 923 ENSURE_VALID_ENV(env); 924 ENSURE_HAS_CAP(env, can_access_local_variables); 925 return MethodUtil::GetLocalVariableTable(env, method, entry_count_ptr, table_ptr); 926 } 927 928 static jvmtiError GetBytecodes(jvmtiEnv* env, 929 jmethodID method, 930 jint* bytecode_count_ptr, 931 unsigned char** bytecodes_ptr) { 932 ENSURE_VALID_ENV(env); 933 ENSURE_HAS_CAP(env, can_get_bytecodes); 934 return MethodUtil::GetBytecodes(env, method, bytecode_count_ptr, bytecodes_ptr); 935 } 936 937 static jvmtiError IsMethodNative(jvmtiEnv* env, jmethodID method, jboolean* is_native_ptr) { 938 ENSURE_VALID_ENV(env); 939 return MethodUtil::IsMethodNative(env, method, is_native_ptr); 940 } 941 942 static jvmtiError IsMethodSynthetic(jvmtiEnv* env, jmethodID method, jboolean* is_synthetic_ptr) { 943 ENSURE_VALID_ENV(env); 944 ENSURE_HAS_CAP(env, can_get_synthetic_attribute); 945 return MethodUtil::IsMethodSynthetic(env, method, is_synthetic_ptr); 946 } 947 948 static jvmtiError IsMethodObsolete(jvmtiEnv* env, jmethodID method, jboolean* is_obsolete_ptr) { 949 ENSURE_VALID_ENV(env); 950 return MethodUtil::IsMethodObsolete(env, method, is_obsolete_ptr); 951 } 952 953 static jvmtiError SetNativeMethodPrefix(jvmtiEnv* env, const char* prefix ATTRIBUTE_UNUSED) { 954 ENSURE_VALID_ENV(env); 955 ENSURE_HAS_CAP(env, can_set_native_method_prefix); 956 return ERR(NOT_IMPLEMENTED); 957 } 958 959 static jvmtiError SetNativeMethodPrefixes(jvmtiEnv* env, 960 jint prefix_count ATTRIBUTE_UNUSED, 961 char** prefixes ATTRIBUTE_UNUSED) { 962 ENSURE_VALID_ENV(env); 963 ENSURE_HAS_CAP(env, can_set_native_method_prefix); 964 return ERR(NOT_IMPLEMENTED); 965 } 966 967 static jvmtiError CreateRawMonitor(jvmtiEnv* env, const char* name, jrawMonitorID* monitor_ptr) { 968 ENSURE_VALID_ENV(env); 969 return MonitorUtil::CreateRawMonitor(env, name, monitor_ptr); 970 } 971 972 static jvmtiError DestroyRawMonitor(jvmtiEnv* env, jrawMonitorID monitor) { 973 ENSURE_VALID_ENV(env); 974 return MonitorUtil::DestroyRawMonitor(env, monitor); 975 } 976 977 static jvmtiError RawMonitorEnter(jvmtiEnv* env, jrawMonitorID monitor) { 978 ENSURE_VALID_ENV(env); 979 return MonitorUtil::RawMonitorEnter(env, monitor); 980 } 981 982 static jvmtiError RawMonitorExit(jvmtiEnv* env, jrawMonitorID monitor) { 983 ENSURE_VALID_ENV(env); 984 return MonitorUtil::RawMonitorExit(env, monitor); 985 } 986 987 static jvmtiError RawMonitorWait(jvmtiEnv* env, jrawMonitorID monitor, jlong millis) { 988 ENSURE_VALID_ENV(env); 989 return MonitorUtil::RawMonitorWait(env, monitor, millis); 990 } 991 992 static jvmtiError RawMonitorNotify(jvmtiEnv* env, jrawMonitorID monitor) { 993 ENSURE_VALID_ENV(env); 994 return MonitorUtil::RawMonitorNotify(env, monitor); 995 } 996 997 static jvmtiError RawMonitorNotifyAll(jvmtiEnv* env, jrawMonitorID monitor) { 998 ENSURE_VALID_ENV(env); 999 return MonitorUtil::RawMonitorNotifyAll(env, monitor); 1000 } 1001 1002 static jvmtiError SetJNIFunctionTable(jvmtiEnv* env, const jniNativeInterface* function_table) { 1003 ENSURE_VALID_ENV(env); 1004 return JNIUtil::SetJNIFunctionTable(env, function_table); 1005 } 1006 1007 static jvmtiError GetJNIFunctionTable(jvmtiEnv* env, jniNativeInterface** function_table) { 1008 ENSURE_VALID_ENV(env); 1009 return JNIUtil::GetJNIFunctionTable(env, function_table); 1010 } 1011 1012 // TODO: This will require locking, so that an agent can't remove callbacks when we're dispatching 1013 // an event. 1014 static jvmtiError SetEventCallbacks(jvmtiEnv* env, 1015 const jvmtiEventCallbacks* callbacks, 1016 jint size_of_callbacks) { 1017 ENSURE_VALID_ENV(env); 1018 if (size_of_callbacks < 0) { 1019 return ERR(ILLEGAL_ARGUMENT); 1020 } 1021 1022 if (callbacks == nullptr) { 1023 ArtJvmTiEnv::AsArtJvmTiEnv(env)->event_callbacks.reset(); 1024 return ERR(NONE); 1025 } 1026 1027 // Lock the event_info_mutex_ while we replace the callbacks. 1028 ArtJvmTiEnv* art_env = ArtJvmTiEnv::AsArtJvmTiEnv(env); 1029 art::WriterMutexLock lk(art::Thread::Current(), art_env->event_info_mutex_); 1030 std::unique_ptr<ArtJvmtiEventCallbacks> tmp(new ArtJvmtiEventCallbacks()); 1031 // Copy over the extension events. 1032 tmp->CopyExtensionsFrom(art_env->event_callbacks.get()); 1033 // Never overwrite the extension events. 1034 size_t copy_size = std::min(sizeof(jvmtiEventCallbacks), 1035 static_cast<size_t>(size_of_callbacks)); 1036 copy_size = art::RoundDown(copy_size, sizeof(void*)); 1037 // Copy non-extension events. 1038 memcpy(tmp.get(), callbacks, copy_size); 1039 1040 // replace the event table. 1041 art_env->event_callbacks = std::move(tmp); 1042 1043 return ERR(NONE); 1044 } 1045 1046 static jvmtiError SetEventNotificationMode(jvmtiEnv* env, 1047 jvmtiEventMode mode, 1048 jvmtiEvent event_type, 1049 jthread event_thread, 1050 ...) { 1051 ENSURE_VALID_ENV(env); 1052 art::Thread* art_thread = nullptr; 1053 if (event_thread != nullptr) { 1054 // TODO The locking around this call is less then what we really want. 1055 art::ScopedObjectAccess soa(art::Thread::Current()); 1056 art::MutexLock mu(soa.Self(), *art::Locks::thread_list_lock_); 1057 jvmtiError err = ERR(INTERNAL); 1058 if (!ThreadUtil::GetAliveNativeThread(event_thread, soa, &art_thread, &err)) { 1059 return err; 1060 } else if (art_thread->IsStillStarting()) { 1061 return ERR(THREAD_NOT_ALIVE); 1062 } 1063 } 1064 1065 ArtJvmTiEnv* art_env = ArtJvmTiEnv::AsArtJvmTiEnv(env); 1066 return gEventHandler->SetEvent(art_env, 1067 art_thread, 1068 GetArtJvmtiEvent(art_env, event_type), 1069 mode); 1070 } 1071 1072 static jvmtiError GenerateEvents(jvmtiEnv* env, 1073 jvmtiEvent event_type ATTRIBUTE_UNUSED) { 1074 ENSURE_VALID_ENV(env); 1075 return OK; 1076 } 1077 1078 static jvmtiError GetExtensionFunctions(jvmtiEnv* env, 1079 jint* extension_count_ptr, 1080 jvmtiExtensionFunctionInfo** extensions) { 1081 ENSURE_VALID_ENV(env); 1082 ENSURE_NON_NULL(extension_count_ptr); 1083 ENSURE_NON_NULL(extensions); 1084 return ExtensionUtil::GetExtensionFunctions(env, extension_count_ptr, extensions); 1085 } 1086 1087 static jvmtiError GetExtensionEvents(jvmtiEnv* env, 1088 jint* extension_count_ptr, 1089 jvmtiExtensionEventInfo** extensions) { 1090 ENSURE_VALID_ENV(env); 1091 ENSURE_NON_NULL(extension_count_ptr); 1092 ENSURE_NON_NULL(extensions); 1093 return ExtensionUtil::GetExtensionEvents(env, extension_count_ptr, extensions); 1094 } 1095 1096 static jvmtiError SetExtensionEventCallback(jvmtiEnv* env, 1097 jint extension_event_index, 1098 jvmtiExtensionEvent callback) { 1099 ENSURE_VALID_ENV(env); 1100 return ExtensionUtil::SetExtensionEventCallback(env, 1101 extension_event_index, 1102 callback, 1103 gEventHandler); 1104 } 1105 1106#define FOR_ALL_CAPABILITIES(FUN) \ 1107 FUN(can_tag_objects) \ 1108 FUN(can_generate_field_modification_events) \ 1109 FUN(can_generate_field_access_events) \ 1110 FUN(can_get_bytecodes) \ 1111 FUN(can_get_synthetic_attribute) \ 1112 FUN(can_get_owned_monitor_info) \ 1113 FUN(can_get_current_contended_monitor) \ 1114 FUN(can_get_monitor_info) \ 1115 FUN(can_pop_frame) \ 1116 FUN(can_redefine_classes) \ 1117 FUN(can_signal_thread) \ 1118 FUN(can_get_source_file_name) \ 1119 FUN(can_get_line_numbers) \ 1120 FUN(can_get_source_debug_extension) \ 1121 FUN(can_access_local_variables) \ 1122 FUN(can_maintain_original_method_order) \ 1123 FUN(can_generate_single_step_events) \ 1124 FUN(can_generate_exception_events) \ 1125 FUN(can_generate_frame_pop_events) \ 1126 FUN(can_generate_breakpoint_events) \ 1127 FUN(can_suspend) \ 1128 FUN(can_redefine_any_class) \ 1129 FUN(can_get_current_thread_cpu_time) \ 1130 FUN(can_get_thread_cpu_time) \ 1131 FUN(can_generate_method_entry_events) \ 1132 FUN(can_generate_method_exit_events) \ 1133 FUN(can_generate_all_class_hook_events) \ 1134 FUN(can_generate_compiled_method_load_events) \ 1135 FUN(can_generate_monitor_events) \ 1136 FUN(can_generate_vm_object_alloc_events) \ 1137 FUN(can_generate_native_method_bind_events) \ 1138 FUN(can_generate_garbage_collection_events) \ 1139 FUN(can_generate_object_free_events) \ 1140 FUN(can_force_early_return) \ 1141 FUN(can_get_owned_monitor_stack_depth_info) \ 1142 FUN(can_get_constant_pool) \ 1143 FUN(can_set_native_method_prefix) \ 1144 FUN(can_retransform_classes) \ 1145 FUN(can_retransform_any_class) \ 1146 FUN(can_generate_resource_exhaustion_heap_events) \ 1147 FUN(can_generate_resource_exhaustion_threads_events) 1148 1149 static jvmtiError GetPotentialCapabilities(jvmtiEnv* env, jvmtiCapabilities* capabilities_ptr) { 1150 ENSURE_VALID_ENV(env); 1151 ENSURE_NON_NULL(capabilities_ptr); 1152 *capabilities_ptr = kPotentialCapabilities; 1153 if (UNLIKELY(!IsFullJvmtiAvailable())) { 1154#define REMOVE_NONDEBUGGABLE_UNSUPPORTED(e) \ 1155 do { \ 1156 if (kNonDebuggableUnsupportedCapabilities.e == 1) { \ 1157 capabilities_ptr->e = 0; \ 1158 } \ 1159 } while (false); 1160 1161 FOR_ALL_CAPABILITIES(REMOVE_NONDEBUGGABLE_UNSUPPORTED); 1162#undef REMOVE_NONDEBUGGABLE_UNSUPPORTED 1163 } 1164 return OK; 1165 } 1166 1167 static jvmtiError AddCapabilities(jvmtiEnv* env, const jvmtiCapabilities* capabilities_ptr) { 1168 ENSURE_VALID_ENV(env); 1169 ENSURE_NON_NULL(capabilities_ptr); 1170 ArtJvmTiEnv* art_env = static_cast<ArtJvmTiEnv*>(env); 1171 jvmtiError ret = OK; 1172 jvmtiCapabilities changed = {}; 1173 jvmtiCapabilities potential_capabilities = {}; 1174 ret = env->GetPotentialCapabilities(&potential_capabilities); 1175 if (ret != OK) { 1176 return ret; 1177 } 1178#define ADD_CAPABILITY(e) \ 1179 do { \ 1180 if (capabilities_ptr->e == 1) { \ 1181 if (potential_capabilities.e == 1) { \ 1182 if (art_env->capabilities.e != 1) { \ 1183 art_env->capabilities.e = 1; \ 1184 changed.e = 1; \ 1185 }\ 1186 } else { \ 1187 ret = ERR(NOT_AVAILABLE); \ 1188 } \ 1189 } \ 1190 } while (false); 1191 1192 FOR_ALL_CAPABILITIES(ADD_CAPABILITY); 1193#undef ADD_CAPABILITY 1194 gEventHandler->HandleChangedCapabilities(ArtJvmTiEnv::AsArtJvmTiEnv(env), 1195 changed, 1196 /*added*/true); 1197 return ret; 1198 } 1199 1200 static jvmtiError RelinquishCapabilities(jvmtiEnv* env, 1201 const jvmtiCapabilities* capabilities_ptr) { 1202 ENSURE_VALID_ENV(env); 1203 ENSURE_NON_NULL(capabilities_ptr); 1204 ArtJvmTiEnv* art_env = reinterpret_cast<ArtJvmTiEnv*>(env); 1205 jvmtiCapabilities changed = {}; 1206#define DEL_CAPABILITY(e) \ 1207 do { \ 1208 if (capabilities_ptr->e == 1) { \ 1209 if (art_env->capabilities.e == 1) { \ 1210 art_env->capabilities.e = 0;\ 1211 changed.e = 1; \ 1212 } \ 1213 } \ 1214 } while (false); 1215 1216 FOR_ALL_CAPABILITIES(DEL_CAPABILITY); 1217#undef DEL_CAPABILITY 1218 gEventHandler->HandleChangedCapabilities(ArtJvmTiEnv::AsArtJvmTiEnv(env), 1219 changed, 1220 /*added*/false); 1221 return OK; 1222 } 1223 1224#undef FOR_ALL_CAPABILITIES 1225 1226 static jvmtiError GetCapabilities(jvmtiEnv* env, jvmtiCapabilities* capabilities_ptr) { 1227 ENSURE_VALID_ENV(env); 1228 ENSURE_NON_NULL(capabilities_ptr); 1229 ArtJvmTiEnv* artenv = reinterpret_cast<ArtJvmTiEnv*>(env); 1230 *capabilities_ptr = artenv->capabilities; 1231 return OK; 1232 } 1233 1234 static jvmtiError GetCurrentThreadCpuTimerInfo(jvmtiEnv* env, 1235 jvmtiTimerInfo* info_ptr ATTRIBUTE_UNUSED) { 1236 ENSURE_VALID_ENV(env); 1237 ENSURE_HAS_CAP(env, can_get_current_thread_cpu_time); 1238 return ERR(NOT_IMPLEMENTED); 1239 } 1240 1241 static jvmtiError GetCurrentThreadCpuTime(jvmtiEnv* env, jlong* nanos_ptr ATTRIBUTE_UNUSED) { 1242 ENSURE_VALID_ENV(env); 1243 ENSURE_HAS_CAP(env, can_get_current_thread_cpu_time); 1244 return ERR(NOT_IMPLEMENTED); 1245 } 1246 1247 static jvmtiError GetThreadCpuTimerInfo(jvmtiEnv* env, 1248 jvmtiTimerInfo* info_ptr ATTRIBUTE_UNUSED) { 1249 ENSURE_VALID_ENV(env); 1250 ENSURE_HAS_CAP(env, can_get_thread_cpu_time); 1251 return ERR(NOT_IMPLEMENTED); 1252 } 1253 1254 static jvmtiError GetThreadCpuTime(jvmtiEnv* env, 1255 jthread thread ATTRIBUTE_UNUSED, 1256 jlong* nanos_ptr ATTRIBUTE_UNUSED) { 1257 ENSURE_VALID_ENV(env); 1258 ENSURE_HAS_CAP(env, can_get_thread_cpu_time); 1259 return ERR(NOT_IMPLEMENTED); 1260 } 1261 1262 static jvmtiError GetTimerInfo(jvmtiEnv* env, jvmtiTimerInfo* info_ptr) { 1263 ENSURE_VALID_ENV(env); 1264 return TimerUtil::GetTimerInfo(env, info_ptr); 1265 } 1266 1267 static jvmtiError GetTime(jvmtiEnv* env, jlong* nanos_ptr) { 1268 ENSURE_VALID_ENV(env); 1269 return TimerUtil::GetTime(env, nanos_ptr); 1270 } 1271 1272 static jvmtiError GetAvailableProcessors(jvmtiEnv* env, jint* processor_count_ptr) { 1273 ENSURE_VALID_ENV(env); 1274 return TimerUtil::GetAvailableProcessors(env, processor_count_ptr); 1275 } 1276 1277 static jvmtiError AddToBootstrapClassLoaderSearch(jvmtiEnv* env, const char* segment) { 1278 ENSURE_VALID_ENV(env); 1279 return SearchUtil::AddToBootstrapClassLoaderSearch(env, segment); 1280 } 1281 1282 static jvmtiError AddToSystemClassLoaderSearch(jvmtiEnv* env, const char* segment) { 1283 ENSURE_VALID_ENV(env); 1284 return SearchUtil::AddToSystemClassLoaderSearch(env, segment); 1285 } 1286 1287 static jvmtiError GetSystemProperties(jvmtiEnv* env, jint* count_ptr, char*** property_ptr) { 1288 ENSURE_VALID_ENV(env); 1289 return PropertiesUtil::GetSystemProperties(env, count_ptr, property_ptr); 1290 } 1291 1292 static jvmtiError GetSystemProperty(jvmtiEnv* env, const char* property, char** value_ptr) { 1293 ENSURE_VALID_ENV(env); 1294 return PropertiesUtil::GetSystemProperty(env, property, value_ptr); 1295 } 1296 1297 static jvmtiError SetSystemProperty(jvmtiEnv* env, const char* property, const char* value) { 1298 ENSURE_VALID_ENV(env); 1299 return PropertiesUtil::SetSystemProperty(env, property, value); 1300 } 1301 1302 static jvmtiError GetPhase(jvmtiEnv* env, jvmtiPhase* phase_ptr) { 1303 ENSURE_VALID_ENV(env); 1304 return PhaseUtil::GetPhase(env, phase_ptr); 1305 } 1306 1307 static jvmtiError DisposeEnvironment(jvmtiEnv* env) { 1308 ENSURE_VALID_ENV(env); 1309 ArtJvmTiEnv* tienv = ArtJvmTiEnv::AsArtJvmTiEnv(env); 1310 gEventHandler->RemoveArtJvmTiEnv(tienv); 1311 art::Runtime::Current()->RemoveSystemWeakHolder(tienv->object_tag_table.get()); 1312 ThreadUtil::RemoveEnvironment(tienv); 1313 delete tienv; 1314 return OK; 1315 } 1316 1317 static jvmtiError SetEnvironmentLocalStorage(jvmtiEnv* env, const void* data) { 1318 ENSURE_VALID_ENV(env); 1319 reinterpret_cast<ArtJvmTiEnv*>(env)->local_data = const_cast<void*>(data); 1320 return OK; 1321 } 1322 1323 static jvmtiError GetEnvironmentLocalStorage(jvmtiEnv* env, void** data_ptr) { 1324 ENSURE_VALID_ENV(env); 1325 *data_ptr = reinterpret_cast<ArtJvmTiEnv*>(env)->local_data; 1326 return OK; 1327 } 1328 1329 static jvmtiError GetVersionNumber(jvmtiEnv* env, jint* version_ptr) { 1330 ENSURE_VALID_ENV(env); 1331 *version_ptr = ArtJvmTiEnv::AsArtJvmTiEnv(env)->ti_version; 1332 return OK; 1333 } 1334 1335 static jvmtiError GetErrorName(jvmtiEnv* env, jvmtiError error, char** name_ptr) { 1336 ENSURE_NON_NULL(name_ptr); 1337 auto copy_fn = [&](const char* name_cstr) { 1338 jvmtiError res; 1339 JvmtiUniquePtr<char[]> copy = CopyString(env, name_cstr, &res); 1340 if (copy == nullptr) { 1341 *name_ptr = nullptr; 1342 return res; 1343 } else { 1344 *name_ptr = copy.release(); 1345 return OK; 1346 } 1347 }; 1348 switch (error) { 1349#define ERROR_CASE(e) case (JVMTI_ERROR_ ## e) : \ 1350 return copy_fn("JVMTI_ERROR_"#e); 1351 ERROR_CASE(NONE); 1352 ERROR_CASE(INVALID_THREAD); 1353 ERROR_CASE(INVALID_THREAD_GROUP); 1354 ERROR_CASE(INVALID_PRIORITY); 1355 ERROR_CASE(THREAD_NOT_SUSPENDED); 1356 ERROR_CASE(THREAD_SUSPENDED); 1357 ERROR_CASE(THREAD_NOT_ALIVE); 1358 ERROR_CASE(INVALID_OBJECT); 1359 ERROR_CASE(INVALID_CLASS); 1360 ERROR_CASE(CLASS_NOT_PREPARED); 1361 ERROR_CASE(INVALID_METHODID); 1362 ERROR_CASE(INVALID_LOCATION); 1363 ERROR_CASE(INVALID_FIELDID); 1364 ERROR_CASE(NO_MORE_FRAMES); 1365 ERROR_CASE(OPAQUE_FRAME); 1366 ERROR_CASE(TYPE_MISMATCH); 1367 ERROR_CASE(INVALID_SLOT); 1368 ERROR_CASE(DUPLICATE); 1369 ERROR_CASE(NOT_FOUND); 1370 ERROR_CASE(INVALID_MONITOR); 1371 ERROR_CASE(NOT_MONITOR_OWNER); 1372 ERROR_CASE(INTERRUPT); 1373 ERROR_CASE(INVALID_CLASS_FORMAT); 1374 ERROR_CASE(CIRCULAR_CLASS_DEFINITION); 1375 ERROR_CASE(FAILS_VERIFICATION); 1376 ERROR_CASE(UNSUPPORTED_REDEFINITION_METHOD_ADDED); 1377 ERROR_CASE(UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED); 1378 ERROR_CASE(INVALID_TYPESTATE); 1379 ERROR_CASE(UNSUPPORTED_REDEFINITION_HIERARCHY_CHANGED); 1380 ERROR_CASE(UNSUPPORTED_REDEFINITION_METHOD_DELETED); 1381 ERROR_CASE(UNSUPPORTED_VERSION); 1382 ERROR_CASE(NAMES_DONT_MATCH); 1383 ERROR_CASE(UNSUPPORTED_REDEFINITION_CLASS_MODIFIERS_CHANGED); 1384 ERROR_CASE(UNSUPPORTED_REDEFINITION_METHOD_MODIFIERS_CHANGED); 1385 ERROR_CASE(UNMODIFIABLE_CLASS); 1386 ERROR_CASE(NOT_AVAILABLE); 1387 ERROR_CASE(MUST_POSSESS_CAPABILITY); 1388 ERROR_CASE(NULL_POINTER); 1389 ERROR_CASE(ABSENT_INFORMATION); 1390 ERROR_CASE(INVALID_EVENT_TYPE); 1391 ERROR_CASE(ILLEGAL_ARGUMENT); 1392 ERROR_CASE(NATIVE_METHOD); 1393 ERROR_CASE(CLASS_LOADER_UNSUPPORTED); 1394 ERROR_CASE(OUT_OF_MEMORY); 1395 ERROR_CASE(ACCESS_DENIED); 1396 ERROR_CASE(WRONG_PHASE); 1397 ERROR_CASE(INTERNAL); 1398 ERROR_CASE(UNATTACHED_THREAD); 1399 ERROR_CASE(INVALID_ENVIRONMENT); 1400#undef ERROR_CASE 1401 } 1402 1403 return ERR(ILLEGAL_ARGUMENT); 1404 } 1405 1406 static jvmtiError SetVerboseFlag(jvmtiEnv* env, 1407 jvmtiVerboseFlag flag, 1408 jboolean value) { 1409 ENSURE_VALID_ENV(env); 1410 if (flag == jvmtiVerboseFlag::JVMTI_VERBOSE_OTHER) { 1411 // OTHER is special, as it's 0, so can't do a bit check. 1412 bool val = (value == JNI_TRUE) ? true : false; 1413 1414 art::gLogVerbosity.collector = val; 1415 art::gLogVerbosity.compiler = val; 1416 art::gLogVerbosity.deopt = val; 1417 art::gLogVerbosity.heap = val; 1418 art::gLogVerbosity.jdwp = val; 1419 art::gLogVerbosity.jit = val; 1420 art::gLogVerbosity.monitor = val; 1421 art::gLogVerbosity.oat = val; 1422 art::gLogVerbosity.profiler = val; 1423 art::gLogVerbosity.signals = val; 1424 art::gLogVerbosity.simulator = val; 1425 art::gLogVerbosity.startup = val; 1426 art::gLogVerbosity.third_party_jni = val; 1427 art::gLogVerbosity.threads = val; 1428 art::gLogVerbosity.verifier = val; 1429 // Do not set verifier-debug. 1430 art::gLogVerbosity.image = val; 1431 1432 // Note: can't switch systrace_lock_logging. That requires changing entrypoints. 1433 1434 art::gLogVerbosity.agents = val; 1435 } else { 1436 // Spec isn't clear whether "flag" is a mask or supposed to be single. We implement the mask 1437 // semantics. 1438 constexpr std::underlying_type<jvmtiVerboseFlag>::type kMask = 1439 jvmtiVerboseFlag::JVMTI_VERBOSE_GC | 1440 jvmtiVerboseFlag::JVMTI_VERBOSE_CLASS | 1441 jvmtiVerboseFlag::JVMTI_VERBOSE_JNI; 1442 if ((flag & ~kMask) != 0) { 1443 return ERR(ILLEGAL_ARGUMENT); 1444 } 1445 1446 bool val = (value == JNI_TRUE) ? true : false; 1447 1448 if ((flag & jvmtiVerboseFlag::JVMTI_VERBOSE_GC) != 0) { 1449 art::gLogVerbosity.gc = val; 1450 } 1451 1452 if ((flag & jvmtiVerboseFlag::JVMTI_VERBOSE_CLASS) != 0) { 1453 art::gLogVerbosity.class_linker = val; 1454 } 1455 1456 if ((flag & jvmtiVerboseFlag::JVMTI_VERBOSE_JNI) != 0) { 1457 art::gLogVerbosity.jni = val; 1458 } 1459 } 1460 1461 return ERR(NONE); 1462 } 1463 1464 static jvmtiError GetJLocationFormat(jvmtiEnv* env, jvmtiJlocationFormat* format_ptr) { 1465 ENSURE_VALID_ENV(env); 1466 // Report BCI as jlocation format. We report dex bytecode indices. 1467 if (format_ptr == nullptr) { 1468 return ERR(NULL_POINTER); 1469 } 1470 *format_ptr = jvmtiJlocationFormat::JVMTI_JLOCATION_JVMBCI; 1471 return ERR(NONE); 1472 } 1473}; 1474 1475static bool IsJvmtiVersion(jint version) { 1476 return version == JVMTI_VERSION_1 || 1477 version == JVMTI_VERSION_1_0 || 1478 version == JVMTI_VERSION_1_1 || 1479 version == JVMTI_VERSION_1_2 || 1480 version == JVMTI_VERSION; 1481} 1482 1483extern const jvmtiInterface_1 gJvmtiInterface; 1484 1485ArtJvmTiEnv::ArtJvmTiEnv(art::JavaVMExt* runtime, EventHandler* event_handler, jint version) 1486 : art_vm(runtime), 1487 local_data(nullptr), 1488 ti_version(version), 1489 capabilities(), 1490 event_info_mutex_("jvmtiEnv_EventInfoMutex") { 1491 object_tag_table = std::unique_ptr<ObjectTagTable>(new ObjectTagTable(event_handler, this)); 1492 functions = &gJvmtiInterface; 1493} 1494 1495// Creates a jvmtiEnv and returns it with the art::ti::Env that is associated with it. new_art_ti 1496// is a pointer to the uninitialized memory for an art::ti::Env. 1497static void CreateArtJvmTiEnv(art::JavaVMExt* vm, jint version, /*out*/void** new_jvmtiEnv) { 1498 struct ArtJvmTiEnv* env = new ArtJvmTiEnv(vm, gEventHandler, version); 1499 *new_jvmtiEnv = env; 1500 1501 gEventHandler->RegisterArtJvmTiEnv(env); 1502 1503 art::Runtime::Current()->AddSystemWeakHolder( 1504 ArtJvmTiEnv::AsArtJvmTiEnv(env)->object_tag_table.get()); 1505} 1506 1507// A hook that the runtime uses to allow plugins to handle GetEnv calls. It returns true and 1508// places the return value in 'env' if this library can handle the GetEnv request. Otherwise 1509// returns false and does not modify the 'env' pointer. 1510static jint GetEnvHandler(art::JavaVMExt* vm, /*out*/void** env, jint version) { 1511 // JavaDebuggable will either be set by the runtime as it is starting up or the plugin if it's 1512 // loaded early enough. If this is false we cannot guarantee conformance to all JVMTI behaviors 1513 // due to optimizations. We will only allow agents to get ArtTiEnvs using the kArtTiVersion. 1514 if (IsFullJvmtiAvailable() && IsJvmtiVersion(version)) { 1515 CreateArtJvmTiEnv(vm, JVMTI_VERSION, env); 1516 return JNI_OK; 1517 } else if (version == kArtTiVersion) { 1518 CreateArtJvmTiEnv(vm, kArtTiVersion, env); 1519 return JNI_OK; 1520 } else { 1521 printf("version 0x%x is not valid!", version); 1522 return JNI_EVERSION; 1523 } 1524} 1525 1526// The plugin initialization function. This adds the jvmti environment. 1527extern "C" bool ArtPlugin_Initialize() { 1528 art::Runtime* runtime = art::Runtime::Current(); 1529 1530 gDeoptManager = new DeoptManager; 1531 gEventHandler = new EventHandler; 1532 1533 gDeoptManager->Setup(); 1534 if (runtime->IsStarted()) { 1535 PhaseUtil::SetToLive(); 1536 } else { 1537 PhaseUtil::SetToOnLoad(); 1538 } 1539 PhaseUtil::Register(gEventHandler); 1540 ThreadUtil::Register(gEventHandler); 1541 ClassUtil::Register(gEventHandler); 1542 DumpUtil::Register(gEventHandler); 1543 MethodUtil::Register(gEventHandler); 1544 SearchUtil::Register(); 1545 HeapUtil::Register(); 1546 Transformer::Setup(); 1547 1548 { 1549 // Make sure we can deopt anything we need to. 1550 art::ScopedObjectAccess soa(art::Thread::Current()); 1551 gDeoptManager->FinishSetup(); 1552 } 1553 1554 runtime->GetJavaVM()->AddEnvironmentHook(GetEnvHandler); 1555 1556 return true; 1557} 1558 1559extern "C" bool ArtPlugin_Deinitialize() { 1560 gEventHandler->Shutdown(); 1561 gDeoptManager->Shutdown(); 1562 PhaseUtil::Unregister(); 1563 ThreadUtil::Unregister(); 1564 ClassUtil::Unregister(); 1565 DumpUtil::Unregister(); 1566 MethodUtil::Unregister(); 1567 SearchUtil::Unregister(); 1568 HeapUtil::Unregister(); 1569 1570 // TODO It would be good to delete the gEventHandler and gDeoptManager here but we cannot since 1571 // daemon threads might be suspended and we want to make sure that even if they wake up briefly 1572 // they won't hit deallocated memory. By this point none of the functions will do anything since 1573 // they have already shutdown. 1574 1575 return true; 1576} 1577 1578// The actual struct holding all of the entrypoints into the jvmti interface. 1579const jvmtiInterface_1 gJvmtiInterface = { 1580 nullptr, // reserved1 1581 JvmtiFunctions::SetEventNotificationMode, 1582 nullptr, // reserved3 1583 JvmtiFunctions::GetAllThreads, 1584 JvmtiFunctions::SuspendThread, 1585 JvmtiFunctions::ResumeThread, 1586 JvmtiFunctions::StopThread, 1587 JvmtiFunctions::InterruptThread, 1588 JvmtiFunctions::GetThreadInfo, 1589 JvmtiFunctions::GetOwnedMonitorInfo, // 10 1590 JvmtiFunctions::GetCurrentContendedMonitor, 1591 JvmtiFunctions::RunAgentThread, 1592 JvmtiFunctions::GetTopThreadGroups, 1593 JvmtiFunctions::GetThreadGroupInfo, 1594 JvmtiFunctions::GetThreadGroupChildren, 1595 JvmtiFunctions::GetFrameCount, 1596 JvmtiFunctions::GetThreadState, 1597 JvmtiFunctions::GetCurrentThread, 1598 JvmtiFunctions::GetFrameLocation, 1599 JvmtiFunctions::NotifyFramePop, // 20 1600 JvmtiFunctions::GetLocalObject, 1601 JvmtiFunctions::GetLocalInt, 1602 JvmtiFunctions::GetLocalLong, 1603 JvmtiFunctions::GetLocalFloat, 1604 JvmtiFunctions::GetLocalDouble, 1605 JvmtiFunctions::SetLocalObject, 1606 JvmtiFunctions::SetLocalInt, 1607 JvmtiFunctions::SetLocalLong, 1608 JvmtiFunctions::SetLocalFloat, 1609 JvmtiFunctions::SetLocalDouble, // 30 1610 JvmtiFunctions::CreateRawMonitor, 1611 JvmtiFunctions::DestroyRawMonitor, 1612 JvmtiFunctions::RawMonitorEnter, 1613 JvmtiFunctions::RawMonitorExit, 1614 JvmtiFunctions::RawMonitorWait, 1615 JvmtiFunctions::RawMonitorNotify, 1616 JvmtiFunctions::RawMonitorNotifyAll, 1617 JvmtiFunctions::SetBreakpoint, 1618 JvmtiFunctions::ClearBreakpoint, 1619 nullptr, // reserved40 1620 JvmtiFunctions::SetFieldAccessWatch, 1621 JvmtiFunctions::ClearFieldAccessWatch, 1622 JvmtiFunctions::SetFieldModificationWatch, 1623 JvmtiFunctions::ClearFieldModificationWatch, 1624 JvmtiFunctions::IsModifiableClass, 1625 JvmtiFunctions::Allocate, 1626 JvmtiFunctions::Deallocate, 1627 JvmtiFunctions::GetClassSignature, 1628 JvmtiFunctions::GetClassStatus, 1629 JvmtiFunctions::GetSourceFileName, // 50 1630 JvmtiFunctions::GetClassModifiers, 1631 JvmtiFunctions::GetClassMethods, 1632 JvmtiFunctions::GetClassFields, 1633 JvmtiFunctions::GetImplementedInterfaces, 1634 JvmtiFunctions::IsInterface, 1635 JvmtiFunctions::IsArrayClass, 1636 JvmtiFunctions::GetClassLoader, 1637 JvmtiFunctions::GetObjectHashCode, 1638 JvmtiFunctions::GetObjectMonitorUsage, 1639 JvmtiFunctions::GetFieldName, // 60 1640 JvmtiFunctions::GetFieldDeclaringClass, 1641 JvmtiFunctions::GetFieldModifiers, 1642 JvmtiFunctions::IsFieldSynthetic, 1643 JvmtiFunctions::GetMethodName, 1644 JvmtiFunctions::GetMethodDeclaringClass, 1645 JvmtiFunctions::GetMethodModifiers, 1646 nullptr, // reserved67 1647 JvmtiFunctions::GetMaxLocals, 1648 JvmtiFunctions::GetArgumentsSize, 1649 JvmtiFunctions::GetLineNumberTable, // 70 1650 JvmtiFunctions::GetMethodLocation, 1651 JvmtiFunctions::GetLocalVariableTable, 1652 JvmtiFunctions::SetNativeMethodPrefix, 1653 JvmtiFunctions::SetNativeMethodPrefixes, 1654 JvmtiFunctions::GetBytecodes, 1655 JvmtiFunctions::IsMethodNative, 1656 JvmtiFunctions::IsMethodSynthetic, 1657 JvmtiFunctions::GetLoadedClasses, 1658 JvmtiFunctions::GetClassLoaderClasses, 1659 JvmtiFunctions::PopFrame, // 80 1660 JvmtiFunctions::ForceEarlyReturnObject, 1661 JvmtiFunctions::ForceEarlyReturnInt, 1662 JvmtiFunctions::ForceEarlyReturnLong, 1663 JvmtiFunctions::ForceEarlyReturnFloat, 1664 JvmtiFunctions::ForceEarlyReturnDouble, 1665 JvmtiFunctions::ForceEarlyReturnVoid, 1666 JvmtiFunctions::RedefineClasses, 1667 JvmtiFunctions::GetVersionNumber, 1668 JvmtiFunctions::GetCapabilities, 1669 JvmtiFunctions::GetSourceDebugExtension, // 90 1670 JvmtiFunctions::IsMethodObsolete, 1671 JvmtiFunctions::SuspendThreadList, 1672 JvmtiFunctions::ResumeThreadList, 1673 nullptr, // reserved94 1674 nullptr, // reserved95 1675 nullptr, // reserved96 1676 nullptr, // reserved97 1677 nullptr, // reserved98 1678 nullptr, // reserved99 1679 JvmtiFunctions::GetAllStackTraces, // 100 1680 JvmtiFunctions::GetThreadListStackTraces, 1681 JvmtiFunctions::GetThreadLocalStorage, 1682 JvmtiFunctions::SetThreadLocalStorage, 1683 JvmtiFunctions::GetStackTrace, 1684 nullptr, // reserved105 1685 JvmtiFunctions::GetTag, 1686 JvmtiFunctions::SetTag, 1687 JvmtiFunctions::ForceGarbageCollection, 1688 JvmtiFunctions::IterateOverObjectsReachableFromObject, 1689 JvmtiFunctions::IterateOverReachableObjects, // 110 1690 JvmtiFunctions::IterateOverHeap, 1691 JvmtiFunctions::IterateOverInstancesOfClass, 1692 nullptr, // reserved113 1693 JvmtiFunctions::GetObjectsWithTags, 1694 JvmtiFunctions::FollowReferences, 1695 JvmtiFunctions::IterateThroughHeap, 1696 nullptr, // reserved117 1697 nullptr, // reserved118 1698 nullptr, // reserved119 1699 JvmtiFunctions::SetJNIFunctionTable, // 120 1700 JvmtiFunctions::GetJNIFunctionTable, 1701 JvmtiFunctions::SetEventCallbacks, 1702 JvmtiFunctions::GenerateEvents, 1703 JvmtiFunctions::GetExtensionFunctions, 1704 JvmtiFunctions::GetExtensionEvents, 1705 JvmtiFunctions::SetExtensionEventCallback, 1706 JvmtiFunctions::DisposeEnvironment, 1707 JvmtiFunctions::GetErrorName, 1708 JvmtiFunctions::GetJLocationFormat, 1709 JvmtiFunctions::GetSystemProperties, // 130 1710 JvmtiFunctions::GetSystemProperty, 1711 JvmtiFunctions::SetSystemProperty, 1712 JvmtiFunctions::GetPhase, 1713 JvmtiFunctions::GetCurrentThreadCpuTimerInfo, 1714 JvmtiFunctions::GetCurrentThreadCpuTime, 1715 JvmtiFunctions::GetThreadCpuTimerInfo, 1716 JvmtiFunctions::GetThreadCpuTime, 1717 JvmtiFunctions::GetTimerInfo, 1718 JvmtiFunctions::GetTime, 1719 JvmtiFunctions::GetPotentialCapabilities, // 140 1720 nullptr, // reserved141 1721 JvmtiFunctions::AddCapabilities, 1722 JvmtiFunctions::RelinquishCapabilities, 1723 JvmtiFunctions::GetAvailableProcessors, 1724 JvmtiFunctions::GetClassVersionNumbers, 1725 JvmtiFunctions::GetConstantPool, 1726 JvmtiFunctions::GetEnvironmentLocalStorage, 1727 JvmtiFunctions::SetEnvironmentLocalStorage, 1728 JvmtiFunctions::AddToBootstrapClassLoaderSearch, 1729 JvmtiFunctions::SetVerboseFlag, // 150 1730 JvmtiFunctions::AddToSystemClassLoaderSearch, 1731 JvmtiFunctions::RetransformClasses, 1732 JvmtiFunctions::GetOwnedMonitorStackDepthInfo, 1733 JvmtiFunctions::GetObjectSize, 1734 JvmtiFunctions::GetLocalInstance, 1735}; 1736 1737}; // namespace openjdkjvmti 1738