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