From 7940e44f4517de5e2634a7e07d58d0fb26160513 Mon Sep 17 00:00:00 2001 From: Brian Carlstrom Date: Fri, 12 Jul 2013 13:46:57 -0700 Subject: Create separate Android.mk for main build targets The runtime, compiler, dex2oat, and oatdump now are in seperate trees to prevent dependency creep. They can now be individually built without rebuilding the rest of the art projects. dalvikvm and jdwpspy were already this way. Builds in the art directory should behave as before, building everything including tests. Change-Id: Ic6b1151e5ed0f823c3dd301afd2b13eb2d8feb81 --- runtime/exception_test.cc | 227 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 227 insertions(+) create mode 100644 runtime/exception_test.cc (limited to 'runtime/exception_test.cc') diff --git a/runtime/exception_test.cc b/runtime/exception_test.cc new file mode 100644 index 000000000..54341e3a4 --- /dev/null +++ b/runtime/exception_test.cc @@ -0,0 +1,227 @@ +/* + * Copyright (C) 2011 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 "class_linker.h" +#include "common_test.h" +#include "dex_file.h" +#include "gtest/gtest.h" +#include "mirror/class-inl.h" +#include "mirror/object_array-inl.h" +#include "mirror/object-inl.h" +#include "mirror/stack_trace_element.h" +#include "runtime.h" +#include "scoped_thread_state_change.h" +#include "sirt_ref.h" +#include "thread.h" +#include "UniquePtr.h" + +namespace art { + +class ExceptionTest : public CommonTest { + protected: + virtual void SetUp() { + CommonTest::SetUp(); + + ScopedObjectAccess soa(Thread::Current()); + SirtRef class_loader(soa.Self(), + soa.Decode(LoadDex("ExceptionHandle"))); + my_klass_ = class_linker_->FindClass("LExceptionHandle;", class_loader.get()); + ASSERT_TRUE(my_klass_ != NULL); + class_linker_->EnsureInitialized(my_klass_, false, true); + + dex_ = my_klass_->GetDexCache()->GetDexFile(); + + uint32_t code_size = 12; + fake_code_.push_back((code_size >> 24) & 0xFF); + fake_code_.push_back((code_size >> 16) & 0xFF); + fake_code_.push_back((code_size >> 8) & 0xFF); + fake_code_.push_back((code_size >> 0) & 0xFF); + for (size_t i = 0 ; i < code_size; i++) { + fake_code_.push_back(0x70 | i); + } + + fake_mapping_data_.push_back(4); // first element is count + fake_mapping_data_.push_back(4); // total (non-length) elements + fake_mapping_data_.push_back(2); // count of pc to dex elements + // --- pc to dex table + fake_mapping_data_.push_back(3); // offset 3 + fake_mapping_data_.push_back(3); // maps to dex offset 3 + // --- dex to pc table + fake_mapping_data_.push_back(3); // offset 3 + fake_mapping_data_.push_back(3); // maps to dex offset 3 + + fake_vmap_table_data_.push_back(0); + + fake_gc_map_.push_back(0); // 0 bytes to encode references and native pc offsets. + fake_gc_map_.push_back(0); + fake_gc_map_.push_back(0); // 0 entries. + fake_gc_map_.push_back(0); + + method_f_ = my_klass_->FindVirtualMethod("f", "()I"); + ASSERT_TRUE(method_f_ != NULL); + method_f_->SetFrameSizeInBytes(kStackAlignment); + method_f_->SetEntryPointFromCompiledCode(CompiledMethod::CodePointer(&fake_code_[sizeof(code_size)], kThumb2)); + method_f_->SetMappingTable(&fake_mapping_data_[0]); + method_f_->SetVmapTable(&fake_vmap_table_data_[0]); + method_f_->SetNativeGcMap(&fake_gc_map_[0]); + + method_g_ = my_klass_->FindVirtualMethod("g", "(I)V"); + ASSERT_TRUE(method_g_ != NULL); + method_g_->SetFrameSizeInBytes(kStackAlignment); + method_g_->SetEntryPointFromCompiledCode(CompiledMethod::CodePointer(&fake_code_[sizeof(code_size)], kThumb2)); + method_g_->SetMappingTable(&fake_mapping_data_[0]); + method_g_->SetVmapTable(&fake_vmap_table_data_[0]); + method_g_->SetNativeGcMap(&fake_gc_map_[0]); + } + + const DexFile* dex_; + + std::vector fake_code_; + std::vector fake_mapping_data_; + std::vector fake_vmap_table_data_; + std::vector fake_gc_map_; + + mirror::AbstractMethod* method_f_; + mirror::AbstractMethod* method_g_; + + private: + mirror::Class* my_klass_; +}; + +TEST_F(ExceptionTest, FindCatchHandler) { + const DexFile::CodeItem* code_item = dex_->GetCodeItem(method_f_->GetCodeItemOffset()); + + ASSERT_TRUE(code_item != NULL); + + ASSERT_EQ(2u, code_item->tries_size_); + ASSERT_NE(0u, code_item->insns_size_in_code_units_); + + const DexFile::TryItem *t0, *t1; + t0 = dex_->GetTryItems(*code_item, 0); + t1 = dex_->GetTryItems(*code_item, 1); + EXPECT_LE(t0->start_addr_, t1->start_addr_); + { + CatchHandlerIterator iter(*code_item, 4 /* Dex PC in the first try block */); + EXPECT_STREQ("Ljava/io/IOException;", dex_->StringByTypeIdx(iter.GetHandlerTypeIndex())); + ASSERT_TRUE(iter.HasNext()); + iter.Next(); + EXPECT_STREQ("Ljava/lang/Exception;", dex_->StringByTypeIdx(iter.GetHandlerTypeIndex())); + ASSERT_TRUE(iter.HasNext()); + iter.Next(); + EXPECT_FALSE(iter.HasNext()); + } + { + CatchHandlerIterator iter(*code_item, 8 /* Dex PC in the second try block */); + EXPECT_STREQ("Ljava/io/IOException;", dex_->StringByTypeIdx(iter.GetHandlerTypeIndex())); + ASSERT_TRUE(iter.HasNext()); + iter.Next(); + EXPECT_FALSE(iter.HasNext()); + } + { + CatchHandlerIterator iter(*code_item, 11 /* Dex PC not in any try block */); + EXPECT_FALSE(iter.HasNext()); + } +} + +TEST_F(ExceptionTest, StackTraceElement) { + Thread* thread = Thread::Current(); + thread->TransitionFromSuspendedToRunnable(); + bool started = runtime_->Start(); + CHECK(started); + JNIEnv* env = thread->GetJniEnv(); + ScopedObjectAccess soa(env); + + std::vector fake_stack; + ASSERT_EQ(kStackAlignment, 16); + ASSERT_EQ(sizeof(uintptr_t), sizeof(uint32_t)); + +#if !defined(ART_USE_PORTABLE_COMPILER) + // Create two fake stack frames with mapping data created in SetUp. We map offset 3 in the code + // to dex pc 3. + const uint32_t dex_pc = 3; + + // Create/push fake 16byte stack frame for method g + fake_stack.push_back(reinterpret_cast(method_g_)); + fake_stack.push_back(0); + fake_stack.push_back(0); + fake_stack.push_back(method_f_->ToNativePc(dex_pc)); // return pc + + // Create/push fake 16byte stack frame for method f + fake_stack.push_back(reinterpret_cast(method_f_)); + fake_stack.push_back(0); + fake_stack.push_back(0); + fake_stack.push_back(0xEBAD6070); // return pc + + // Pull Method* of NULL to terminate the trace + fake_stack.push_back(0); + + // Push null values which will become null incoming arguments. + fake_stack.push_back(0); + fake_stack.push_back(0); + fake_stack.push_back(0); + + // Set up thread to appear as if we called out of method_g_ at pc dex 3 + thread->SetTopOfStack(&fake_stack[0], method_g_->ToNativePc(dex_pc)); // return pc +#else + // Create/push fake 20-byte shadow frame for method g + fake_stack.push_back(0); + fake_stack.push_back(0); + fake_stack.push_back(reinterpret_cast(method_g_)); + fake_stack.push_back(3); + fake_stack.push_back(0); + + // Create/push fake 20-byte shadow frame for method f + fake_stack.push_back(0); + fake_stack.push_back(0); + fake_stack.push_back(reinterpret_cast(method_f_)); + fake_stack.push_back(3); + fake_stack.push_back(0); + + thread->PushShadowFrame(reinterpret_cast(&fake_stack[5])); + thread->PushShadowFrame(reinterpret_cast(&fake_stack[0])); +#endif + + jobject internal = thread->CreateInternalStackTrace(soa); + ASSERT_TRUE(internal != NULL); + jobjectArray ste_array = Thread::InternalStackTraceToStackTraceElementArray(env, internal); + ASSERT_TRUE(ste_array != NULL); + mirror::ObjectArray* trace_array = + soa.Decode*>(ste_array); + + ASSERT_TRUE(trace_array != NULL); + ASSERT_TRUE(trace_array->Get(0) != NULL); + EXPECT_STREQ("ExceptionHandle", + trace_array->Get(0)->GetDeclaringClass()->ToModifiedUtf8().c_str()); + EXPECT_STREQ("ExceptionHandle.java", trace_array->Get(0)->GetFileName()->ToModifiedUtf8().c_str()); + EXPECT_STREQ("g", trace_array->Get(0)->GetMethodName()->ToModifiedUtf8().c_str()); + EXPECT_EQ(37, trace_array->Get(0)->GetLineNumber()); + + ASSERT_TRUE(trace_array->Get(1) != NULL); + EXPECT_STREQ("ExceptionHandle", + trace_array->Get(1)->GetDeclaringClass()->ToModifiedUtf8().c_str()); + EXPECT_STREQ("ExceptionHandle.java", trace_array->Get(1)->GetFileName()->ToModifiedUtf8().c_str()); + EXPECT_STREQ("f", trace_array->Get(1)->GetMethodName()->ToModifiedUtf8().c_str()); + EXPECT_EQ(22, trace_array->Get(1)->GetLineNumber()); + +#if !defined(ART_USE_PORTABLE_COMPILER) + thread->SetTopOfStack(NULL, 0); // Disarm the assertion that no code is running when we detach. +#else + thread->PopShadowFrame(); + thread->PopShadowFrame(); +#endif +} + +} // namespace art -- cgit v1.2.3