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 24 namespace art { 25 26 class 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. 81 TEST_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, \ 85 Runtime::kSaveRefsAndArgs, \ 86 GetCalleeSaveFrameSize(isa, Runtime::kSaveRefsAndArgs)); \ 87 CheckFrameSize(isa, \ 88 Runtime::kSaveRefsOnly, \ 89 GetCalleeSaveFrameSize(isa, Runtime::kSaveRefsOnly)); \ 90 CheckFrameSize(isa, \ 91 Runtime::kSaveAllCalleeSaves, \ 92 GetCalleeSaveFrameSize(isa, Runtime::kSaveAllCalleeSaves)) 93 94 CHECK_FRAME_SIZE(kArm); 95 CHECK_FRAME_SIZE(kArm64); 96 CHECK_FRAME_SIZE(kMips); 97 CHECK_FRAME_SIZE(kMips64); 98 CHECK_FRAME_SIZE(kX86); 99 CHECK_FRAME_SIZE(kX86_64); 100 } 101 102 // This test ensures that GetConstExprPointerSize is correct with respect to 103 // GetInstructionSetPointerSize. 104 TEST_F(QuickTrampolineEntrypointsTest, PointerSize) { 105 EXPECT_EQ(GetInstructionSetPointerSize(kArm), GetConstExprPointerSize(kArm)); 106 EXPECT_EQ(GetInstructionSetPointerSize(kArm64), GetConstExprPointerSize(kArm64)); 107 EXPECT_EQ(GetInstructionSetPointerSize(kMips), GetConstExprPointerSize(kMips)); 108 EXPECT_EQ(GetInstructionSetPointerSize(kMips64), GetConstExprPointerSize(kMips64)); 109 EXPECT_EQ(GetInstructionSetPointerSize(kX86), GetConstExprPointerSize(kX86)); 110 EXPECT_EQ(GetInstructionSetPointerSize(kX86_64), GetConstExprPointerSize(kX86_64)); 111 } 112 113 // This test ensures that the constexpr specialization of the return PC offset computation in 114 // GetCalleeSavePCOffset is correct. 115 TEST_F(QuickTrampolineEntrypointsTest, ReturnPC) { 116 // Ensure that the computation in callee_save_frame.h correct. 117 // Note: we can only check against the kRuntimeISA, because the ArtMethod computation uses 118 // sizeof(void*), which is wrong when the target bitwidth is not the same as the host's. 119 CheckPCOffset(kRuntimeISA, Runtime::kSaveRefsAndArgs, 120 GetCalleeSaveReturnPcOffset(kRuntimeISA, Runtime::kSaveRefsAndArgs)); 121 CheckPCOffset(kRuntimeISA, Runtime::kSaveRefsOnly, 122 GetCalleeSaveReturnPcOffset(kRuntimeISA, Runtime::kSaveRefsOnly)); 123 CheckPCOffset(kRuntimeISA, Runtime::kSaveAllCalleeSaves, 124 GetCalleeSaveReturnPcOffset(kRuntimeISA, Runtime::kSaveAllCalleeSaves)); 125 } 126 127 } // namespace art 128
