dex2oat/linker/multi_oat_relative_patcher_test.cc - LeafOS-Project/android_art - Gitiles

 /*
  * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "multi_oat_relative_patcher.h"

 #include "debug/method_debug_info.h"
 #include "driver/compiled_method.h"
 #include "gtest/gtest.h"
 #include "linker/linker_patch.h"
 #include "stream/vector_output_stream.h"

 namespace art {
 namespace linker {

 static const MethodReference kNullMethodRef = MethodReference(nullptr, 0u);

 class MultiOatRelativePatcherTest : public testing::Test {
  protected:
   class MockPatcher : public RelativePatcher {
    public:
     MockPatcher() { }

     uint32_t ReserveSpace(uint32_t offset,
                           [[maybe_unused]] const CompiledMethod* compiled_method,
                           MethodReference method_ref) override {
       last_reserve_offset_ = offset;
       last_reserve_method_ = method_ref;
       offset += next_reserve_adjustment_;
       next_reserve_adjustment_ = 0u;
       return offset;
     }

     uint32_t ReserveSpaceEnd(uint32_t offset) override {
       last_reserve_offset_ = offset;
       last_reserve_method_ = kNullMethodRef;
       offset += next_reserve_adjustment_;
       next_reserve_adjustment_ = 0u;
       return offset;
     }

     uint32_t WriteThunks(OutputStream* out, uint32_t offset) override {
       last_write_offset_ = offset;
       if (next_write_alignment_ != 0u) {
         offset += next_write_alignment_;
         bool success = WriteCodeAlignment(out, next_write_alignment_);
         CHECK(success);
         next_write_alignment_ = 0u;
       }
       if (next_write_call_thunk_ != 0u) {
         offset += next_write_call_thunk_;
         std::vector<uint8_t> thunk(next_write_call_thunk_, 'c');
         bool success = WriteThunk(out, ArrayRef<const uint8_t>(thunk));
         CHECK(success);
         next_write_call_thunk_ = 0u;
       }
       if (next_write_misc_thunk_ != 0u) {
         offset += next_write_misc_thunk_;
         std::vector<uint8_t> thunk(next_write_misc_thunk_, 'm');
         bool success = WriteMiscThunk(out, ArrayRef<const uint8_t>(thunk));
         CHECK(success);
         next_write_misc_thunk_ = 0u;
       }
       return offset;
     }

     void PatchCall([[maybe_unused]] std::vector<uint8_t>* code,
                    uint32_t literal_offset,
                    uint32_t patch_offset,
                    uint32_t target_offset) override {
       last_literal_offset_ = literal_offset;
       last_patch_offset_ = patch_offset;
       last_target_offset_ = target_offset;
     }

     void PatchPcRelativeReference([[maybe_unused]] std::vector<uint8_t>* code,
                                   const LinkerPatch& patch,
                                   uint32_t patch_offset,
                                   uint32_t target_offset) override {
       last_literal_offset_ = patch.LiteralOffset();
       last_patch_offset_ = patch_offset;
       last_target_offset_ = target_offset;
     }

     void PatchEntrypointCall([[maybe_unused]] std::vector<uint8_t>* code,
                              [[maybe_unused]] const LinkerPatch& patch,
                              [[maybe_unused]] uint32_t patch_offset) override {
       LOG(FATAL) << "UNIMPLEMENTED";
     }

     void PatchBakerReadBarrierBranch([[maybe_unused]] std::vector<uint8_t>* code,
                                      [[maybe_unused]] const LinkerPatch& patch,
                                      [[maybe_unused]] uint32_t patch_offset) override {
       LOG(FATAL) << "UNIMPLEMENTED";
     }

     std::vector<debug::MethodDebugInfo> GenerateThunkDebugInfo(
         [[maybe_unused]] uint32_t executable_offset) override {
       LOG(FATAL) << "UNIMPLEMENTED";
       UNREACHABLE();
     }

     uint32_t last_reserve_offset_ = 0u;
     MethodReference last_reserve_method_ = kNullMethodRef;
     uint32_t next_reserve_adjustment_ = 0u;

     uint32_t last_write_offset_ = 0u;
     uint32_t next_write_alignment_ = 0u;
     uint32_t next_write_call_thunk_ = 0u;
     uint32_t next_write_misc_thunk_ = 0u;

     uint32_t last_literal_offset_ = 0u;
     uint32_t last_patch_offset_ = 0u;
     uint32_t last_target_offset_ = 0u;
   };

   MultiOatRelativePatcherTest()
       : instruction_set_features_(InstructionSetFeatures::FromCppDefines()),
         patcher_(kRuntimeISA, instruction_set_features_.get(), /* storage */ nullptr) {
     std::unique_ptr<MockPatcher> mock(new MockPatcher());
     mock_ = mock.get();
     patcher_.relative_patcher_ = std::move(mock);
   }

   std::unique_ptr<const InstructionSetFeatures> instruction_set_features_;
   MultiOatRelativePatcher patcher_;
   MockPatcher* mock_;
 };

 TEST_F(MultiOatRelativePatcherTest, Offsets) {
   const DexFile* dex_file = reinterpret_cast<const DexFile*>(1);
   MethodReference ref1(dex_file, 1u);
   MethodReference ref2(dex_file, 2u);
   EXPECT_EQ(0u, patcher_.GetOffset(ref1));
   EXPECT_EQ(0u, patcher_.GetOffset(ref2));

   uint32_t adjustment1 = kElfSegmentAlignment;
   patcher_.StartOatFile(adjustment1);
   EXPECT_EQ(0u, patcher_.GetOffset(ref1));
   EXPECT_EQ(0u, patcher_.GetOffset(ref2));

   uint32_t off1 = 0x1234;
   patcher_.SetOffset(ref1, off1);
   EXPECT_EQ(off1, patcher_.GetOffset(ref1));
   EXPECT_EQ(0u, patcher_.GetOffset(ref2));

   uint32_t adjustment2 = 0x30 * kElfSegmentAlignment;
   patcher_.StartOatFile(adjustment2);
   EXPECT_EQ(off1 + adjustment1 - adjustment2, patcher_.GetOffset(ref1));
   EXPECT_EQ(0u, patcher_.GetOffset(ref2));

   uint32_t off2 = 0x4321;
   patcher_.SetOffset(ref2, off2);
   EXPECT_EQ(off1 + adjustment1 - adjustment2, patcher_.GetOffset(ref1));
   EXPECT_EQ(off2, patcher_.GetOffset(ref2));

   uint32_t adjustment3 = 0x78 * kElfSegmentAlignment;
   patcher_.StartOatFile(adjustment3);
   EXPECT_EQ(off1 + adjustment1 - adjustment3, patcher_.GetOffset(ref1));
   EXPECT_EQ(off2 + adjustment2 - adjustment3, patcher_.GetOffset(ref2));
 }

 TEST_F(MultiOatRelativePatcherTest, OffsetsInReserve) {
   const DexFile* dex_file = reinterpret_cast<const DexFile*>(1);
   MethodReference ref1(dex_file, 1u);
   MethodReference ref2(dex_file, 2u);
   MethodReference ref3(dex_file, 3u);
   const CompiledMethod* method = reinterpret_cast<const CompiledMethod*>(-1);

   uint32_t adjustment1 = kElfSegmentAlignment;
   patcher_.StartOatFile(adjustment1);

   uint32_t method1_offset = 0x100;
   uint32_t method1_offset_check = patcher_.ReserveSpace(method1_offset, method, ref1);
   ASSERT_EQ(adjustment1 + method1_offset, mock_->last_reserve_offset_);
   ASSERT_TRUE(ref1 == mock_->last_reserve_method_);
   ASSERT_EQ(method1_offset, method1_offset_check);

   uint32_t method2_offset = 0x1230;
   uint32_t method2_reserve_adjustment = 0x10;
   mock_->next_reserve_adjustment_ = method2_reserve_adjustment;
   uint32_t method2_offset_adjusted = patcher_.ReserveSpace(method2_offset, method, ref2);
   ASSERT_EQ(adjustment1 + method2_offset, mock_->last_reserve_offset_);
   ASSERT_TRUE(ref2 == mock_->last_reserve_method_);
   ASSERT_EQ(method2_offset + method2_reserve_adjustment, method2_offset_adjusted);

   uint32_t end1_offset = 0x4320;
   uint32_t end1_offset_check = patcher_.ReserveSpaceEnd(end1_offset);
   ASSERT_EQ(adjustment1 + end1_offset, mock_->last_reserve_offset_);
   ASSERT_TRUE(kNullMethodRef == mock_->last_reserve_method_);
   ASSERT_EQ(end1_offset, end1_offset_check);

   uint32_t adjustment2 = 0xd * kElfSegmentAlignment;
   patcher_.StartOatFile(adjustment2);

   uint32_t method3_offset = 0xf00;
   uint32_t method3_offset_check = patcher_.ReserveSpace(method3_offset, method, ref3);
   ASSERT_EQ(adjustment2 + method3_offset, mock_->last_reserve_offset_);
   ASSERT_TRUE(ref3 == mock_->last_reserve_method_);
   ASSERT_EQ(method3_offset, method3_offset_check);

   uint32_t end2_offset = 0x2400;
   uint32_t end2_reserve_adjustment = 0x20;
   mock_->next_reserve_adjustment_ = end2_reserve_adjustment;
   uint32_t end2_offset_adjusted = patcher_.ReserveSpaceEnd(end2_offset);
   ASSERT_EQ(adjustment2 + end2_offset, mock_->last_reserve_offset_);
   ASSERT_TRUE(kNullMethodRef == mock_->last_reserve_method_);
   ASSERT_EQ(end2_offset + end2_reserve_adjustment, end2_offset_adjusted);
 }

 TEST_F(MultiOatRelativePatcherTest, Write) {
   std::vector<uint8_t> output;
   VectorOutputStream vos("output", &output);

   uint32_t adjustment1 = kElfSegmentAlignment;
   patcher_.StartOatFile(adjustment1);

   uint32_t method1_offset = 0x100;
   uint32_t method1_offset_check = patcher_.WriteThunks(&vos, method1_offset);
   ASSERT_EQ(adjustment1 + method1_offset, mock_->last_write_offset_);
   ASSERT_EQ(method1_offset, method1_offset_check);
   vos.WriteFully("1", 1);  // Mark method1.

   uint32_t method2_offset = 0x1230;
   uint32_t method2_alignment_size = 1;
   uint32_t method2_call_thunk_size = 2;
   mock_->next_write_alignment_ = method2_alignment_size;
   mock_->next_write_call_thunk_ = method2_call_thunk_size;
   uint32_t method2_offset_adjusted = patcher_.WriteThunks(&vos, method2_offset);
   ASSERT_EQ(adjustment1 + method2_offset, mock_->last_write_offset_);
   ASSERT_EQ(method2_offset + method2_alignment_size + method2_call_thunk_size,
             method2_offset_adjusted);
   vos.WriteFully("2", 1);  // Mark method2.

   EXPECT_EQ(method2_alignment_size, patcher_.CodeAlignmentSize());
   EXPECT_EQ(method2_call_thunk_size, patcher_.RelativeCallThunksSize());

   uint32_t adjustment2 = 0xd * kElfSegmentAlignment;
   patcher_.StartOatFile(adjustment2);

   uint32_t method3_offset = 0xf00;
   uint32_t method3_alignment_size = 2;
   uint32_t method3_misc_thunk_size = 1;
   mock_->next_write_alignment_ = method3_alignment_size;
   mock_->next_write_misc_thunk_ = method3_misc_thunk_size;
   uint32_t method3_offset_adjusted = patcher_.WriteThunks(&vos, method3_offset);
   ASSERT_EQ(adjustment2 + method3_offset, mock_->last_write_offset_);
   ASSERT_EQ(method3_offset + method3_alignment_size + method3_misc_thunk_size,
             method3_offset_adjusted);
   vos.WriteFully("3", 1);  // Mark method3.

   EXPECT_EQ(method3_alignment_size, patcher_.CodeAlignmentSize());
   EXPECT_EQ(method3_misc_thunk_size, patcher_.MiscThunksSize());

   uint8_t expected_output[] = {
       '1',
       0, 'c', 'c', '2',
       0, 0, 'm', '3',
   };
   ASSERT_EQ(arraysize(expected_output), output.size());
   for (size_t i = 0; i != arraysize(expected_output); ++i) {
     ASSERT_EQ(expected_output[i], output[i]) << i;
   }
 }

 TEST_F(MultiOatRelativePatcherTest, Patch) {
   std::vector<uint8_t> code(16);

   uint32_t adjustment1 = kElfSegmentAlignment;
   patcher_.StartOatFile(adjustment1);

   uint32_t method1_literal_offset = 4u;
   uint32_t method1_patch_offset = 0x1234u;
   uint32_t method1_target_offset = 0x8888u;
   patcher_.PatchCall(&code, method1_literal_offset, method1_patch_offset, method1_target_offset);
   DCHECK_EQ(method1_literal_offset, mock_->last_literal_offset_);
   DCHECK_EQ(method1_patch_offset + adjustment1, mock_->last_patch_offset_);
   DCHECK_EQ(method1_target_offset + adjustment1, mock_->last_target_offset_);

   uint32_t method2_literal_offset = 12u;
   uint32_t method2_patch_offset = 0x7654u;
   uint32_t method2_target_offset = 0xccccu;
   LinkerPatch method2_patch =
       LinkerPatch::StringBssEntryPatch(method2_literal_offset, nullptr, 0u, 1u);
   patcher_.PatchPcRelativeReference(
       &code, method2_patch, method2_patch_offset, method2_target_offset);
   DCHECK_EQ(method2_literal_offset, mock_->last_literal_offset_);
   DCHECK_EQ(method2_patch_offset + adjustment1, mock_->last_patch_offset_);
   DCHECK_EQ(method2_target_offset + adjustment1, mock_->last_target_offset_);

   uint32_t adjustment2 = 0xd * kElfSegmentAlignment;
   patcher_.StartOatFile(adjustment2);

   uint32_t method3_literal_offset = 8u;
   uint32_t method3_patch_offset = 0x108u;
   uint32_t method3_target_offset = 0x200u;
   patcher_.PatchCall(&code, method3_literal_offset, method3_patch_offset, method3_target_offset);
   DCHECK_EQ(method3_literal_offset, mock_->last_literal_offset_);
   DCHECK_EQ(method3_patch_offset + adjustment2, mock_->last_patch_offset_);
   DCHECK_EQ(method3_target_offset + adjustment2, mock_->last_target_offset_);
 }

 }  // namespace linker
 }  // namespace art
	/*
	* Copyright (C) 2016 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "multi_oat_relative_patcher.h"

	#include "debug/method_debug_info.h"
	#include "driver/compiled_method.h"
	#include "gtest/gtest.h"
	#include "linker/linker_patch.h"
	#include "stream/vector_output_stream.h"

	namespace art {
	namespace linker {

	static const MethodReference kNullMethodRef = MethodReference(nullptr, 0u);

	class MultiOatRelativePatcherTest : public testing::Test {
	protected:
	class MockPatcher : public RelativePatcher {
	public:
	MockPatcher() { }

	uint32_t ReserveSpace(uint32_t offset,
	[[maybe_unused]] const CompiledMethod* compiled_method,
	MethodReference method_ref) override {
	last_reserve_offset_ = offset;
	last_reserve_method_ = method_ref;
	offset += next_reserve_adjustment_;
	next_reserve_adjustment_ = 0u;
	return offset;
	}

	uint32_t ReserveSpaceEnd(uint32_t offset) override {
	last_reserve_offset_ = offset;
	last_reserve_method_ = kNullMethodRef;
	offset += next_reserve_adjustment_;
	next_reserve_adjustment_ = 0u;
	return offset;
	}

	uint32_t WriteThunks(OutputStream* out, uint32_t offset) override {
	last_write_offset_ = offset;
	if (next_write_alignment_ != 0u) {
	offset += next_write_alignment_;
	bool success = WriteCodeAlignment(out, next_write_alignment_);
	CHECK(success);
	next_write_alignment_ = 0u;
	}
	if (next_write_call_thunk_ != 0u) {
	offset += next_write_call_thunk_;
	std::vector<uint8_t> thunk(next_write_call_thunk_, 'c');
	bool success = WriteThunk(out, ArrayRef<const uint8_t>(thunk));
	CHECK(success);
	next_write_call_thunk_ = 0u;
	}
	if (next_write_misc_thunk_ != 0u) {
	offset += next_write_misc_thunk_;
	std::vector<uint8_t> thunk(next_write_misc_thunk_, 'm');
	bool success = WriteMiscThunk(out, ArrayRef<const uint8_t>(thunk));
	CHECK(success);
	next_write_misc_thunk_ = 0u;
	}
	return offset;
	}

	void PatchCall([[maybe_unused]] std::vector<uint8_t>* code,
	uint32_t literal_offset,
	uint32_t patch_offset,
	uint32_t target_offset) override {
	last_literal_offset_ = literal_offset;
	last_patch_offset_ = patch_offset;
	last_target_offset_ = target_offset;
	}

	void PatchPcRelativeReference([[maybe_unused]] std::vector<uint8_t>* code,
	const LinkerPatch& patch,
	uint32_t patch_offset,
	uint32_t target_offset) override {
	last_literal_offset_ = patch.LiteralOffset();
	last_patch_offset_ = patch_offset;
	last_target_offset_ = target_offset;
	}

	void PatchEntrypointCall([[maybe_unused]] std::vector<uint8_t>* code,
	[[maybe_unused]] const LinkerPatch& patch,
	[[maybe_unused]] uint32_t patch_offset) override {
	LOG(FATAL) << "UNIMPLEMENTED";
	}

	void PatchBakerReadBarrierBranch([[maybe_unused]] std::vector<uint8_t>* code,
	[[maybe_unused]] const LinkerPatch& patch,
	[[maybe_unused]] uint32_t patch_offset) override {
	LOG(FATAL) << "UNIMPLEMENTED";
	}

	std::vector<debug::MethodDebugInfo> GenerateThunkDebugInfo(
	[[maybe_unused]] uint32_t executable_offset) override {
	LOG(FATAL) << "UNIMPLEMENTED";
	UNREACHABLE();
	}

	uint32_t last_reserve_offset_ = 0u;
	MethodReference last_reserve_method_ = kNullMethodRef;
	uint32_t next_reserve_adjustment_ = 0u;

	uint32_t last_write_offset_ = 0u;
	uint32_t next_write_alignment_ = 0u;
	uint32_t next_write_call_thunk_ = 0u;
	uint32_t next_write_misc_thunk_ = 0u;

	uint32_t last_literal_offset_ = 0u;
	uint32_t last_patch_offset_ = 0u;
	uint32_t last_target_offset_ = 0u;
	};

	MultiOatRelativePatcherTest()
	: instruction_set_features_(InstructionSetFeatures::FromCppDefines()),
	patcher_(kRuntimeISA, instruction_set_features_.get(), /* storage */ nullptr) {
	std::unique_ptr<MockPatcher> mock(new MockPatcher());
	mock_ = mock.get();
	patcher_.relative_patcher_ = std::move(mock);
	}

	std::unique_ptr<const InstructionSetFeatures> instruction_set_features_;
	MultiOatRelativePatcher patcher_;
	MockPatcher* mock_;
	};

	TEST_F(MultiOatRelativePatcherTest, Offsets) {
	const DexFile* dex_file = reinterpret_cast<const DexFile*>(1);
	MethodReference ref1(dex_file, 1u);
	MethodReference ref2(dex_file, 2u);
	EXPECT_EQ(0u, patcher_.GetOffset(ref1));
	EXPECT_EQ(0u, patcher_.GetOffset(ref2));

	uint32_t adjustment1 = kElfSegmentAlignment;
	patcher_.StartOatFile(adjustment1);
	EXPECT_EQ(0u, patcher_.GetOffset(ref1));
	EXPECT_EQ(0u, patcher_.GetOffset(ref2));

	uint32_t off1 = 0x1234;
	patcher_.SetOffset(ref1, off1);
	EXPECT_EQ(off1, patcher_.GetOffset(ref1));
	EXPECT_EQ(0u, patcher_.GetOffset(ref2));

	uint32_t adjustment2 = 0x30 * kElfSegmentAlignment;
	patcher_.StartOatFile(adjustment2);
	EXPECT_EQ(off1 + adjustment1 - adjustment2, patcher_.GetOffset(ref1));
	EXPECT_EQ(0u, patcher_.GetOffset(ref2));

	uint32_t off2 = 0x4321;
	patcher_.SetOffset(ref2, off2);
	EXPECT_EQ(off1 + adjustment1 - adjustment2, patcher_.GetOffset(ref1));
	EXPECT_EQ(off2, patcher_.GetOffset(ref2));

	uint32_t adjustment3 = 0x78 * kElfSegmentAlignment;
	patcher_.StartOatFile(adjustment3);
	EXPECT_EQ(off1 + adjustment1 - adjustment3, patcher_.GetOffset(ref1));
	EXPECT_EQ(off2 + adjustment2 - adjustment3, patcher_.GetOffset(ref2));
	}

	TEST_F(MultiOatRelativePatcherTest, OffsetsInReserve) {
	const DexFile* dex_file = reinterpret_cast<const DexFile*>(1);
	MethodReference ref1(dex_file, 1u);
	MethodReference ref2(dex_file, 2u);
	MethodReference ref3(dex_file, 3u);
	const CompiledMethod* method = reinterpret_cast<const CompiledMethod*>(-1);

	uint32_t adjustment1 = kElfSegmentAlignment;
	patcher_.StartOatFile(adjustment1);

	uint32_t method1_offset = 0x100;
	uint32_t method1_offset_check = patcher_.ReserveSpace(method1_offset, method, ref1);
	ASSERT_EQ(adjustment1 + method1_offset, mock_->last_reserve_offset_);
	ASSERT_TRUE(ref1 == mock_->last_reserve_method_);
	ASSERT_EQ(method1_offset, method1_offset_check);

	uint32_t method2_offset = 0x1230;
	uint32_t method2_reserve_adjustment = 0x10;
	mock_->next_reserve_adjustment_ = method2_reserve_adjustment;
	uint32_t method2_offset_adjusted = patcher_.ReserveSpace(method2_offset, method, ref2);
	ASSERT_EQ(adjustment1 + method2_offset, mock_->last_reserve_offset_);
	ASSERT_TRUE(ref2 == mock_->last_reserve_method_);
	ASSERT_EQ(method2_offset + method2_reserve_adjustment, method2_offset_adjusted);

	uint32_t end1_offset = 0x4320;
	uint32_t end1_offset_check = patcher_.ReserveSpaceEnd(end1_offset);
	ASSERT_EQ(adjustment1 + end1_offset, mock_->last_reserve_offset_);
	ASSERT_TRUE(kNullMethodRef == mock_->last_reserve_method_);
	ASSERT_EQ(end1_offset, end1_offset_check);

	uint32_t adjustment2 = 0xd * kElfSegmentAlignment;
	patcher_.StartOatFile(adjustment2);

	uint32_t method3_offset = 0xf00;
	uint32_t method3_offset_check = patcher_.ReserveSpace(method3_offset, method, ref3);
	ASSERT_EQ(adjustment2 + method3_offset, mock_->last_reserve_offset_);
	ASSERT_TRUE(ref3 == mock_->last_reserve_method_);
	ASSERT_EQ(method3_offset, method3_offset_check);

	uint32_t end2_offset = 0x2400;
	uint32_t end2_reserve_adjustment = 0x20;
	mock_->next_reserve_adjustment_ = end2_reserve_adjustment;
	uint32_t end2_offset_adjusted = patcher_.ReserveSpaceEnd(end2_offset);
	ASSERT_EQ(adjustment2 + end2_offset, mock_->last_reserve_offset_);
	ASSERT_TRUE(kNullMethodRef == mock_->last_reserve_method_);
	ASSERT_EQ(end2_offset + end2_reserve_adjustment, end2_offset_adjusted);
	}

	TEST_F(MultiOatRelativePatcherTest, Write) {
	std::vector<uint8_t> output;
	VectorOutputStream vos("output", &output);

	uint32_t adjustment1 = kElfSegmentAlignment;
	patcher_.StartOatFile(adjustment1);

	uint32_t method1_offset = 0x100;
	uint32_t method1_offset_check = patcher_.WriteThunks(&vos, method1_offset);
	ASSERT_EQ(adjustment1 + method1_offset, mock_->last_write_offset_);
	ASSERT_EQ(method1_offset, method1_offset_check);
	vos.WriteFully("1", 1); // Mark method1.

	uint32_t method2_offset = 0x1230;
	uint32_t method2_alignment_size = 1;
	uint32_t method2_call_thunk_size = 2;
	mock_->next_write_alignment_ = method2_alignment_size;
	mock_->next_write_call_thunk_ = method2_call_thunk_size;
	uint32_t method2_offset_adjusted = patcher_.WriteThunks(&vos, method2_offset);
	ASSERT_EQ(adjustment1 + method2_offset, mock_->last_write_offset_);
	ASSERT_EQ(method2_offset + method2_alignment_size + method2_call_thunk_size,
	method2_offset_adjusted);
	vos.WriteFully("2", 1); // Mark method2.

	EXPECT_EQ(method2_alignment_size, patcher_.CodeAlignmentSize());
	EXPECT_EQ(method2_call_thunk_size, patcher_.RelativeCallThunksSize());

	uint32_t adjustment2 = 0xd * kElfSegmentAlignment;
	patcher_.StartOatFile(adjustment2);

	uint32_t method3_offset = 0xf00;
	uint32_t method3_alignment_size = 2;
	uint32_t method3_misc_thunk_size = 1;
	mock_->next_write_alignment_ = method3_alignment_size;
	mock_->next_write_misc_thunk_ = method3_misc_thunk_size;
	uint32_t method3_offset_adjusted = patcher_.WriteThunks(&vos, method3_offset);
	ASSERT_EQ(adjustment2 + method3_offset, mock_->last_write_offset_);
	ASSERT_EQ(method3_offset + method3_alignment_size + method3_misc_thunk_size,
	method3_offset_adjusted);
	vos.WriteFully("3", 1); // Mark method3.

	EXPECT_EQ(method3_alignment_size, patcher_.CodeAlignmentSize());
	EXPECT_EQ(method3_misc_thunk_size, patcher_.MiscThunksSize());

	uint8_t expected_output[] = {
	'1',
	0, 'c', 'c', '2',
	0, 0, 'm', '3',
	};
	ASSERT_EQ(arraysize(expected_output), output.size());
	for (size_t i = 0; i != arraysize(expected_output); ++i) {
	ASSERT_EQ(expected_output[i], output[i]) << i;
	}
	}

	TEST_F(MultiOatRelativePatcherTest, Patch) {
	std::vector<uint8_t> code(16);

	uint32_t adjustment1 = kElfSegmentAlignment;
	patcher_.StartOatFile(adjustment1);

	uint32_t method1_literal_offset = 4u;
	uint32_t method1_patch_offset = 0x1234u;
	uint32_t method1_target_offset = 0x8888u;
	patcher_.PatchCall(&code, method1_literal_offset, method1_patch_offset, method1_target_offset);
	DCHECK_EQ(method1_literal_offset, mock_->last_literal_offset_);
	DCHECK_EQ(method1_patch_offset + adjustment1, mock_->last_patch_offset_);
	DCHECK_EQ(method1_target_offset + adjustment1, mock_->last_target_offset_);

	uint32_t method2_literal_offset = 12u;
	uint32_t method2_patch_offset = 0x7654u;
	uint32_t method2_target_offset = 0xccccu;
	LinkerPatch method2_patch =
	LinkerPatch::StringBssEntryPatch(method2_literal_offset, nullptr, 0u, 1u);
	patcher_.PatchPcRelativeReference(
	&code, method2_patch, method2_patch_offset, method2_target_offset);
	DCHECK_EQ(method2_literal_offset, mock_->last_literal_offset_);
	DCHECK_EQ(method2_patch_offset + adjustment1, mock_->last_patch_offset_);
	DCHECK_EQ(method2_target_offset + adjustment1, mock_->last_target_offset_);

	uint32_t adjustment2 = 0xd * kElfSegmentAlignment;
	patcher_.StartOatFile(adjustment2);

	uint32_t method3_literal_offset = 8u;
	uint32_t method3_patch_offset = 0x108u;
	uint32_t method3_target_offset = 0x200u;
	patcher_.PatchCall(&code, method3_literal_offset, method3_patch_offset, method3_target_offset);
	DCHECK_EQ(method3_literal_offset, mock_->last_literal_offset_);
	DCHECK_EQ(method3_patch_offset + adjustment2, mock_->last_patch_offset_);
	DCHECK_EQ(method3_target_offset + adjustment2, mock_->last_target_offset_);
	}

	} // namespace linker
	} // namespace art