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:
SetUpRuntimeOptions(RuntimeOptions * options)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.
FinalizeSetup()37 void FinalizeSetup() OVERRIDE {
38 ASSERT_EQ(InstructionSet::kX86_64, Runtime::Current()->GetInstructionSet());
39 }
40
CreateCalleeSaveMethod(InstructionSet isa,Runtime::CalleeSaveType type)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
CheckFrameSize(InstructionSet isa,Runtime::CalleeSaveType type,uint32_t save_size)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
CheckPCOffset(InstructionSet isa,Runtime::CalleeSaveType type,size_t pc_offset)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.
TEST_F(QuickTrampolineEntrypointsTest,FrameSize)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, 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.
TEST_F(QuickTrampolineEntrypointsTest,PointerSize)97 TEST_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.
TEST_F(QuickTrampolineEntrypointsTest,ReturnPC)107 TEST_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