1/* 2 * Copyright (C) 2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#include <stdint.h> 18 19#include "art_method-inl.h" 20#include "callee_save_frame.h" 21#include "common_runtime_test.h" 22#include "quick/quick_method_frame_info.h" 23 24namespace art { 25 26class QuickTrampolineEntrypointsTest : public CommonRuntimeTest { 27 protected: 28 void SetUpRuntimeOptions(RuntimeOptions *options) OVERRIDE { 29 // Use 64-bit ISA for runtime setup to make method size potentially larger 30 // than necessary (rather than smaller) during CreateCalleeSaveMethod 31 options->push_back(std::make_pair("imageinstructionset", "x86_64")); 32 } 33 34 // Do not do any of the finalization. We don't want to run any code, we don't need the heap 35 // prepared, it actually will be a problem with setting the instruction set to x86_64 in 36 // SetUpRuntimeOptions. 37 void FinalizeSetup() OVERRIDE { 38 ASSERT_EQ(InstructionSet::kX86_64, Runtime::Current()->GetInstructionSet()); 39 } 40 41 static ArtMethod* CreateCalleeSaveMethod(InstructionSet isa, Runtime::CalleeSaveType type) 42 NO_THREAD_SAFETY_ANALYSIS { 43 Runtime* r = Runtime::Current(); 44 45 Thread* t = Thread::Current(); 46 47 ScopedObjectAccess soa(t); 48 49 r->SetInstructionSet(isa); 50 ArtMethod* save_method = r->CreateCalleeSaveMethod(); 51 r->SetCalleeSaveMethod(save_method, type); 52 53 return save_method; 54 } 55 56 static void CheckFrameSize(InstructionSet isa, Runtime::CalleeSaveType type, uint32_t save_size) 57 NO_THREAD_SAFETY_ANALYSIS { 58 ArtMethod* save_method = CreateCalleeSaveMethod(isa, type); 59 QuickMethodFrameInfo frame_info = Runtime::Current()->GetRuntimeMethodFrameInfo(save_method); 60 EXPECT_EQ(frame_info.FrameSizeInBytes(), save_size) << "Expected and real size differs for " 61 << type << " core spills=" << std::hex << frame_info.CoreSpillMask() << " fp spills=" 62 << frame_info.FpSpillMask() << std::dec << " ISA " << isa; 63 } 64 65 static void CheckPCOffset(InstructionSet isa, Runtime::CalleeSaveType type, size_t pc_offset) 66 NO_THREAD_SAFETY_ANALYSIS { 67 ArtMethod* save_method = CreateCalleeSaveMethod(isa, type); 68 QuickMethodFrameInfo frame_info = Runtime::Current()->GetRuntimeMethodFrameInfo(save_method); 69 EXPECT_EQ(frame_info.GetReturnPcOffset(), pc_offset) 70 << "Expected and real pc offset differs for " << type 71 << " core spills=" << std::hex << frame_info.CoreSpillMask() 72 << " fp spills=" << frame_info.FpSpillMask() << std::dec << " ISA " << isa; 73 } 74}; 75 76// Note: these tests are all runtime tests. They let the Runtime create the corresponding ArtMethod 77// and check against it. Technically we know and expect certain values, but the Runtime code is 78// not constexpr, so we cannot make this compile-time checks (and I want the Runtime code tested). 79 80// This test ensures that kQuickCalleeSaveFrame_RefAndArgs_FrameSize is correct. 81TEST_F(QuickTrampolineEntrypointsTest, FrameSize) { 82 // We have to use a define here as the callee_save_frame.h functions are constexpr. 83#define CHECK_FRAME_SIZE(isa) \ 84 CheckFrameSize(isa, Runtime::kRefsAndArgs, GetCalleeSaveFrameSize(isa, Runtime::kRefsAndArgs)); \ 85 CheckFrameSize(isa, Runtime::kRefsOnly, GetCalleeSaveFrameSize(isa, Runtime::kRefsOnly)); \ 86 CheckFrameSize(isa, Runtime::kSaveAll, GetCalleeSaveFrameSize(isa, Runtime::kSaveAll)) 87 88 CHECK_FRAME_SIZE(kArm); 89 CHECK_FRAME_SIZE(kArm64); 90 CHECK_FRAME_SIZE(kMips); 91 CHECK_FRAME_SIZE(kX86); 92 CHECK_FRAME_SIZE(kX86_64); 93} 94 95// This test ensures that GetConstExprPointerSize is correct with respect to 96// GetInstructionSetPointerSize. 97TEST_F(QuickTrampolineEntrypointsTest, PointerSize) { 98 EXPECT_EQ(GetInstructionSetPointerSize(kArm), GetConstExprPointerSize(kArm)); 99 EXPECT_EQ(GetInstructionSetPointerSize(kArm64), GetConstExprPointerSize(kArm64)); 100 EXPECT_EQ(GetInstructionSetPointerSize(kMips), GetConstExprPointerSize(kMips)); 101 EXPECT_EQ(GetInstructionSetPointerSize(kX86), GetConstExprPointerSize(kX86)); 102 EXPECT_EQ(GetInstructionSetPointerSize(kX86_64), GetConstExprPointerSize(kX86_64)); 103} 104 105// This test ensures that the constexpr specialization of the return PC offset computation in 106// GetCalleeSavePCOffset is correct. 107TEST_F(QuickTrampolineEntrypointsTest, ReturnPC) { 108 // Ensure that the computation in callee_save_frame.h correct. 109 // Note: we can only check against the kRuntimeISA, because the ArtMethod computation uses 110 // sizeof(void*), which is wrong when the target bitwidth is not the same as the host's. 111 CheckPCOffset(kRuntimeISA, Runtime::kRefsAndArgs, 112 GetCalleeSaveReturnPcOffset(kRuntimeISA, Runtime::kRefsAndArgs)); 113 CheckPCOffset(kRuntimeISA, Runtime::kRefsOnly, 114 GetCalleeSaveReturnPcOffset(kRuntimeISA, Runtime::kRefsOnly)); 115 CheckPCOffset(kRuntimeISA, Runtime::kSaveAll, 116 GetCalleeSaveReturnPcOffset(kRuntimeISA, Runtime::kSaveAll)); 117} 118 119} // namespace art 120