1 /* 2 * Copyright (C) 2016 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 "linker/relative_patcher_test.h" 18 #include "linker/mips64/relative_patcher_mips64.h" 19 20 namespace art { 21 namespace linker { 22 23 class Mips64RelativePatcherTest : public RelativePatcherTest { 24 public: 25 Mips64RelativePatcherTest() : RelativePatcherTest(kMips64, "default") {} 26 27 protected: 28 static const uint8_t kUnpatchedPcRelativeRawCode[]; 29 static const uint8_t kUnpatchedPcRelativeCallRawCode[]; 30 static const uint32_t kLiteralOffset; 31 static const uint32_t kAnchorOffset; 32 static const ArrayRef<const uint8_t> kUnpatchedPcRelativeCode; 33 static const ArrayRef<const uint8_t> kUnpatchedPcRelativeCallCode; 34 35 uint32_t GetMethodOffset(uint32_t method_idx) { 36 auto result = method_offset_map_.FindMethodOffset(MethodRef(method_idx)); 37 CHECK(result.first); 38 return result.second; 39 } 40 41 void CheckPcRelativePatch(const ArrayRef<const LinkerPatch>& patches, uint32_t target_offset); 42 void TestDexCacheReference(uint32_t dex_cache_arrays_begin, uint32_t element_offset); 43 void TestStringReference(uint32_t string_offset); 44 }; 45 46 const uint8_t Mips64RelativePatcherTest::kUnpatchedPcRelativeRawCode[] = { 47 0x34, 0x12, 0x5E, 0xEE, // auipc s2, high(diff); placeholder = 0x1234 48 0x78, 0x56, 0x52, 0x66, // daddiu s2, s2, low(diff); placeholder = 0x5678 49 }; 50 const uint8_t Mips64RelativePatcherTest::kUnpatchedPcRelativeCallRawCode[] = { 51 0x34, 0x12, 0x3E, 0xEC, // auipc at, high(diff); placeholder = 0x1234 52 0x78, 0x56, 0x01, 0xF8, // jialc at, low(diff); placeholder = 0x5678 53 }; 54 const uint32_t Mips64RelativePatcherTest::kLiteralOffset = 0; // At auipc (where patching starts). 55 const uint32_t Mips64RelativePatcherTest::kAnchorOffset = 0; // At auipc (where PC+0 points). 56 const ArrayRef<const uint8_t> Mips64RelativePatcherTest::kUnpatchedPcRelativeCode( 57 kUnpatchedPcRelativeRawCode); 58 const ArrayRef<const uint8_t> Mips64RelativePatcherTest::kUnpatchedPcRelativeCallCode( 59 kUnpatchedPcRelativeCallRawCode); 60 61 void Mips64RelativePatcherTest::CheckPcRelativePatch(const ArrayRef<const LinkerPatch>& patches, 62 uint32_t target_offset) { 63 AddCompiledMethod(MethodRef(1u), kUnpatchedPcRelativeCode, ArrayRef<const LinkerPatch>(patches)); 64 Link(); 65 66 auto result = method_offset_map_.FindMethodOffset(MethodRef(1u)); 67 ASSERT_TRUE(result.first); 68 69 uint32_t diff = target_offset - (result.second + kAnchorOffset); 70 diff += (diff & 0x8000) << 1; // Account for sign extension in instruction following auipc. 71 72 const uint8_t expected_code[] = { 73 static_cast<uint8_t>(diff >> 16), static_cast<uint8_t>(diff >> 24), 0x5E, 0xEE, 74 static_cast<uint8_t>(diff), static_cast<uint8_t>(diff >> 8), 0x52, 0x66, 75 }; 76 EXPECT_TRUE(CheckLinkedMethod(MethodRef(1u), ArrayRef<const uint8_t>(expected_code))); 77 } 78 79 void Mips64RelativePatcherTest::TestDexCacheReference(uint32_t dex_cache_arrays_begin, 80 uint32_t element_offset) { 81 dex_cache_arrays_begin_ = dex_cache_arrays_begin; 82 LinkerPatch patches[] = { 83 LinkerPatch::DexCacheArrayPatch(kLiteralOffset, nullptr, kAnchorOffset, element_offset) 84 }; 85 CheckPcRelativePatch(ArrayRef<const LinkerPatch>(patches), 86 dex_cache_arrays_begin_ + element_offset); 87 } 88 89 TEST_F(Mips64RelativePatcherTest, DexCacheReference) { 90 TestDexCacheReference(/* dex_cache_arrays_begin */ 0x12345678, /* element_offset */ 0x1234); 91 } 92 93 TEST_F(Mips64RelativePatcherTest, CallOther) { 94 LinkerPatch method1_patches[] = { 95 LinkerPatch::RelativeCodePatch(kLiteralOffset, nullptr, 2u), 96 }; 97 AddCompiledMethod(MethodRef(1u), 98 kUnpatchedPcRelativeCallCode, 99 ArrayRef<const LinkerPatch>(method1_patches)); 100 LinkerPatch method2_patches[] = { 101 LinkerPatch::RelativeCodePatch(kLiteralOffset, nullptr, 1u), 102 }; 103 AddCompiledMethod(MethodRef(2u), 104 kUnpatchedPcRelativeCallCode, 105 ArrayRef<const LinkerPatch>(method2_patches)); 106 Link(); 107 108 uint32_t method1_offset = GetMethodOffset(1u); 109 uint32_t method2_offset = GetMethodOffset(2u); 110 uint32_t diff_after = method2_offset - (method1_offset + kAnchorOffset /* PC adjustment */); 111 diff_after += (diff_after & 0x8000) << 1; // Account for sign extension in jialc. 112 static const uint8_t method1_expected_code[] = { 113 static_cast<uint8_t>(diff_after >> 16), static_cast<uint8_t>(diff_after >> 24), 0x3E, 0xEC, 114 static_cast<uint8_t>(diff_after), static_cast<uint8_t>(diff_after >> 8), 0x01, 0xF8, 115 }; 116 EXPECT_TRUE(CheckLinkedMethod(MethodRef(1u), ArrayRef<const uint8_t>(method1_expected_code))); 117 uint32_t diff_before = method1_offset - (method2_offset + kAnchorOffset /* PC adjustment */); 118 diff_before += (diff_before & 0x8000) << 1; // Account for sign extension in jialc. 119 static const uint8_t method2_expected_code[] = { 120 static_cast<uint8_t>(diff_before >> 16), static_cast<uint8_t>(diff_before >> 24), 0x3E, 0xEC, 121 static_cast<uint8_t>(diff_before), static_cast<uint8_t>(diff_before >> 8), 0x01, 0xF8, 122 }; 123 EXPECT_TRUE(CheckLinkedMethod(MethodRef(2u), ArrayRef<const uint8_t>(method2_expected_code))); 124 } 125 126 } // namespace linker 127 } // namespace art 128
