Home | History | Annotate | Download | only in quick 
      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 "callee_save_frame.h"
     20 #include "common_runtime_test.h"
     21 #include "mirror/art_method-inl.h"
     22 #include "quick/quick_method_frame_info.h"
     23 
     24 namespace art {
     25 
     26 class QuickTrampolineEntrypointsTest : public CommonRuntimeTest {
     27  protected:
     28   static mirror::ArtMethod* CreateCalleeSaveMethod(InstructionSet isa,
     29                                                    Runtime::CalleeSaveType type)
     30       NO_THREAD_SAFETY_ANALYSIS {
     31     Runtime* r = Runtime::Current();
     32 
     33     Thread* t = Thread::Current();
     34     t->TransitionFromSuspendedToRunnable();  // So we can create callee-save methods.
     35 
     36     r->SetInstructionSet(isa);
     37     mirror::ArtMethod* save_method = r->CreateCalleeSaveMethod(type);
     38     r->SetCalleeSaveMethod(save_method, type);
     39 
     40     t->TransitionFromRunnableToSuspended(ThreadState::kNative);  // So we can shut down.
     41 
     42     return save_method;
     43   }
     44 
     45   static void CheckFrameSize(InstructionSet isa, Runtime::CalleeSaveType type, uint32_t save_size)
     46       NO_THREAD_SAFETY_ANALYSIS {
     47     mirror::ArtMethod* save_method = CreateCalleeSaveMethod(isa, type);
     48     QuickMethodFrameInfo frame_info = save_method->GetQuickFrameInfo();
     49     EXPECT_EQ(frame_info.FrameSizeInBytes(), save_size) << "Expected and real size differs for "
     50         << type << " core spills=" << std::hex << frame_info.CoreSpillMask() << " fp spills="
     51         << frame_info.FpSpillMask() << std::dec << " ISA " << isa;
     52   }
     53 
     54   static void CheckPCOffset(InstructionSet isa, Runtime::CalleeSaveType type, size_t pc_offset)
     55       NO_THREAD_SAFETY_ANALYSIS {
     56     mirror::ArtMethod* save_method = CreateCalleeSaveMethod(isa, type);
     57     QuickMethodFrameInfo frame_info = save_method->GetQuickFrameInfo();
     58     EXPECT_EQ(save_method->GetReturnPcOffsetInBytes(), pc_offset) << "Expected and real pc offset"
     59         " differs for " << type << " core spills=" << std::hex << frame_info.CoreSpillMask() <<
     60         " fp spills=" << frame_info.FpSpillMask() << std::dec << " ISA " << isa;
     61   }
     62 };
     63 
     64 // Note: these tests are all runtime tests. They let the Runtime create the corresponding ArtMethod
     65 // and check against it. Technically we know and expect certain values, but the Runtime code is
     66 // not constexpr, so we cannot make this compile-time checks (and I want the Runtime code tested).
     67 
     68 // This test ensures that kQuickCalleeSaveFrame_RefAndArgs_FrameSize is correct.
     69 TEST_F(QuickTrampolineEntrypointsTest, FrameSize) {
     70   // We have to use a define here as the callee_save_frame.h functions are constexpr.
     71 #define CHECK_FRAME_SIZE(isa)                                                                     \
     72   CheckFrameSize(isa, Runtime::kRefsAndArgs, GetCalleeSaveFrameSize(isa, Runtime::kRefsAndArgs)); \
     73   CheckFrameSize(isa, Runtime::kRefsOnly, GetCalleeSaveFrameSize(isa, Runtime::kRefsOnly));       \
     74   CheckFrameSize(isa, Runtime::kSaveAll, GetCalleeSaveFrameSize(isa, Runtime::kSaveAll))
     75 
     76   CHECK_FRAME_SIZE(kArm);
     77   CHECK_FRAME_SIZE(kArm64);
     78   CHECK_FRAME_SIZE(kMips);
     79   CHECK_FRAME_SIZE(kX86);
     80   CHECK_FRAME_SIZE(kX86_64);
     81 }
     82 
     83 // This test ensures that GetConstExprPointerSize is correct with respect to
     84 // GetInstructionSetPointerSize.
     85 TEST_F(QuickTrampolineEntrypointsTest, PointerSize) {
     86   EXPECT_EQ(GetInstructionSetPointerSize(kArm), GetConstExprPointerSize(kArm));
     87   EXPECT_EQ(GetInstructionSetPointerSize(kArm64), GetConstExprPointerSize(kArm64));
     88   EXPECT_EQ(GetInstructionSetPointerSize(kMips), GetConstExprPointerSize(kMips));
     89   EXPECT_EQ(GetInstructionSetPointerSize(kX86), GetConstExprPointerSize(kX86));
     90   EXPECT_EQ(GetInstructionSetPointerSize(kX86_64), GetConstExprPointerSize(kX86_64));
     91 }
     92 
     93 // This test ensures that the constexpr specialization of the return PC offset computation in
     94 // GetCalleeSavePCOffset is correct.
     95 TEST_F(QuickTrampolineEntrypointsTest, ReturnPC) {
     96   // Ensure that the computation in callee_save_frame.h correct.
     97   // Note: we can only check against the kRuntimeISA, because the ArtMethod computation uses
     98   // kPointerSize, which is wrong when the target bitwidth is not the same as the host's.
     99   CheckPCOffset(kRuntimeISA, Runtime::kRefsAndArgs,
    100                 GetCalleeSavePCOffset(kRuntimeISA, Runtime::kRefsAndArgs));
    101   CheckPCOffset(kRuntimeISA, Runtime::kRefsOnly,
    102                 GetCalleeSavePCOffset(kRuntimeISA, Runtime::kRefsOnly));
    103   CheckPCOffset(kRuntimeISA, Runtime::kSaveAll,
    104                 GetCalleeSavePCOffset(kRuntimeISA, Runtime::kSaveAll));
    105 }
    106 
    107 }  // namespace art
    108