| /* |
| * Copyright (C) 2013 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <inttypes.h> |
| |
| #include <cstdio> |
| #include <memory> |
| #include <string> |
| #include <vector> |
| |
| #include "android-base/logging.h" |
| #include "android-base/stringprintf.h" |
| |
| #include "jni.h" |
| #include "jvmti.h" |
| #include "scoped_local_ref.h" |
| #include "scoped_utf_chars.h" |
| |
| // Test infrastructure |
| #include "jni_binder.h" |
| #include "jni_helper.h" |
| #include "jvmti_helper.h" |
| #include "test_env.h" |
| #include "ti_macros.h" |
| |
| namespace art { |
| namespace Test1953PopFrame { |
| |
| struct TestData { |
| jlocation target_loc; |
| jmethodID target_method; |
| jclass target_klass; |
| jfieldID target_field; |
| jrawMonitorID notify_monitor; |
| jint frame_pop_offset; |
| jmethodID frame_pop_setup_method; |
| std::vector<std::string> interesting_classes; |
| bool hit_location; |
| |
| TestData(jvmtiEnv* jvmti, |
| JNIEnv* env, |
| jlocation loc, |
| jobject meth, |
| jclass klass, |
| jobject field, |
| jobject setup_meth, |
| jint pop_offset, |
| const std::vector<std::string>&& interesting) |
| : target_loc(loc), |
| target_method(meth != nullptr ? env->FromReflectedMethod(meth) : nullptr), |
| target_klass(reinterpret_cast<jclass>(env->NewGlobalRef(klass))), |
| target_field(field != nullptr ? env->FromReflectedField(field) : nullptr), |
| frame_pop_offset(pop_offset), |
| frame_pop_setup_method(setup_meth != nullptr ? env->FromReflectedMethod(setup_meth) |
| : nullptr), |
| interesting_classes(interesting), |
| hit_location(false) { |
| JvmtiErrorToException(env, jvmti, jvmti->CreateRawMonitor("SuspendStopMonitor", |
| ¬ify_monitor)); |
| } |
| |
| void PerformSuspend(jvmtiEnv* jvmti, JNIEnv* env) { |
| // Wake up the waiting thread. |
| JvmtiErrorToException(env, jvmti, jvmti->RawMonitorEnter(notify_monitor)); |
| hit_location = true; |
| JvmtiErrorToException(env, jvmti, jvmti->RawMonitorNotifyAll(notify_monitor)); |
| JvmtiErrorToException(env, jvmti, jvmti->RawMonitorExit(notify_monitor)); |
| // Suspend ourself |
| jvmti->SuspendThread(nullptr); |
| } |
| }; |
| |
| void JNICALL cbSingleStep(jvmtiEnv* jvmti, |
| JNIEnv* env, |
| jthread thr, |
| jmethodID meth, |
| jlocation loc) { |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti, |
| jvmti->GetThreadLocalStorage(thr, reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data != nullptr); |
| if (meth != data->target_method || loc != data->target_loc) { |
| return; |
| } |
| data->PerformSuspend(jvmti, env); |
| } |
| |
| void JNICALL cbExceptionCatch(jvmtiEnv *jvmti, |
| JNIEnv* env, |
| jthread thr, |
| jmethodID method, |
| jlocation location ATTRIBUTE_UNUSED, |
| jobject exception ATTRIBUTE_UNUSED) { |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti, |
| jvmti->GetThreadLocalStorage(thr, reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data != nullptr); |
| if (method != data->target_method) { |
| return; |
| } |
| data->PerformSuspend(jvmti, env); |
| } |
| |
| void JNICALL cbException(jvmtiEnv *jvmti, |
| JNIEnv* env, |
| jthread thr, |
| jmethodID method, |
| jlocation location ATTRIBUTE_UNUSED, |
| jobject exception ATTRIBUTE_UNUSED, |
| jmethodID catch_method ATTRIBUTE_UNUSED, |
| jlocation catch_location ATTRIBUTE_UNUSED) { |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti, |
| jvmti->GetThreadLocalStorage(thr, reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data != nullptr); |
| if (method != data->target_method) { |
| return; |
| } |
| data->PerformSuspend(jvmti, env); |
| } |
| |
| void JNICALL cbMethodEntry(jvmtiEnv *jvmti, |
| JNIEnv* env, |
| jthread thr, |
| jmethodID method) { |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti, |
| jvmti->GetThreadLocalStorage(thr, reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data != nullptr); |
| if (method != data->target_method) { |
| return; |
| } |
| data->PerformSuspend(jvmti, env); |
| } |
| |
| void JNICALL cbMethodExit(jvmtiEnv *jvmti, |
| JNIEnv* env, |
| jthread thr, |
| jmethodID method, |
| jboolean was_popped_by_exception ATTRIBUTE_UNUSED, |
| jvalue return_value ATTRIBUTE_UNUSED) { |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti, |
| jvmti->GetThreadLocalStorage(thr, reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data != nullptr); |
| if (method != data->target_method) { |
| return; |
| } |
| data->PerformSuspend(jvmti, env); |
| } |
| |
| void JNICALL cbFieldModification(jvmtiEnv* jvmti, |
| JNIEnv* env, |
| jthread thr, |
| jmethodID method ATTRIBUTE_UNUSED, |
| jlocation location ATTRIBUTE_UNUSED, |
| jclass field_klass ATTRIBUTE_UNUSED, |
| jobject object ATTRIBUTE_UNUSED, |
| jfieldID field, |
| char signature_type ATTRIBUTE_UNUSED, |
| jvalue new_value ATTRIBUTE_UNUSED) { |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti, |
| jvmti->GetThreadLocalStorage(thr, reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data != nullptr); |
| if (field != data->target_field) { |
| // TODO What to do here. |
| LOG(FATAL) << "Strange, shouldn't get here!"; |
| } |
| data->PerformSuspend(jvmti, env); |
| } |
| |
| void JNICALL cbFieldAccess(jvmtiEnv* jvmti, |
| JNIEnv* env, |
| jthread thr, |
| jmethodID method ATTRIBUTE_UNUSED, |
| jlocation location ATTRIBUTE_UNUSED, |
| jclass field_klass, |
| jobject object ATTRIBUTE_UNUSED, |
| jfieldID field) { |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti, |
| jvmti->GetThreadLocalStorage(thr, reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data != nullptr); |
| if (field != data->target_field || !env->IsSameObject(field_klass, data->target_klass)) { |
| // TODO What to do here. |
| LOG(FATAL) << "Strange, shouldn't get here!"; |
| } |
| data->PerformSuspend(jvmti, env); |
| } |
| |
| void JNICALL cbBreakpointHit(jvmtiEnv* jvmti, |
| JNIEnv* env, |
| jthread thr, |
| jmethodID method, |
| jlocation loc) { |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti, |
| jvmti->GetThreadLocalStorage(thr, reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data != nullptr); |
| if (data->frame_pop_setup_method == method) { |
| CHECK(loc == 0) << "We should have stopped at location 0"; |
| if (JvmtiErrorToException(env, |
| jvmti, |
| jvmti->NotifyFramePop(thr, data->frame_pop_offset))) { |
| return; |
| } |
| return; |
| } |
| if (method != data->target_method || loc != data->target_loc) { |
| // TODO What to do here. |
| LOG(FATAL) << "Strange, shouldn't get here!"; |
| } |
| data->PerformSuspend(jvmti, env); |
| } |
| |
| void JNICALL cbFramePop(jvmtiEnv* jvmti, |
| JNIEnv* env, |
| jthread thr, |
| jmethodID method ATTRIBUTE_UNUSED, |
| jboolean was_popped_by_exception ATTRIBUTE_UNUSED) { |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti, |
| jvmti->GetThreadLocalStorage(thr, reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data != nullptr); |
| data->PerformSuspend(jvmti, env); |
| } |
| |
| void JNICALL cbClassLoadOrPrepare(jvmtiEnv* jvmti, |
| JNIEnv* env, |
| jthread thr, |
| jclass klass) { |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti, |
| jvmti->GetThreadLocalStorage(thr, reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data != nullptr); |
| char* name; |
| if (JvmtiErrorToException(env, jvmti, jvmti->GetClassSignature(klass, &name, nullptr))) { |
| return; |
| } |
| std::string name_str(name); |
| if (JvmtiErrorToException(env, |
| jvmti, |
| jvmti->Deallocate(reinterpret_cast<unsigned char*>(name)))) { |
| return; |
| } |
| if (std::find(data->interesting_classes.cbegin(), |
| data->interesting_classes.cend(), |
| name_str) != data->interesting_classes.cend()) { |
| data->PerformSuspend(jvmti, env); |
| } |
| } |
| |
| extern "C" JNIEXPORT |
| void JNICALL Java_art_Test1953_setupTest(JNIEnv* env, jclass klass ATTRIBUTE_UNUSED) { |
| jvmtiCapabilities caps; |
| memset(&caps, 0, sizeof(caps)); |
| // Most of these will already be there but might as well be complete. |
| caps.can_pop_frame = 1; |
| caps.can_generate_single_step_events = 1; |
| caps.can_generate_breakpoint_events = 1; |
| caps.can_suspend = 1; |
| caps.can_generate_method_entry_events = 1; |
| caps.can_generate_method_exit_events = 1; |
| caps.can_generate_monitor_events = 1; |
| caps.can_generate_exception_events = 1; |
| caps.can_generate_frame_pop_events = 1; |
| caps.can_generate_field_access_events = 1; |
| caps.can_generate_field_modification_events = 1; |
| caps.can_redefine_classes = 1; |
| if (JvmtiErrorToException(env, jvmti_env, jvmti_env->AddCapabilities(&caps))) { |
| return; |
| } |
| jvmtiEventCallbacks cb; |
| memset(&cb, 0, sizeof(cb)); |
| // TODO Add the rest of these. |
| cb.Breakpoint = cbBreakpointHit; |
| cb.SingleStep = cbSingleStep; |
| cb.FieldAccess = cbFieldAccess; |
| cb.FieldModification = cbFieldModification; |
| cb.MethodEntry = cbMethodEntry; |
| cb.MethodExit = cbMethodExit; |
| cb.Exception = cbException; |
| cb.ExceptionCatch = cbExceptionCatch; |
| cb.FramePop = cbFramePop; |
| cb.ClassLoad = cbClassLoadOrPrepare; |
| cb.ClassPrepare = cbClassLoadOrPrepare; |
| JvmtiErrorToException(env, jvmti_env, jvmti_env->SetEventCallbacks(&cb, sizeof(cb))); |
| } |
| |
| static bool DeleteTestData(JNIEnv* env, jthread thr, TestData* data) { |
| env->DeleteGlobalRef(data->target_klass); |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetThreadLocalStorage(thr, nullptr))) { |
| return false; |
| } |
| return JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->Deallocate(reinterpret_cast<uint8_t*>(data))); |
| } |
| |
| static TestData* SetupTestData(JNIEnv* env, |
| jobject meth, |
| jlocation loc, |
| jclass target_klass, |
| jobject field, |
| jobject setup_meth, |
| jint pop_offset, |
| const std::vector<std::string>&& interesting_names) { |
| void* data_ptr; |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->Allocate(sizeof(TestData), |
| reinterpret_cast<uint8_t**>(&data_ptr)))) { |
| return nullptr; |
| } |
| data = new (data_ptr) TestData(jvmti_env, |
| env, |
| loc, |
| meth, |
| target_klass, |
| field, |
| setup_meth, |
| pop_offset, |
| std::move(interesting_names)); |
| if (env->ExceptionCheck()) { |
| env->DeleteGlobalRef(data->target_klass); |
| jvmti_env->Deallocate(reinterpret_cast<uint8_t*>(data)); |
| return nullptr; |
| } |
| return data; |
| } |
| |
| static TestData* SetupTestData(JNIEnv* env, |
| jobject meth, |
| jlocation loc, |
| jclass target_klass, |
| jobject field, |
| jobject setup_meth, |
| jint pop_offset) { |
| std::vector<std::string> empty; |
| return SetupTestData( |
| env, meth, loc, target_klass, field, setup_meth, pop_offset, std::move(empty)); |
| } |
| |
| extern "C" JNIEXPORT |
| void JNICALL Java_art_Test1953_setupSuspendClassEvent(JNIEnv* env, |
| jclass klass ATTRIBUTE_UNUSED, |
| jint event_num, |
| jobjectArray interesting_names, |
| jthread thr) { |
| CHECK(event_num == JVMTI_EVENT_CLASS_LOAD || event_num == JVMTI_EVENT_CLASS_PREPARE); |
| std::vector<std::string> names; |
| jint cnt = env->GetArrayLength(interesting_names); |
| for (jint i = 0; i < cnt; i++) { |
| env->PushLocalFrame(1); |
| jstring name_obj = reinterpret_cast<jstring>(env->GetObjectArrayElement(interesting_names, i)); |
| const char* name_chr = env->GetStringUTFChars(name_obj, nullptr); |
| names.push_back(std::string(name_chr)); |
| env->ReleaseStringUTFChars(name_obj, name_chr); |
| env->PopLocalFrame(nullptr); |
| } |
| TestData* data; |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->GetThreadLocalStorage(thr, |
| reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data == nullptr) << "Data was not cleared!"; |
| data = SetupTestData(env, nullptr, 0, nullptr, nullptr, nullptr, 0, std::move(names)); |
| if (data == nullptr) { |
| return; |
| } |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetThreadLocalStorage(thr, data))) { |
| return; |
| } |
| JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetEventNotificationMode(JVMTI_ENABLE, |
| static_cast<jvmtiEvent>(event_num), |
| thr)); |
| } |
| |
| extern "C" JNIEXPORT |
| void JNICALL Java_art_Test1953_clearSuspendClassEvent(JNIEnv* env, |
| jclass klass ATTRIBUTE_UNUSED, |
| jthread thr) { |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->GetThreadLocalStorage(thr, |
| reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data != nullptr); |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetEventNotificationMode(JVMTI_DISABLE, |
| JVMTI_EVENT_CLASS_LOAD, |
| thr))) { |
| return; |
| } |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetEventNotificationMode(JVMTI_DISABLE, |
| JVMTI_EVENT_CLASS_PREPARE, |
| thr))) { |
| return; |
| } |
| DeleteTestData(env, thr, data); |
| } |
| |
| extern "C" JNIEXPORT |
| void JNICALL Java_art_Test1953_setupSuspendSingleStepAt(JNIEnv* env, |
| jclass klass ATTRIBUTE_UNUSED, |
| jobject meth, |
| jlocation loc, |
| jthread thr) { |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->GetThreadLocalStorage(thr, |
| reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data == nullptr) << "Data was not cleared!"; |
| data = SetupTestData(env, meth, loc, nullptr, nullptr, nullptr, 0); |
| if (data == nullptr) { |
| return; |
| } |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetThreadLocalStorage(thr, data))) { |
| return; |
| } |
| JvmtiErrorToException(env, jvmti_env, jvmti_env->SetEventNotificationMode(JVMTI_ENABLE, |
| JVMTI_EVENT_SINGLE_STEP, |
| thr)); |
| } |
| |
| extern "C" JNIEXPORT |
| void JNICALL Java_art_Test1953_clearSuspendSingleStepFor(JNIEnv* env, |
| jclass klass ATTRIBUTE_UNUSED, |
| jthread thr) { |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->GetThreadLocalStorage(thr, |
| reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data != nullptr); |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetEventNotificationMode(JVMTI_DISABLE, |
| JVMTI_EVENT_SINGLE_STEP, |
| thr))) { |
| return; |
| } |
| DeleteTestData(env, thr, data); |
| } |
| |
| extern "C" JNIEXPORT |
| void JNICALL Java_art_Test1953_setupSuspendPopFrameEvent(JNIEnv* env, |
| jclass klass ATTRIBUTE_UNUSED, |
| jint offset, |
| jobject breakpoint_func, |
| jthread thr) { |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->GetThreadLocalStorage(thr, |
| reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data == nullptr) << "Data was not cleared!"; |
| data = SetupTestData(env, nullptr, 0, nullptr, nullptr, breakpoint_func, offset); |
| CHECK(data != nullptr); |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetThreadLocalStorage(thr, data))) { |
| return; |
| } |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetEventNotificationMode(JVMTI_ENABLE, |
| JVMTI_EVENT_FRAME_POP, |
| thr))) { |
| return; |
| } |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetEventNotificationMode(JVMTI_ENABLE, |
| JVMTI_EVENT_BREAKPOINT, |
| thr))) { |
| return; |
| } |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetBreakpoint(data->frame_pop_setup_method, 0))) { |
| return; |
| } |
| } |
| |
| extern "C" JNIEXPORT |
| void JNICALL Java_art_Test1953_clearSuspendPopFrameEvent(JNIEnv* env, |
| jclass klass ATTRIBUTE_UNUSED, |
| jthread thr) { |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->GetThreadLocalStorage(thr, |
| reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data != nullptr); |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetEventNotificationMode(JVMTI_DISABLE, |
| JVMTI_EVENT_FRAME_POP, |
| thr))) { |
| return; |
| } |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetEventNotificationMode(JVMTI_DISABLE, |
| JVMTI_EVENT_BREAKPOINT, |
| thr))) { |
| return; |
| } |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->ClearBreakpoint(data->frame_pop_setup_method, 0))) { |
| return; |
| } |
| DeleteTestData(env, thr, data); |
| } |
| |
| extern "C" JNIEXPORT |
| void JNICALL Java_art_Test1953_setupSuspendBreakpointFor(JNIEnv* env, |
| jclass klass ATTRIBUTE_UNUSED, |
| jobject meth, |
| jlocation loc, |
| jthread thr) { |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->GetThreadLocalStorage(thr, |
| reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data == nullptr) << "Data was not cleared!"; |
| data = SetupTestData(env, meth, loc, nullptr, nullptr, nullptr, 0); |
| if (data == nullptr) { |
| return; |
| } |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetThreadLocalStorage(thr, data))) { |
| return; |
| } |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetEventNotificationMode(JVMTI_ENABLE, |
| JVMTI_EVENT_BREAKPOINT, |
| thr))) { |
| return; |
| } |
| JvmtiErrorToException(env, jvmti_env, jvmti_env->SetBreakpoint(data->target_method, |
| data->target_loc)); |
| } |
| |
| extern "C" JNIEXPORT |
| void JNICALL Java_art_Test1953_clearSuspendBreakpointFor(JNIEnv* env, |
| jclass klass ATTRIBUTE_UNUSED, |
| jthread thr) { |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->GetThreadLocalStorage(thr, |
| reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data != nullptr); |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetEventNotificationMode(JVMTI_DISABLE, |
| JVMTI_EVENT_BREAKPOINT, |
| thr))) { |
| return; |
| } |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->ClearBreakpoint(data->target_method, |
| data->target_loc))) { |
| return; |
| } |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetThreadLocalStorage(thr, nullptr))) { |
| return; |
| } |
| DeleteTestData(env, thr, data); |
| } |
| |
| extern "C" JNIEXPORT |
| void JNICALL Java_art_Test1953_setupSuspendExceptionEvent(JNIEnv* env, |
| jclass klass ATTRIBUTE_UNUSED, |
| jobject method, |
| jboolean is_catch, |
| jthread thr) { |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->GetThreadLocalStorage( |
| thr, reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data == nullptr) << "Data was not cleared!"; |
| data = SetupTestData(env, method, 0, nullptr, nullptr, nullptr, 0); |
| if (data == nullptr) { |
| return; |
| } |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetThreadLocalStorage(thr, data))) { |
| return; |
| } |
| JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetEventNotificationMode( |
| JVMTI_ENABLE, |
| is_catch ? JVMTI_EVENT_EXCEPTION_CATCH : JVMTI_EVENT_EXCEPTION, |
| thr)); |
| } |
| |
| extern "C" JNIEXPORT |
| void JNICALL Java_art_Test1953_clearSuspendExceptionEvent(JNIEnv* env, |
| jclass klass ATTRIBUTE_UNUSED, |
| jthread thr) { |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->GetThreadLocalStorage(thr, |
| reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data != nullptr); |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetEventNotificationMode(JVMTI_DISABLE, |
| JVMTI_EVENT_EXCEPTION_CATCH, |
| thr))) { |
| return; |
| } |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetEventNotificationMode(JVMTI_DISABLE, |
| JVMTI_EVENT_EXCEPTION, |
| thr))) { |
| return; |
| } |
| DeleteTestData(env, thr, data); |
| } |
| |
| extern "C" JNIEXPORT |
| void JNICALL Java_art_Test1953_setupSuspendMethodEvent(JNIEnv* env, |
| jclass klass ATTRIBUTE_UNUSED, |
| jobject method, |
| jboolean enter, |
| jthread thr) { |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->GetThreadLocalStorage( |
| thr, reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data == nullptr) << "Data was not cleared!"; |
| data = SetupTestData(env, method, 0, nullptr, nullptr, nullptr, 0); |
| if (data == nullptr) { |
| return; |
| } |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetThreadLocalStorage(thr, data))) { |
| return; |
| } |
| JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetEventNotificationMode( |
| JVMTI_ENABLE, |
| enter ? JVMTI_EVENT_METHOD_ENTRY : JVMTI_EVENT_METHOD_EXIT, |
| thr)); |
| } |
| |
| extern "C" JNIEXPORT |
| void JNICALL Java_art_Test1953_clearSuspendMethodEvent(JNIEnv* env, |
| jclass klass ATTRIBUTE_UNUSED, |
| jthread thr) { |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->GetThreadLocalStorage(thr, |
| reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data != nullptr); |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetEventNotificationMode(JVMTI_DISABLE, |
| JVMTI_EVENT_METHOD_EXIT, |
| thr))) { |
| return; |
| } |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetEventNotificationMode(JVMTI_DISABLE, |
| JVMTI_EVENT_METHOD_ENTRY, |
| thr))) { |
| return; |
| } |
| DeleteTestData(env, thr, data); |
| } |
| |
| extern "C" JNIEXPORT |
| void JNICALL Java_art_Test1953_setupFieldSuspendFor(JNIEnv* env, |
| jclass klass ATTRIBUTE_UNUSED, |
| jclass target_klass, |
| jobject field, |
| jboolean access, |
| jthread thr) { |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->GetThreadLocalStorage( |
| thr, reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data == nullptr) << "Data was not cleared!"; |
| data = SetupTestData(env, nullptr, 0, target_klass, field, nullptr, 0); |
| if (data == nullptr) { |
| return; |
| } |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetThreadLocalStorage(thr, data))) { |
| return; |
| } |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetEventNotificationMode( |
| JVMTI_ENABLE, |
| access ? JVMTI_EVENT_FIELD_ACCESS : JVMTI_EVENT_FIELD_MODIFICATION, |
| thr))) { |
| return; |
| } |
| if (access) { |
| JvmtiErrorToException(env, jvmti_env, jvmti_env->SetFieldAccessWatch(data->target_klass, |
| data->target_field)); |
| } else { |
| JvmtiErrorToException(env, jvmti_env, jvmti_env->SetFieldModificationWatch(data->target_klass, |
| data->target_field)); |
| } |
| } |
| |
| extern "C" JNIEXPORT |
| void JNICALL Java_art_Test1953_clearFieldSuspendFor(JNIEnv* env, |
| jclass klass ATTRIBUTE_UNUSED, |
| jthread thr) { |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->GetThreadLocalStorage(thr, |
| reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data != nullptr); |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetEventNotificationMode(JVMTI_DISABLE, |
| JVMTI_EVENT_FIELD_ACCESS, |
| thr))) { |
| return; |
| } |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetEventNotificationMode(JVMTI_DISABLE, |
| JVMTI_EVENT_FIELD_MODIFICATION, |
| thr))) { |
| return; |
| } |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->ClearFieldModificationWatch( |
| data->target_klass, data->target_field)) && |
| JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->ClearFieldAccessWatch( |
| data->target_klass, data->target_field))) { |
| return; |
| } else { |
| env->ExceptionClear(); |
| } |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetThreadLocalStorage(thr, nullptr))) { |
| return; |
| } |
| DeleteTestData(env, thr, data); |
| } |
| |
| extern "C" JNIEXPORT |
| void JNICALL Java_art_Test1953_setupWaitForNativeCall(JNIEnv* env, |
| jclass klass ATTRIBUTE_UNUSED, |
| jthread thr) { |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->GetThreadLocalStorage( |
| thr, reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data == nullptr) << "Data was not cleared!"; |
| data = SetupTestData(env, nullptr, 0, nullptr, nullptr, nullptr, 0); |
| if (data == nullptr) { |
| return; |
| } |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetThreadLocalStorage(thr, data))) { |
| return; |
| } |
| } |
| |
| extern "C" JNIEXPORT |
| void JNICALL Java_art_Test1953_clearWaitForNativeCall(JNIEnv* env, |
| jclass klass ATTRIBUTE_UNUSED, |
| jthread thr) { |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->GetThreadLocalStorage(thr, |
| reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data != nullptr); |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->SetThreadLocalStorage(thr, nullptr))) { |
| return; |
| } |
| DeleteTestData(env, thr, data); |
| } |
| |
| extern "C" JNIEXPORT |
| void JNICALL Java_art_Test1953_waitForSuspendHit(JNIEnv* env, |
| jclass klass ATTRIBUTE_UNUSED, |
| jthread thr) { |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->GetThreadLocalStorage(thr, |
| reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data != nullptr); |
| if (JvmtiErrorToException(env, jvmti_env, jvmti_env->RawMonitorEnter(data->notify_monitor))) { |
| return; |
| } |
| while (!data->hit_location) { |
| if (JvmtiErrorToException(env, jvmti_env, jvmti_env->RawMonitorWait(data->notify_monitor, -1))) { |
| return; |
| } |
| } |
| if (JvmtiErrorToException(env, jvmti_env, jvmti_env->RawMonitorExit(data->notify_monitor))) { |
| return; |
| } |
| jint state = 0; |
| while (!JvmtiErrorToException(env, jvmti_env, jvmti_env->GetThreadState(thr, &state)) && |
| (state & JVMTI_THREAD_STATE_SUSPENDED) == 0) { } |
| } |
| |
| extern "C" JNIEXPORT |
| void JNICALL Java_art_Test1953_popFrame(JNIEnv* env, |
| jclass klass ATTRIBUTE_UNUSED, |
| jthread thr) { |
| JvmtiErrorToException(env, jvmti_env, jvmti_env->PopFrame(thr)); |
| } |
| |
| extern "C" JNIEXPORT |
| void JNICALL Java_art_Test1953_00024NativeCalledObject_calledFunction( |
| JNIEnv* env, jobject thiz) { |
| env->PushLocalFrame(1); |
| jclass klass = env->GetObjectClass(thiz); |
| jfieldID cnt = env->GetFieldID(klass, "cnt", "I"); |
| env->SetIntField(thiz, cnt, env->GetIntField(thiz, cnt) + 1); |
| env->PopLocalFrame(nullptr); |
| TestData *data; |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->GetThreadLocalStorage(/* thread */ nullptr, |
| reinterpret_cast<void**>(&data)))) { |
| return; |
| } |
| CHECK(data != nullptr); |
| data->PerformSuspend(jvmti_env, env); |
| } |
| |
| extern "C" JNIEXPORT |
| void JNICALL Java_art_Test1953_00024NativeCallerObject_run( |
| JNIEnv* env, jobject thiz) { |
| env->PushLocalFrame(1); |
| jclass klass = env->GetObjectClass(thiz); |
| jfieldID baseCnt = env->GetFieldID(klass, "baseCnt", "I"); |
| env->SetIntField(thiz, baseCnt, env->GetIntField(thiz, baseCnt) + 1); |
| jmethodID called = env->GetMethodID(klass, "calledFunction", "()V"); |
| env->CallVoidMethod(thiz, called); |
| env->PopLocalFrame(nullptr); |
| } |
| |
| extern "C" JNIEXPORT |
| jboolean JNICALL Java_art_Test1953_isClassLoaded(JNIEnv* env, jclass, jstring name) { |
| ScopedUtfChars chr(env, name); |
| if (env->ExceptionCheck()) { |
| return false; |
| } |
| jint cnt = 0; |
| jclass* klasses = nullptr; |
| if (JvmtiErrorToException(env, jvmti_env, jvmti_env->GetLoadedClasses(&cnt, &klasses))) { |
| return false; |
| } |
| bool res = false; |
| for (jint i = 0; !res && i < cnt; i++) { |
| char* sig; |
| if (JvmtiErrorToException(env, |
| jvmti_env, |
| jvmti_env->GetClassSignature(klasses[i], &sig, nullptr))) { |
| return false; |
| } |
| res = (strcmp(sig, chr.c_str()) == 0); |
| jvmti_env->Deallocate(reinterpret_cast<unsigned char*>(sig)); |
| } |
| jvmti_env->Deallocate(reinterpret_cast<unsigned char*>(klasses)); |
| return res; |
| } |
| |
| } // namespace Test1953PopFrame |
| } // namespace art |
| |
