diff options
47 files changed, 710 insertions, 547 deletions
diff --git a/compiler/Android.bp b/compiler/Android.bp index 14756792c0..c50c1978ac 100644 --- a/compiler/Android.bp +++ b/compiler/Android.bp @@ -204,10 +204,10 @@ gensrcs { cmd: "$(location generate-operator-out.py) art/compiler $(in) > $(out)", tool_files: ["generate-operator-out.py"], srcs: [ - "compiled_method.h", "dex/dex_to_dex_compiler.h", "driver/compiler_driver.h", "driver/compiler_options.h", + "linker/linker_patch.h", "optimizing/locations.h", "utils/arm/constants_arm.h", @@ -310,13 +310,14 @@ art_cc_test { "art_gtest_defaults", ], srcs: [ - "compiled_method_test.cc", "debug/dwarf/dwarf_test.cc", + "debug/src_map_elem_test.cc", "dex/dex_to_dex_decompiler_test.cc", "driver/compiled_method_storage_test.cc", "driver/compiler_driver_test.cc", "exception_test.cc", "jni/jni_compiler_test.cc", + "linker/linker_patch_test.cc", "linker/method_bss_mapping_encoder_test.cc", "linker/output_stream_test.cc", "optimizing/bounds_check_elimination_test.cc", diff --git a/compiler/common_compiler_test.cc b/compiler/common_compiler_test.cc index 0d38620b1a..500fc4ae9a 100644 --- a/compiler/common_compiler_test.cc +++ b/compiler/common_compiler_test.cc @@ -22,7 +22,7 @@ #include "base/callee_save_type.h" #include "base/enums.h" #include "class_linker.h" -#include "compiled_method.h" +#include "compiled_method-inl.h" #include "dex/quick_compiler_callbacks.h" #include "dex/verification_results.h" #include "driver/compiler_driver.h" diff --git a/compiler/compiled_method-inl.h b/compiler/compiled_method-inl.h new file mode 100644 index 0000000000..c43274782e --- /dev/null +++ b/compiler/compiled_method-inl.h @@ -0,0 +1,59 @@ +/* + * Copyright (C) 2017 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. + */ + +#ifndef ART_COMPILER_COMPILED_METHOD_INL_H_ +#define ART_COMPILER_COMPILED_METHOD_INL_H_ + +#include "compiled_method.h" + +#include "base/array_ref.h" +#include "base/length_prefixed_array.h" +#include "linker/linker_patch.h" + +namespace art { + +inline ArrayRef<const uint8_t> CompiledCode::GetQuickCode() const { + return GetArray(quick_code_); +} + +template <typename T> +inline ArrayRef<const T> CompiledCode::GetArray(const LengthPrefixedArray<T>* array) { + if (array == nullptr) { + return ArrayRef<const T>(); + } + DCHECK_NE(array->size(), 0u); + return ArrayRef<const T>(&array->At(0), array->size()); +} + +inline ArrayRef<const uint8_t> CompiledMethod::GetMethodInfo() const { + return GetArray(method_info_); +} + +inline ArrayRef<const uint8_t> CompiledMethod::GetVmapTable() const { + return GetArray(vmap_table_); +} + +inline ArrayRef<const uint8_t> CompiledMethod::GetCFIInfo() const { + return GetArray(cfi_info_); +} + +inline ArrayRef<const linker::LinkerPatch> CompiledMethod::GetPatches() const { + return GetArray(patches_); +} + +} // namespace art + +#endif // ART_COMPILER_COMPILED_METHOD_INL_H_ diff --git a/compiler/compiled_method.cc b/compiler/compiled_method.cc index 0d9021fcfb..111469fe89 100644 --- a/compiler/compiled_method.cc +++ b/compiler/compiled_method.cc @@ -22,7 +22,8 @@ namespace art { -CompiledCode::CompiledCode(CompilerDriver* compiler_driver, InstructionSet instruction_set, +CompiledCode::CompiledCode(CompilerDriver* compiler_driver, + InstructionSet instruction_set, const ArrayRef<const uint8_t>& quick_code) : compiler_driver_(compiler_driver), instruction_set_(instruction_set), @@ -77,8 +78,7 @@ size_t CompiledCode::CodeDelta(InstructionSet instruction_set) { } } -const void* CompiledCode::CodePointer(const void* code_pointer, - InstructionSet instruction_set) { +const void* CompiledCode::CodePointer(const void* code_pointer, InstructionSet instruction_set) { switch (instruction_set) { case kArm: case kArm64: @@ -108,7 +108,7 @@ CompiledMethod::CompiledMethod(CompilerDriver* driver, const ArrayRef<const uint8_t>& method_info, const ArrayRef<const uint8_t>& vmap_table, const ArrayRef<const uint8_t>& cfi_info, - const ArrayRef<const LinkerPatch>& patches) + const ArrayRef<const linker::LinkerPatch>& patches) : CompiledCode(driver, instruction_set, quick_code), frame_size_in_bytes_(frame_size_in_bytes), core_spill_mask_(core_spill_mask), @@ -129,7 +129,7 @@ CompiledMethod* CompiledMethod::SwapAllocCompiledMethod( const ArrayRef<const uint8_t>& method_info, const ArrayRef<const uint8_t>& vmap_table, const ArrayRef<const uint8_t>& cfi_info, - const ArrayRef<const LinkerPatch>& patches) { + const ArrayRef<const linker::LinkerPatch>& patches) { SwapAllocator<CompiledMethod> alloc(driver->GetCompiledMethodStorage()->GetSwapSpaceAllocator()); CompiledMethod* ret = alloc.allocate(1); alloc.construct(ret, diff --git a/compiler/compiled_method.h b/compiler/compiled_method.h index 5ef6cbff78..892bc592db 100644 --- a/compiler/compiled_method.h +++ b/compiler/compiled_method.h @@ -17,27 +17,28 @@ #ifndef ART_COMPILER_COMPILED_METHOD_H_ #define ART_COMPILER_COMPILED_METHOD_H_ -#include <iosfwd> #include <memory> #include <string> #include <vector> #include "arch/instruction_set.h" -#include "base/array_ref.h" -#include "base/bit_utils.h" -#include "base/length_prefixed_array.h" -#include "dex_file_types.h" -#include "method_reference.h" namespace art { +template <typename T> class ArrayRef; class CompilerDriver; class CompiledMethodStorage; +template<typename T> class LengthPrefixedArray; + +namespace linker { +class LinkerPatch; +} // namespace linker class CompiledCode { public: // For Quick to supply an code blob - CompiledCode(CompilerDriver* compiler_driver, InstructionSet instruction_set, + CompiledCode(CompilerDriver* compiler_driver, + InstructionSet instruction_set, const ArrayRef<const uint8_t>& quick_code); virtual ~CompiledCode(); @@ -46,9 +47,7 @@ class CompiledCode { return instruction_set_; } - ArrayRef<const uint8_t> GetQuickCode() const { - return GetArray(quick_code_); - } + ArrayRef<const uint8_t> GetQuickCode() const; bool operator==(const CompiledCode& rhs) const; @@ -66,18 +65,11 @@ class CompiledCode { // Returns a pointer suitable for invoking the code at the argument // code_pointer address. Mainly to cope with kThumb2 where the // lower bit must be set to indicate Thumb mode. - static const void* CodePointer(const void* code_pointer, - InstructionSet instruction_set); + static const void* CodePointer(const void* code_pointer, InstructionSet instruction_set); protected: template <typename T> - static ArrayRef<const T> GetArray(const LengthPrefixedArray<T>* array) { - if (array == nullptr) { - return ArrayRef<const T>(); - } - DCHECK_NE(array->size(), 0u); - return ArrayRef<const T>(&array->At(0), array->size()); - } + static ArrayRef<const T> GetArray(const LengthPrefixedArray<T>* array); CompilerDriver* GetCompilerDriver() { return compiler_driver_; @@ -92,298 +84,6 @@ class CompiledCode { const LengthPrefixedArray<uint8_t>* const quick_code_; }; -class SrcMapElem { - public: - uint32_t from_; - int32_t to_; -}; - -inline bool operator<(const SrcMapElem& lhs, const SrcMapElem& rhs) { - if (lhs.from_ != rhs.from_) { - return lhs.from_ < rhs.from_; - } - return lhs.to_ < rhs.to_; -} - -inline bool operator==(const SrcMapElem& lhs, const SrcMapElem& rhs) { - return lhs.from_ == rhs.from_ && lhs.to_ == rhs.to_; -} - -class LinkerPatch { - public: - // Note: We explicitly specify the underlying type of the enum because GCC - // would otherwise select a bigger underlying type and then complain that - // 'art::LinkerPatch::patch_type_' is too small to hold all - // values of 'enum class art::LinkerPatch::Type' - // which is ridiculous given we have only a handful of values here. If we - // choose to squeeze the Type into fewer than 8 bits, we'll have to declare - // patch_type_ as an uintN_t and do explicit static_cast<>s. - enum class Type : uint8_t { - kMethodRelative, // NOTE: Actual patching is instruction_set-dependent. - kMethodBssEntry, // NOTE: Actual patching is instruction_set-dependent. - kCall, - kCallRelative, // NOTE: Actual patching is instruction_set-dependent. - kTypeRelative, // NOTE: Actual patching is instruction_set-dependent. - kTypeClassTable, // NOTE: Actual patching is instruction_set-dependent. - kTypeBssEntry, // NOTE: Actual patching is instruction_set-dependent. - kStringRelative, // NOTE: Actual patching is instruction_set-dependent. - kStringInternTable, // NOTE: Actual patching is instruction_set-dependent. - kStringBssEntry, // NOTE: Actual patching is instruction_set-dependent. - kBakerReadBarrierBranch, // NOTE: Actual patching is instruction_set-dependent. - }; - - static LinkerPatch RelativeMethodPatch(size_t literal_offset, - const DexFile* target_dex_file, - uint32_t pc_insn_offset, - uint32_t target_method_idx) { - LinkerPatch patch(literal_offset, Type::kMethodRelative, target_dex_file); - patch.method_idx_ = target_method_idx; - patch.pc_insn_offset_ = pc_insn_offset; - return patch; - } - - static LinkerPatch MethodBssEntryPatch(size_t literal_offset, - const DexFile* target_dex_file, - uint32_t pc_insn_offset, - uint32_t target_method_idx) { - LinkerPatch patch(literal_offset, Type::kMethodBssEntry, target_dex_file); - patch.method_idx_ = target_method_idx; - patch.pc_insn_offset_ = pc_insn_offset; - return patch; - } - - static LinkerPatch CodePatch(size_t literal_offset, - const DexFile* target_dex_file, - uint32_t target_method_idx) { - LinkerPatch patch(literal_offset, Type::kCall, target_dex_file); - patch.method_idx_ = target_method_idx; - return patch; - } - - static LinkerPatch RelativeCodePatch(size_t literal_offset, - const DexFile* target_dex_file, - uint32_t target_method_idx) { - LinkerPatch patch(literal_offset, Type::kCallRelative, target_dex_file); - patch.method_idx_ = target_method_idx; - return patch; - } - - static LinkerPatch RelativeTypePatch(size_t literal_offset, - const DexFile* target_dex_file, - uint32_t pc_insn_offset, - uint32_t target_type_idx) { - LinkerPatch patch(literal_offset, Type::kTypeRelative, target_dex_file); - patch.type_idx_ = target_type_idx; - patch.pc_insn_offset_ = pc_insn_offset; - return patch; - } - - static LinkerPatch TypeClassTablePatch(size_t literal_offset, - const DexFile* target_dex_file, - uint32_t pc_insn_offset, - uint32_t target_type_idx) { - LinkerPatch patch(literal_offset, Type::kTypeClassTable, target_dex_file); - patch.type_idx_ = target_type_idx; - patch.pc_insn_offset_ = pc_insn_offset; - return patch; - } - - static LinkerPatch TypeBssEntryPatch(size_t literal_offset, - const DexFile* target_dex_file, - uint32_t pc_insn_offset, - uint32_t target_type_idx) { - LinkerPatch patch(literal_offset, Type::kTypeBssEntry, target_dex_file); - patch.type_idx_ = target_type_idx; - patch.pc_insn_offset_ = pc_insn_offset; - return patch; - } - - static LinkerPatch RelativeStringPatch(size_t literal_offset, - const DexFile* target_dex_file, - uint32_t pc_insn_offset, - uint32_t target_string_idx) { - LinkerPatch patch(literal_offset, Type::kStringRelative, target_dex_file); - patch.string_idx_ = target_string_idx; - patch.pc_insn_offset_ = pc_insn_offset; - return patch; - } - - static LinkerPatch StringInternTablePatch(size_t literal_offset, - const DexFile* target_dex_file, - uint32_t pc_insn_offset, - uint32_t target_string_idx) { - LinkerPatch patch(literal_offset, Type::kStringInternTable, target_dex_file); - patch.string_idx_ = target_string_idx; - patch.pc_insn_offset_ = pc_insn_offset; - return patch; - } - - static LinkerPatch StringBssEntryPatch(size_t literal_offset, - const DexFile* target_dex_file, - uint32_t pc_insn_offset, - uint32_t target_string_idx) { - LinkerPatch patch(literal_offset, Type::kStringBssEntry, target_dex_file); - patch.string_idx_ = target_string_idx; - patch.pc_insn_offset_ = pc_insn_offset; - return patch; - } - - static LinkerPatch BakerReadBarrierBranchPatch(size_t literal_offset, - uint32_t custom_value1 = 0u, - uint32_t custom_value2 = 0u) { - LinkerPatch patch(literal_offset, Type::kBakerReadBarrierBranch, nullptr); - patch.baker_custom_value1_ = custom_value1; - patch.baker_custom_value2_ = custom_value2; - return patch; - } - - LinkerPatch(const LinkerPatch& other) = default; - LinkerPatch& operator=(const LinkerPatch& other) = default; - - size_t LiteralOffset() const { - return literal_offset_; - } - - Type GetType() const { - return patch_type_; - } - - bool IsPcRelative() const { - switch (GetType()) { - case Type::kMethodRelative: - case Type::kMethodBssEntry: - case Type::kCallRelative: - case Type::kTypeRelative: - case Type::kTypeClassTable: - case Type::kTypeBssEntry: - case Type::kStringRelative: - case Type::kStringInternTable: - case Type::kStringBssEntry: - case Type::kBakerReadBarrierBranch: - return true; - default: - return false; - } - } - - MethodReference TargetMethod() const { - DCHECK(patch_type_ == Type::kMethodRelative || - patch_type_ == Type::kMethodBssEntry || - patch_type_ == Type::kCall || - patch_type_ == Type::kCallRelative); - return MethodReference(target_dex_file_, method_idx_); - } - - const DexFile* TargetTypeDexFile() const { - DCHECK(patch_type_ == Type::kTypeRelative || - patch_type_ == Type::kTypeClassTable || - patch_type_ == Type::kTypeBssEntry); - return target_dex_file_; - } - - dex::TypeIndex TargetTypeIndex() const { - DCHECK(patch_type_ == Type::kTypeRelative || - patch_type_ == Type::kTypeClassTable || - patch_type_ == Type::kTypeBssEntry); - return dex::TypeIndex(type_idx_); - } - - const DexFile* TargetStringDexFile() const { - DCHECK(patch_type_ == Type::kStringRelative || - patch_type_ == Type::kStringInternTable || - patch_type_ == Type::kStringBssEntry); - return target_dex_file_; - } - - dex::StringIndex TargetStringIndex() const { - DCHECK(patch_type_ == Type::kStringRelative || - patch_type_ == Type::kStringInternTable || - patch_type_ == Type::kStringBssEntry); - return dex::StringIndex(string_idx_); - } - - uint32_t PcInsnOffset() const { - DCHECK(patch_type_ == Type::kMethodRelative || - patch_type_ == Type::kMethodBssEntry || - patch_type_ == Type::kTypeRelative || - patch_type_ == Type::kTypeClassTable || - patch_type_ == Type::kTypeBssEntry || - patch_type_ == Type::kStringRelative || - patch_type_ == Type::kStringInternTable || - patch_type_ == Type::kStringBssEntry); - return pc_insn_offset_; - } - - uint32_t GetBakerCustomValue1() const { - DCHECK(patch_type_ == Type::kBakerReadBarrierBranch); - return baker_custom_value1_; - } - - uint32_t GetBakerCustomValue2() const { - DCHECK(patch_type_ == Type::kBakerReadBarrierBranch); - return baker_custom_value2_; - } - - private: - LinkerPatch(size_t literal_offset, Type patch_type, const DexFile* target_dex_file) - : target_dex_file_(target_dex_file), - literal_offset_(literal_offset), - patch_type_(patch_type) { - cmp1_ = 0u; - cmp2_ = 0u; - // The compiler rejects methods that are too big, so the compiled code - // of a single method really shouln't be anywhere close to 16MiB. - DCHECK(IsUint<24>(literal_offset)); - } - - const DexFile* target_dex_file_; - // TODO: Clean up naming. Some patched locations are literals but others are not. - uint32_t literal_offset_ : 24; // Method code size up to 16MiB. - Type patch_type_ : 8; - union { - uint32_t cmp1_; // Used for relational operators. - uint32_t method_idx_; // Method index for Call/Method patches. - uint32_t type_idx_; // Type index for Type patches. - uint32_t string_idx_; // String index for String patches. - uint32_t baker_custom_value1_; - static_assert(sizeof(method_idx_) == sizeof(cmp1_), "needed by relational operators"); - static_assert(sizeof(type_idx_) == sizeof(cmp1_), "needed by relational operators"); - static_assert(sizeof(string_idx_) == sizeof(cmp1_), "needed by relational operators"); - static_assert(sizeof(baker_custom_value1_) == sizeof(cmp1_), "needed by relational operators"); - }; - union { - // Note: To avoid uninitialized padding on 64-bit systems, we use `size_t` for `cmp2_`. - // This allows a hashing function to treat an array of linker patches as raw memory. - size_t cmp2_; // Used for relational operators. - // Literal offset of the insn loading PC (same as literal_offset if it's the same insn, - // may be different if the PC-relative addressing needs multiple insns). - uint32_t pc_insn_offset_; - uint32_t baker_custom_value2_; - static_assert(sizeof(pc_insn_offset_) <= sizeof(cmp2_), "needed by relational operators"); - static_assert(sizeof(baker_custom_value2_) <= sizeof(cmp2_), "needed by relational operators"); - }; - - friend bool operator==(const LinkerPatch& lhs, const LinkerPatch& rhs); - friend bool operator<(const LinkerPatch& lhs, const LinkerPatch& rhs); -}; -std::ostream& operator<<(std::ostream& os, const LinkerPatch::Type& type); - -inline bool operator==(const LinkerPatch& lhs, const LinkerPatch& rhs) { - return lhs.literal_offset_ == rhs.literal_offset_ && - lhs.patch_type_ == rhs.patch_type_ && - lhs.target_dex_file_ == rhs.target_dex_file_ && - lhs.cmp1_ == rhs.cmp1_ && - lhs.cmp2_ == rhs.cmp2_; -} - -inline bool operator<(const LinkerPatch& lhs, const LinkerPatch& rhs) { - return (lhs.literal_offset_ != rhs.literal_offset_) ? lhs.literal_offset_ < rhs.literal_offset_ - : (lhs.patch_type_ != rhs.patch_type_) ? lhs.patch_type_ < rhs.patch_type_ - : (lhs.target_dex_file_ != rhs.target_dex_file_) ? lhs.target_dex_file_ < rhs.target_dex_file_ - : (lhs.cmp1_ != rhs.cmp1_) ? lhs.cmp1_ < rhs.cmp1_ - : lhs.cmp2_ < rhs.cmp2_; -} - class CompiledMethod FINAL : public CompiledCode { public: // Constructs a CompiledMethod. @@ -398,7 +98,7 @@ class CompiledMethod FINAL : public CompiledCode { const ArrayRef<const uint8_t>& method_info, const ArrayRef<const uint8_t>& vmap_table, const ArrayRef<const uint8_t>& cfi_info, - const ArrayRef<const LinkerPatch>& patches); + const ArrayRef<const linker::LinkerPatch>& patches); virtual ~CompiledMethod(); @@ -412,7 +112,7 @@ class CompiledMethod FINAL : public CompiledCode { const ArrayRef<const uint8_t>& method_info, const ArrayRef<const uint8_t>& vmap_table, const ArrayRef<const uint8_t>& cfi_info, - const ArrayRef<const LinkerPatch>& patches); + const ArrayRef<const linker::LinkerPatch>& patches); static void ReleaseSwapAllocatedCompiledMethod(CompilerDriver* driver, CompiledMethod* m); @@ -428,21 +128,13 @@ class CompiledMethod FINAL : public CompiledCode { return fp_spill_mask_; } - ArrayRef<const uint8_t> GetMethodInfo() const { - return GetArray(method_info_); - } + ArrayRef<const uint8_t> GetMethodInfo() const; - ArrayRef<const uint8_t> GetVmapTable() const { - return GetArray(vmap_table_); - } + ArrayRef<const uint8_t> GetVmapTable() const; - ArrayRef<const uint8_t> GetCFIInfo() const { - return GetArray(cfi_info_); - } + ArrayRef<const uint8_t> GetCFIInfo() const; - ArrayRef<const LinkerPatch> GetPatches() const { - return GetArray(patches_); - } + ArrayRef<const linker::LinkerPatch> GetPatches() const; private: // For quick code, the size of the activation used by the code. @@ -458,7 +150,7 @@ class CompiledMethod FINAL : public CompiledCode { // For quick code, a FDE entry for the debug_frame section. const LengthPrefixedArray<uint8_t>* const cfi_info_; // For quick code, linker patches needed by the method. - const LengthPrefixedArray<LinkerPatch>* const patches_; + const LengthPrefixedArray<linker::LinkerPatch>* const patches_; }; } // namespace art diff --git a/compiler/debug/elf_debug_line_writer.h b/compiler/debug/elf_debug_line_writer.h index cf5d65efac..49d52c45c2 100644 --- a/compiler/debug/elf_debug_line_writer.h +++ b/compiler/debug/elf_debug_line_writer.h @@ -20,10 +20,10 @@ #include <unordered_set> #include <vector> -#include "compiled_method.h" #include "debug/dwarf/debug_line_opcode_writer.h" #include "debug/dwarf/headers.h" #include "debug/elf_compilation_unit.h" +#include "debug/src_map_elem.h" #include "dex_file-inl.h" #include "linker/elf_builder.h" #include "stack_map.h" diff --git a/compiler/debug/method_debug_info.h b/compiler/debug/method_debug_info.h index 567891087a..a8225fa2b4 100644 --- a/compiler/debug/method_debug_info.h +++ b/compiler/debug/method_debug_info.h @@ -19,7 +19,8 @@ #include <string> -#include "compiled_method.h" +#include "arch/instruction_set.h" +#include "base/array_ref.h" #include "dex_file.h" namespace art { diff --git a/compiler/debug/src_map_elem.h b/compiler/debug/src_map_elem.h new file mode 100644 index 0000000000..5286b8c4dc --- /dev/null +++ b/compiler/debug/src_map_elem.h @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2017 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. + */ + +#ifndef ART_COMPILER_DEBUG_SRC_MAP_ELEM_H_ +#define ART_COMPILER_DEBUG_SRC_MAP_ELEM_H_ + +#include <stdint.h> + +namespace art { + +class SrcMapElem { + public: + uint32_t from_; + int32_t to_; +}; + +inline bool operator<(const SrcMapElem& lhs, const SrcMapElem& rhs) { + if (lhs.from_ != rhs.from_) { + return lhs.from_ < rhs.from_; + } + return lhs.to_ < rhs.to_; +} + +inline bool operator==(const SrcMapElem& lhs, const SrcMapElem& rhs) { + return lhs.from_ == rhs.from_ && lhs.to_ == rhs.to_; +} + +} // namespace art + +#endif // ART_COMPILER_DEBUG_SRC_MAP_ELEM_H_ diff --git a/compiler/debug/src_map_elem_test.cc b/compiler/debug/src_map_elem_test.cc new file mode 100644 index 0000000000..ceaa53fa99 --- /dev/null +++ b/compiler/debug/src_map_elem_test.cc @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2017 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 <gtest/gtest.h> + +#include "src_map_elem.h" + +#include "base/macros.h" + +namespace art { +namespace debug { + +TEST(SrcMapElem, Operators) { + SrcMapElem elems[] = { + { 1u, -1 }, + { 1u, 0 }, + { 1u, 1 }, + { 2u, -1 }, + { 2u, 0 }, // Index 4. + { 2u, 1 }, + { 2u, 0u }, // Index 6: Arbitrarily add identical SrcMapElem with index 4. + }; + + for (size_t i = 0; i != arraysize(elems); ++i) { + for (size_t j = 0; j != arraysize(elems); ++j) { + bool expected = (i != 6u ? i : 4u) == (j != 6u ? j : 4u); + EXPECT_EQ(expected, elems[i] == elems[j]) << i << " " << j; + } + } + + for (size_t i = 0; i != arraysize(elems); ++i) { + for (size_t j = 0; j != arraysize(elems); ++j) { + bool expected = (i != 6u ? i : 4u) < (j != 6u ? j : 4u); + EXPECT_EQ(expected, elems[i] < elems[j]) << i << " " << j; + } + } +} + +} // namespace debug +} // namespace art diff --git a/compiler/dex/dex_to_dex_compiler.cc b/compiler/dex/dex_to_dex_compiler.cc index 9d57b965ab..e49f83f943 100644 --- a/compiler/dex/dex_to_dex_compiler.cc +++ b/compiler/dex/dex_to_dex_compiler.cc @@ -395,7 +395,7 @@ CompiledMethod* ArtCompileDEX( ArrayRef<const uint8_t>(), // method_info ArrayRef<const uint8_t>(quicken_data), // vmap_table ArrayRef<const uint8_t>(), // cfi data - ArrayRef<const LinkerPatch>()); + ArrayRef<const linker::LinkerPatch>()); } return nullptr; } diff --git a/compiler/dex/dex_to_dex_decompiler_test.cc b/compiler/dex/dex_to_dex_decompiler_test.cc index e36d416e9f..6637be2811 100644 --- a/compiler/dex/dex_to_dex_decompiler_test.cc +++ b/compiler/dex/dex_to_dex_decompiler_test.cc @@ -18,7 +18,7 @@ #include "class_linker.h" #include "common_compiler_test.h" -#include "compiled_method.h" +#include "compiled_method-inl.h" #include "compiler_callbacks.h" #include "dex_file.h" #include "driver/compiler_driver.h" diff --git a/compiler/driver/compiled_method_storage.cc b/compiler/driver/compiled_method_storage.cc index 528b0a215b..c739333cee 100644 --- a/compiler/driver/compiled_method_storage.cc +++ b/compiler/driver/compiled_method_storage.cc @@ -21,6 +21,7 @@ #include "base/logging.h" #include "compiled_method.h" +#include "linker/linker_patch.h" #include "thread-current-inl.h" #include "utils.h" #include "utils/dedupe_set-inl.h" @@ -178,7 +179,7 @@ CompiledMethodStorage::CompiledMethodStorage(int swap_fd) LengthPrefixedArrayAlloc<uint8_t>(swap_space_.get())), dedupe_cfi_info_("dedupe cfi info", LengthPrefixedArrayAlloc<uint8_t>(swap_space_.get())), dedupe_linker_patches_("dedupe cfi info", - LengthPrefixedArrayAlloc<LinkerPatch>(swap_space_.get())) { + LengthPrefixedArrayAlloc<linker::LinkerPatch>(swap_space_.get())) { } CompiledMethodStorage::~CompiledMethodStorage() { @@ -234,13 +235,13 @@ void CompiledMethodStorage::ReleaseCFIInfo(const LengthPrefixedArray<uint8_t>* c ReleaseArrayIfNotDeduplicated(cfi_info); } -const LengthPrefixedArray<LinkerPatch>* CompiledMethodStorage::DeduplicateLinkerPatches( - const ArrayRef<const LinkerPatch>& linker_patches) { +const LengthPrefixedArray<linker::LinkerPatch>* CompiledMethodStorage::DeduplicateLinkerPatches( + const ArrayRef<const linker::LinkerPatch>& linker_patches) { return AllocateOrDeduplicateArray(linker_patches, &dedupe_linker_patches_); } void CompiledMethodStorage::ReleaseLinkerPatches( - const LengthPrefixedArray<LinkerPatch>* linker_patches) { + const LengthPrefixedArray<linker::LinkerPatch>* linker_patches) { ReleaseArrayIfNotDeduplicated(linker_patches); } diff --git a/compiler/driver/compiled_method_storage.h b/compiler/driver/compiled_method_storage.h index 27011e8955..249f06c20f 100644 --- a/compiler/driver/compiled_method_storage.h +++ b/compiler/driver/compiled_method_storage.h @@ -28,7 +28,9 @@ namespace art { +namespace linker { class LinkerPatch; +} // namespace linker class CompiledMethodStorage { public: @@ -61,9 +63,9 @@ class CompiledMethodStorage { const LengthPrefixedArray<uint8_t>* DeduplicateCFIInfo(const ArrayRef<const uint8_t>& cfi_info); void ReleaseCFIInfo(const LengthPrefixedArray<uint8_t>* cfi_info); - const LengthPrefixedArray<LinkerPatch>* DeduplicateLinkerPatches( - const ArrayRef<const LinkerPatch>& linker_patches); - void ReleaseLinkerPatches(const LengthPrefixedArray<LinkerPatch>* linker_patches); + const LengthPrefixedArray<linker::LinkerPatch>* DeduplicateLinkerPatches( + const ArrayRef<const linker::LinkerPatch>& linker_patches); + void ReleaseLinkerPatches(const LengthPrefixedArray<linker::LinkerPatch>* linker_patches); private: template <typename T, typename DedupeSetType> @@ -98,7 +100,7 @@ class CompiledMethodStorage { ArrayDedupeSet<uint8_t> dedupe_method_info_; ArrayDedupeSet<uint8_t> dedupe_vmap_table_; ArrayDedupeSet<uint8_t> dedupe_cfi_info_; - ArrayDedupeSet<LinkerPatch> dedupe_linker_patches_; + ArrayDedupeSet<linker::LinkerPatch> dedupe_linker_patches_; DISALLOW_COPY_AND_ASSIGN(CompiledMethodStorage); }; diff --git a/compiler/driver/compiled_method_storage_test.cc b/compiler/driver/compiled_method_storage_test.cc index 2ec2af587e..e1ea6304eb 100644 --- a/compiler/driver/compiled_method_storage_test.cc +++ b/compiler/driver/compiled_method_storage_test.cc @@ -18,7 +18,7 @@ #include <gtest/gtest.h> -#include "compiled_method.h" +#include "compiled_method-inl.h" #include "compiler_driver.h" #include "compiler_options.h" #include "dex/verification_results.h" @@ -70,17 +70,17 @@ TEST(CompiledMethodStorage, Deduplicate) { ArrayRef<const uint8_t>(raw_cfi_info1), ArrayRef<const uint8_t>(raw_cfi_info2), }; - const LinkerPatch raw_patches1[] = { - LinkerPatch::CodePatch(0u, nullptr, 1u), - LinkerPatch::RelativeMethodPatch(4u, nullptr, 0u, 1u), + const linker::LinkerPatch raw_patches1[] = { + linker::LinkerPatch::CodePatch(0u, nullptr, 1u), + linker::LinkerPatch::RelativeMethodPatch(4u, nullptr, 0u, 1u), }; - const LinkerPatch raw_patches2[] = { - LinkerPatch::CodePatch(0u, nullptr, 1u), - LinkerPatch::RelativeMethodPatch(4u, nullptr, 0u, 2u), + const linker::LinkerPatch raw_patches2[] = { + linker::LinkerPatch::CodePatch(0u, nullptr, 1u), + linker::LinkerPatch::RelativeMethodPatch(4u, nullptr, 0u, 2u), }; - ArrayRef<const LinkerPatch> patches[] = { - ArrayRef<const LinkerPatch>(raw_patches1), - ArrayRef<const LinkerPatch>(raw_patches2), + ArrayRef<const linker::LinkerPatch> patches[] = { + ArrayRef<const linker::LinkerPatch>(raw_patches1), + ArrayRef<const linker::LinkerPatch>(raw_patches2), }; std::vector<CompiledMethod*> compiled_methods; diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc index 678f090532..03d8ef5915 100644 --- a/compiler/driver/compiler_driver.cc +++ b/compiler/driver/compiler_driver.cc @@ -37,7 +37,7 @@ #include "base/time_utils.h" #include "base/timing_logger.h" #include "class_linker-inl.h" -#include "compiled_method.h" +#include "compiled_method-inl.h" #include "compiler.h" #include "compiler_callbacks.h" #include "compiler_driver-inl.h" @@ -55,6 +55,7 @@ #include "handle_scope-inl.h" #include "intrinsics_enum.h" #include "jni_internal.h" +#include "linker/linker_patch.h" #include "mirror/class-inl.h" #include "mirror/class_loader.h" #include "mirror/dex_cache-inl.h" @@ -618,7 +619,7 @@ static void CompileMethod(Thread* self, if (compiled_method != nullptr) { // Count non-relative linker patches. size_t non_relative_linker_patch_count = 0u; - for (const LinkerPatch& patch : compiled_method->GetPatches()) { + for (const linker::LinkerPatch& patch : compiled_method->GetPatches()) { if (!patch.IsPcRelative()) { ++non_relative_linker_patch_count; } diff --git a/compiler/jni/quick/jni_compiler.cc b/compiler/jni/quick/jni_compiler.cc index e7e4647866..c66a2a62eb 100644 --- a/compiler/jni/quick/jni_compiler.cc +++ b/compiler/jni/quick/jni_compiler.cc @@ -665,7 +665,7 @@ static CompiledMethod* ArtJniCompileMethodInternal(CompilerDriver* driver, /* method_info */ ArrayRef<const uint8_t>(), /* vmap_table */ ArrayRef<const uint8_t>(), ArrayRef<const uint8_t>(*jni_asm->cfi().data()), - ArrayRef<const LinkerPatch>()); + ArrayRef<const linker::LinkerPatch>()); } // Copy a single parameter from the managed to the JNI calling convention. diff --git a/compiler/linker/arm/relative_patcher_arm_base.cc b/compiler/linker/arm/relative_patcher_arm_base.cc index cb6522cbbb..2cb23d1710 100644 --- a/compiler/linker/arm/relative_patcher_arm_base.cc +++ b/compiler/linker/arm/relative_patcher_arm_base.cc @@ -17,9 +17,10 @@ #include "linker/arm/relative_patcher_arm_base.h" #include "base/stl_util.h" -#include "compiled_method.h" +#include "compiled_method-inl.h" #include "debug/method_debug_info.h" #include "dex_file_types.h" +#include "linker/linker_patch.h" #include "linker/output_stream.h" #include "oat.h" #include "oat_quick_method_header.h" diff --git a/compiler/linker/arm/relative_patcher_thumb2.cc b/compiler/linker/arm/relative_patcher_thumb2.cc index 704feeb387..f84fea378d 100644 --- a/compiler/linker/arm/relative_patcher_thumb2.cc +++ b/compiler/linker/arm/relative_patcher_thumb2.cc @@ -21,6 +21,7 @@ #include "base/bit_utils.h" #include "compiled_method.h" #include "entrypoints/quick/quick_entrypoints_enum.h" +#include "linker/linker_patch.h" #include "lock_word.h" #include "mirror/array-inl.h" #include "mirror/object.h" diff --git a/compiler/linker/arm64/relative_patcher_arm64.cc b/compiler/linker/arm64/relative_patcher_arm64.cc index 82f502a3af..828c99ba86 100644 --- a/compiler/linker/arm64/relative_patcher_arm64.cc +++ b/compiler/linker/arm64/relative_patcher_arm64.cc @@ -20,10 +20,11 @@ #include "arch/arm64/instruction_set_features_arm64.h" #include "art_method.h" #include "base/bit_utils.h" -#include "compiled_method.h" +#include "compiled_method-inl.h" #include "driver/compiler_driver.h" #include "entrypoints/quick/quick_entrypoints_enum.h" #include "heap_poisoning.h" +#include "linker/linker_patch.h" #include "linker/output_stream.h" #include "lock_word.h" #include "mirror/array-inl.h" diff --git a/compiler/linker/linker_patch.h b/compiler/linker/linker_patch.h new file mode 100644 index 0000000000..0ac149029a --- /dev/null +++ b/compiler/linker/linker_patch.h @@ -0,0 +1,311 @@ +/* + * Copyright (C) 2017 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. + */ + +#ifndef ART_COMPILER_LINKER_LINKER_PATCH_H_ +#define ART_COMPILER_LINKER_LINKER_PATCH_H_ + +#include <iosfwd> +#include <stdint.h> + +#include "base/bit_utils.h" +#include "base/logging.h" +#include "method_reference.h" + +namespace art { + +class DexFile; + +namespace linker { + +class LinkerPatch { + public: + // Note: We explicitly specify the underlying type of the enum because GCC + // would otherwise select a bigger underlying type and then complain that + // 'art::LinkerPatch::patch_type_' is too small to hold all + // values of 'enum class art::LinkerPatch::Type' + // which is ridiculous given we have only a handful of values here. If we + // choose to squeeze the Type into fewer than 8 bits, we'll have to declare + // patch_type_ as an uintN_t and do explicit static_cast<>s. + enum class Type : uint8_t { + kMethodRelative, // NOTE: Actual patching is instruction_set-dependent. + kMethodBssEntry, // NOTE: Actual patching is instruction_set-dependent. + kCall, + kCallRelative, // NOTE: Actual patching is instruction_set-dependent. + kTypeRelative, // NOTE: Actual patching is instruction_set-dependent. + kTypeClassTable, // NOTE: Actual patching is instruction_set-dependent. + kTypeBssEntry, // NOTE: Actual patching is instruction_set-dependent. + kStringRelative, // NOTE: Actual patching is instruction_set-dependent. + kStringInternTable, // NOTE: Actual patching is instruction_set-dependent. + kStringBssEntry, // NOTE: Actual patching is instruction_set-dependent. + kBakerReadBarrierBranch, // NOTE: Actual patching is instruction_set-dependent. + }; + + static LinkerPatch RelativeMethodPatch(size_t literal_offset, + const DexFile* target_dex_file, + uint32_t pc_insn_offset, + uint32_t target_method_idx) { + LinkerPatch patch(literal_offset, Type::kMethodRelative, target_dex_file); + patch.method_idx_ = target_method_idx; + patch.pc_insn_offset_ = pc_insn_offset; + return patch; + } + + static LinkerPatch MethodBssEntryPatch(size_t literal_offset, + const DexFile* target_dex_file, + uint32_t pc_insn_offset, + uint32_t target_method_idx) { + LinkerPatch patch(literal_offset, Type::kMethodBssEntry, target_dex_file); + patch.method_idx_ = target_method_idx; + patch.pc_insn_offset_ = pc_insn_offset; + return patch; + } + + static LinkerPatch CodePatch(size_t literal_offset, + const DexFile* target_dex_file, + uint32_t target_method_idx) { + LinkerPatch patch(literal_offset, Type::kCall, target_dex_file); + patch.method_idx_ = target_method_idx; + return patch; + } + + static LinkerPatch RelativeCodePatch(size_t literal_offset, + const DexFile* target_dex_file, + uint32_t target_method_idx) { + LinkerPatch patch(literal_offset, Type::kCallRelative, target_dex_file); + patch.method_idx_ = target_method_idx; + return patch; + } + + static LinkerPatch RelativeTypePatch(size_t literal_offset, + const DexFile* target_dex_file, + uint32_t pc_insn_offset, + uint32_t target_type_idx) { + LinkerPatch patch(literal_offset, Type::kTypeRelative, target_dex_file); + patch.type_idx_ = target_type_idx; + patch.pc_insn_offset_ = pc_insn_offset; + return patch; + } + + static LinkerPatch TypeClassTablePatch(size_t literal_offset, + const DexFile* target_dex_file, + uint32_t pc_insn_offset, + uint32_t target_type_idx) { + LinkerPatch patch(literal_offset, Type::kTypeClassTable, target_dex_file); + patch.type_idx_ = target_type_idx; + patch.pc_insn_offset_ = pc_insn_offset; + return patch; + } + + static LinkerPatch TypeBssEntryPatch(size_t literal_offset, + const DexFile* target_dex_file, + uint32_t pc_insn_offset, + uint32_t target_type_idx) { + LinkerPatch patch(literal_offset, Type::kTypeBssEntry, target_dex_file); + patch.type_idx_ = target_type_idx; + patch.pc_insn_offset_ = pc_insn_offset; + return patch; + } + + static LinkerPatch RelativeStringPatch(size_t literal_offset, + const DexFile* target_dex_file, + uint32_t pc_insn_offset, + uint32_t target_string_idx) { + LinkerPatch patch(literal_offset, Type::kStringRelative, target_dex_file); + patch.string_idx_ = target_string_idx; + patch.pc_insn_offset_ = pc_insn_offset; + return patch; + } + + static LinkerPatch StringInternTablePatch(size_t literal_offset, + const DexFile* target_dex_file, + uint32_t pc_insn_offset, + uint32_t target_string_idx) { + LinkerPatch patch(literal_offset, Type::kStringInternTable, target_dex_file); + patch.string_idx_ = target_string_idx; + patch.pc_insn_offset_ = pc_insn_offset; + return patch; + } + + static LinkerPatch StringBssEntryPatch(size_t literal_offset, + const DexFile* target_dex_file, + uint32_t pc_insn_offset, + uint32_t target_string_idx) { + LinkerPatch patch(literal_offset, Type::kStringBssEntry, target_dex_file); + patch.string_idx_ = target_string_idx; + patch.pc_insn_offset_ = pc_insn_offset; + return patch; + } + + static LinkerPatch BakerReadBarrierBranchPatch(size_t literal_offset, + uint32_t custom_value1 = 0u, + uint32_t custom_value2 = 0u) { + LinkerPatch patch(literal_offset, Type::kBakerReadBarrierBranch, nullptr); + patch.baker_custom_value1_ = custom_value1; + patch.baker_custom_value2_ = custom_value2; + return patch; + } + + LinkerPatch(const LinkerPatch& other) = default; + LinkerPatch& operator=(const LinkerPatch& other) = default; + + size_t LiteralOffset() const { + return literal_offset_; + } + + Type GetType() const { + return patch_type_; + } + + bool IsPcRelative() const { + switch (GetType()) { + case Type::kMethodRelative: + case Type::kMethodBssEntry: + case Type::kCallRelative: + case Type::kTypeRelative: + case Type::kTypeClassTable: + case Type::kTypeBssEntry: + case Type::kStringRelative: + case Type::kStringInternTable: + case Type::kStringBssEntry: + case Type::kBakerReadBarrierBranch: + return true; + default: + return false; + } + } + + MethodReference TargetMethod() const { + DCHECK(patch_type_ == Type::kMethodRelative || + patch_type_ == Type::kMethodBssEntry || + patch_type_ == Type::kCall || + patch_type_ == Type::kCallRelative); + return MethodReference(target_dex_file_, method_idx_); + } + + const DexFile* TargetTypeDexFile() const { + DCHECK(patch_type_ == Type::kTypeRelative || + patch_type_ == Type::kTypeClassTable || + patch_type_ == Type::kTypeBssEntry); + return target_dex_file_; + } + + dex::TypeIndex TargetTypeIndex() const { + DCHECK(patch_type_ == Type::kTypeRelative || + patch_type_ == Type::kTypeClassTable || + patch_type_ == Type::kTypeBssEntry); + return dex::TypeIndex(type_idx_); + } + + const DexFile* TargetStringDexFile() const { + DCHECK(patch_type_ == Type::kStringRelative || + patch_type_ == Type::kStringInternTable || + patch_type_ == Type::kStringBssEntry); + return target_dex_file_; + } + + dex::StringIndex TargetStringIndex() const { + DCHECK(patch_type_ == Type::kStringRelative || + patch_type_ == Type::kStringInternTable || + patch_type_ == Type::kStringBssEntry); + return dex::StringIndex(string_idx_); + } + + uint32_t PcInsnOffset() const { + DCHECK(patch_type_ == Type::kMethodRelative || + patch_type_ == Type::kMethodBssEntry || + patch_type_ == Type::kTypeRelative || + patch_type_ == Type::kTypeClassTable || + patch_type_ == Type::kTypeBssEntry || + patch_type_ == Type::kStringRelative || + patch_type_ == Type::kStringInternTable || + patch_type_ == Type::kStringBssEntry); + return pc_insn_offset_; + } + + uint32_t GetBakerCustomValue1() const { + DCHECK(patch_type_ == Type::kBakerReadBarrierBranch); + return baker_custom_value1_; + } + + uint32_t GetBakerCustomValue2() const { + DCHECK(patch_type_ == Type::kBakerReadBarrierBranch); + return baker_custom_value2_; + } + + private: + LinkerPatch(size_t literal_offset, Type patch_type, const DexFile* target_dex_file) + : target_dex_file_(target_dex_file), + literal_offset_(literal_offset), + patch_type_(patch_type) { + cmp1_ = 0u; + cmp2_ = 0u; + // The compiler rejects methods that are too big, so the compiled code + // of a single method really shouln't be anywhere close to 16MiB. + DCHECK(IsUint<24>(literal_offset)); + } + + const DexFile* target_dex_file_; + // TODO: Clean up naming. Some patched locations are literals but others are not. + uint32_t literal_offset_ : 24; // Method code size up to 16MiB. + Type patch_type_ : 8; + union { + uint32_t cmp1_; // Used for relational operators. + uint32_t method_idx_; // Method index for Call/Method patches. + uint32_t type_idx_; // Type index for Type patches. + uint32_t string_idx_; // String index for String patches. + uint32_t baker_custom_value1_; + static_assert(sizeof(method_idx_) == sizeof(cmp1_), "needed by relational operators"); + static_assert(sizeof(type_idx_) == sizeof(cmp1_), "needed by relational operators"); + static_assert(sizeof(string_idx_) == sizeof(cmp1_), "needed by relational operators"); + static_assert(sizeof(baker_custom_value1_) == sizeof(cmp1_), "needed by relational operators"); + }; + union { + // Note: To avoid uninitialized padding on 64-bit systems, we use `size_t` for `cmp2_`. + // This allows a hashing function to treat an array of linker patches as raw memory. + size_t cmp2_; // Used for relational operators. + // Literal offset of the insn loading PC (same as literal_offset if it's the same insn, + // may be different if the PC-relative addressing needs multiple insns). + uint32_t pc_insn_offset_; + uint32_t baker_custom_value2_; + static_assert(sizeof(pc_insn_offset_) <= sizeof(cmp2_), "needed by relational operators"); + static_assert(sizeof(baker_custom_value2_) <= sizeof(cmp2_), "needed by relational operators"); + }; + + friend bool operator==(const LinkerPatch& lhs, const LinkerPatch& rhs); + friend bool operator<(const LinkerPatch& lhs, const LinkerPatch& rhs); +}; +std::ostream& operator<<(std::ostream& os, const LinkerPatch::Type& type); + +inline bool operator==(const LinkerPatch& lhs, const LinkerPatch& rhs) { + return lhs.literal_offset_ == rhs.literal_offset_ && + lhs.patch_type_ == rhs.patch_type_ && + lhs.target_dex_file_ == rhs.target_dex_file_ && + lhs.cmp1_ == rhs.cmp1_ && + lhs.cmp2_ == rhs.cmp2_; +} + +inline bool operator<(const LinkerPatch& lhs, const LinkerPatch& rhs) { + return (lhs.literal_offset_ != rhs.literal_offset_) ? lhs.literal_offset_ < rhs.literal_offset_ + : (lhs.patch_type_ != rhs.patch_type_) ? lhs.patch_type_ < rhs.patch_type_ + : (lhs.target_dex_file_ != rhs.target_dex_file_) ? lhs.target_dex_file_ < rhs.target_dex_file_ + : (lhs.cmp1_ != rhs.cmp1_) ? lhs.cmp1_ < rhs.cmp1_ + : lhs.cmp2_ < rhs.cmp2_; +} + +} // namespace linker +} // namespace art + +#endif // ART_COMPILER_LINKER_LINKER_PATCH_H_ diff --git a/compiler/compiled_method_test.cc b/compiler/linker/linker_patch_test.cc index f4a72cf2cc..e87dc8de6b 100644 --- a/compiler/compiled_method_test.cc +++ b/compiler/linker/linker_patch_test.cc @@ -1,5 +1,5 @@ /* - * Copyright (C) 2015 The Android Open Source Project + * Copyright (C) 2017 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. @@ -16,37 +16,12 @@ #include <gtest/gtest.h> -#include "compiled_method.h" +#include "linker_patch.h" namespace art { +namespace linker { -TEST(CompiledMethod, SrcMapElemOperators) { - SrcMapElem elems[] = { - { 1u, -1 }, - { 1u, 0 }, - { 1u, 1 }, - { 2u, -1 }, - { 2u, 0 }, // Index 4. - { 2u, 1 }, - { 2u, 0u }, // Index 6: Arbitrarily add identical SrcMapElem with index 4. - }; - - for (size_t i = 0; i != arraysize(elems); ++i) { - for (size_t j = 0; j != arraysize(elems); ++j) { - bool expected = (i != 6u ? i : 4u) == (j != 6u ? j : 4u); - EXPECT_EQ(expected, elems[i] == elems[j]) << i << " " << j; - } - } - - for (size_t i = 0; i != arraysize(elems); ++i) { - for (size_t j = 0; j != arraysize(elems); ++j) { - bool expected = (i != 6u ? i : 4u) < (j != 6u ? j : 4u); - EXPECT_EQ(expected, elems[i] < elems[j]) << i << " " << j; - } - } -} - -TEST(CompiledMethod, LinkerPatchOperators) { +TEST(LinkerPatch, LinkerPatchOperators) { const DexFile* dex_file1 = reinterpret_cast<const DexFile*>(1); const DexFile* dex_file2 = reinterpret_cast<const DexFile*>(2); LinkerPatch patches[] = { @@ -191,4 +166,5 @@ TEST(CompiledMethod, LinkerPatchOperators) { } } +} // namespace linker } // namespace art diff --git a/compiler/linker/mips/relative_patcher_mips.cc b/compiler/linker/mips/relative_patcher_mips.cc index 408ac22976..69e0846cb7 100644 --- a/compiler/linker/mips/relative_patcher_mips.cc +++ b/compiler/linker/mips/relative_patcher_mips.cc @@ -18,6 +18,7 @@ #include "compiled_method.h" #include "debug/method_debug_info.h" +#include "linker/linker_patch.h" namespace art { namespace linker { diff --git a/compiler/linker/mips64/relative_patcher_mips64.cc b/compiler/linker/mips64/relative_patcher_mips64.cc index 2bcd98a2b0..aae5746278 100644 --- a/compiler/linker/mips64/relative_patcher_mips64.cc +++ b/compiler/linker/mips64/relative_patcher_mips64.cc @@ -18,6 +18,7 @@ #include "compiled_method.h" #include "debug/method_debug_info.h" +#include "linker/linker_patch.h" namespace art { namespace linker { diff --git a/compiler/linker/relative_patcher.h b/compiler/linker/relative_patcher.h index e079946e71..548e12896a 100644 --- a/compiler/linker/relative_patcher.h +++ b/compiler/linker/relative_patcher.h @@ -28,7 +28,6 @@ namespace art { class CompiledMethod; -class LinkerPatch; namespace debug { struct MethodDebugInfo; @@ -36,6 +35,7 @@ struct MethodDebugInfo; namespace linker { +class LinkerPatch; class OutputStream; /** diff --git a/compiler/linker/relative_patcher_test.h b/compiler/linker/relative_patcher_test.h index f7dbc1ef1c..6297dd0481 100644 --- a/compiler/linker/relative_patcher_test.h +++ b/compiler/linker/relative_patcher_test.h @@ -21,7 +21,7 @@ #include "arch/instruction_set_features.h" #include "base/array_ref.h" #include "base/macros.h" -#include "compiled_method.h" +#include "compiled_method-inl.h" #include "dex/verification_results.h" #include "driver/compiler_driver.h" #include "driver/compiler_options.h" diff --git a/compiler/linker/x86/relative_patcher_x86.cc b/compiler/linker/x86/relative_patcher_x86.cc index 6967b0b6c2..cdd2cef13a 100644 --- a/compiler/linker/x86/relative_patcher_x86.cc +++ b/compiler/linker/x86/relative_patcher_x86.cc @@ -17,6 +17,7 @@ #include "linker/x86/relative_patcher_x86.h" #include "compiled_method.h" +#include "linker/linker_patch.h" namespace art { namespace linker { diff --git a/compiler/linker/x86_64/relative_patcher_x86_64.cc b/compiler/linker/x86_64/relative_patcher_x86_64.cc index 156ece9909..9633564999 100644 --- a/compiler/linker/x86_64/relative_patcher_x86_64.cc +++ b/compiler/linker/x86_64/relative_patcher_x86_64.cc @@ -17,6 +17,7 @@ #include "linker/x86_64/relative_patcher_x86_64.h" #include "compiled_method.h" +#include "linker/linker_patch.h" namespace art { namespace linker { diff --git a/compiler/optimizing/code_generator.cc b/compiler/optimizing/code_generator.cc index 1e5f1ec00f..6533e2b9f7 100644 --- a/compiler/optimizing/code_generator.cc +++ b/compiler/optimizing/code_generator.cc @@ -288,7 +288,8 @@ void CodeGenerator::Finalize(CodeAllocator* allocator) { GetAssembler()->FinalizeInstructions(code); } -void CodeGenerator::EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_patches ATTRIBUTE_UNUSED) { +void CodeGenerator::EmitLinkerPatches( + ArenaVector<linker::LinkerPatch>* linker_patches ATTRIBUTE_UNUSED) { // No linker patches by default. } diff --git a/compiler/optimizing/code_generator.h b/compiler/optimizing/code_generator.h index 30c2b52242..4b4abdfaa3 100644 --- a/compiler/optimizing/code_generator.h +++ b/compiler/optimizing/code_generator.h @@ -61,9 +61,12 @@ class Assembler; class CodeGenerator; class CompilerDriver; class CompilerOptions; -class LinkerPatch; class ParallelMoveResolver; +namespace linker { +class LinkerPatch; +} // namespace linker + class CodeAllocator { public: CodeAllocator() {} @@ -205,7 +208,7 @@ class CodeGenerator : public DeletableArenaObject<kArenaAllocCodeGenerator> { virtual void Initialize() = 0; virtual void Finalize(CodeAllocator* allocator); - virtual void EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_patches); + virtual void EmitLinkerPatches(ArenaVector<linker::LinkerPatch>* linker_patches); virtual void GenerateFrameEntry() = 0; virtual void GenerateFrameExit() = 0; virtual void Bind(HBasicBlock* block) = 0; diff --git a/compiler/optimizing/code_generator_arm64.cc b/compiler/optimizing/code_generator_arm64.cc index 8814cfc251..aaea7c1025 100644 --- a/compiler/optimizing/code_generator_arm64.cc +++ b/compiler/optimizing/code_generator_arm64.cc @@ -31,6 +31,7 @@ #include "intrinsics.h" #include "intrinsics_arm64.h" #include "linker/arm64/relative_patcher_arm64.h" +#include "linker/linker_patch.h" #include "lock_word.h" #include "mirror/array-inl.h" #include "mirror/class-inl.h" @@ -4754,10 +4755,10 @@ void CodeGeneratorARM64::EmitLdrOffsetPlaceholder(vixl::aarch64::Label* fixup_la __ ldr(out, MemOperand(base, /* offset placeholder */ 0)); } -template <LinkerPatch (*Factory)(size_t, const DexFile*, uint32_t, uint32_t)> +template <linker::LinkerPatch (*Factory)(size_t, const DexFile*, uint32_t, uint32_t)> inline void CodeGeneratorARM64::EmitPcRelativeLinkerPatches( const ArenaDeque<PcRelativePatchInfo>& infos, - ArenaVector<LinkerPatch>* linker_patches) { + ArenaVector<linker::LinkerPatch>* linker_patches) { for (const PcRelativePatchInfo& info : infos) { linker_patches->push_back(Factory(info.label.GetLocation(), &info.target_dex_file, @@ -4766,7 +4767,7 @@ inline void CodeGeneratorARM64::EmitPcRelativeLinkerPatches( } } -void CodeGeneratorARM64::EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_patches) { +void CodeGeneratorARM64::EmitLinkerPatches(ArenaVector<linker::LinkerPatch>* linker_patches) { DCHECK(linker_patches->empty()); size_t size = pc_relative_method_patches_.size() + @@ -4778,28 +4779,28 @@ void CodeGeneratorARM64::EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_patc baker_read_barrier_patches_.size(); linker_patches->reserve(size); if (GetCompilerOptions().IsBootImage()) { - EmitPcRelativeLinkerPatches<LinkerPatch::RelativeMethodPatch>(pc_relative_method_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::RelativeTypePatch>(pc_relative_type_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::RelativeStringPatch>(pc_relative_string_patches_, - linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::RelativeMethodPatch>( + pc_relative_method_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::RelativeTypePatch>( + pc_relative_type_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::RelativeStringPatch>( + pc_relative_string_patches_, linker_patches); } else { DCHECK(pc_relative_method_patches_.empty()); - EmitPcRelativeLinkerPatches<LinkerPatch::TypeClassTablePatch>(pc_relative_type_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::StringInternTablePatch>(pc_relative_string_patches_, - linker_patches); - } - EmitPcRelativeLinkerPatches<LinkerPatch::MethodBssEntryPatch>(method_bss_entry_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::TypeBssEntryPatch>(type_bss_entry_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::StringBssEntryPatch>(string_bss_entry_patches_, - linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::TypeClassTablePatch>( + pc_relative_type_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::StringInternTablePatch>( + pc_relative_string_patches_, linker_patches); + } + EmitPcRelativeLinkerPatches<linker::LinkerPatch::MethodBssEntryPatch>( + method_bss_entry_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::TypeBssEntryPatch>( + type_bss_entry_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::StringBssEntryPatch>( + string_bss_entry_patches_, linker_patches); for (const BakerReadBarrierPatchInfo& info : baker_read_barrier_patches_) { - linker_patches->push_back(LinkerPatch::BakerReadBarrierBranchPatch(info.label.GetLocation(), - info.custom_data)); + linker_patches->push_back(linker::LinkerPatch::BakerReadBarrierBranchPatch( + info.label.GetLocation(), info.custom_data)); } DCHECK_EQ(size, linker_patches->size()); } diff --git a/compiler/optimizing/code_generator_arm64.h b/compiler/optimizing/code_generator_arm64.h index 69c511907e..cebdaa102c 100644 --- a/compiler/optimizing/code_generator_arm64.h +++ b/compiler/optimizing/code_generator_arm64.h @@ -627,7 +627,7 @@ class CodeGeneratorARM64 : public CodeGenerator { vixl::aarch64::Register out, vixl::aarch64::Register base); - void EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_patches) OVERRIDE; + void EmitLinkerPatches(ArenaVector<linker::LinkerPatch>* linker_patches) OVERRIDE; void EmitJitRootPatches(uint8_t* code, const uint8_t* roots_data) OVERRIDE; @@ -805,9 +805,9 @@ class CodeGeneratorARM64 : public CodeGenerator { void EmitJumpTables(); - template <LinkerPatch (*Factory)(size_t, const DexFile*, uint32_t, uint32_t)> + template <linker::LinkerPatch (*Factory)(size_t, const DexFile*, uint32_t, uint32_t)> static void EmitPcRelativeLinkerPatches(const ArenaDeque<PcRelativePatchInfo>& infos, - ArenaVector<LinkerPatch>* linker_patches); + ArenaVector<linker::LinkerPatch>* linker_patches); // Labels for each block that will be compiled. // We use a deque so that the `vixl::aarch64::Label` objects do not move in memory. diff --git a/compiler/optimizing/code_generator_arm_vixl.cc b/compiler/optimizing/code_generator_arm_vixl.cc index baf68c4e11..e1ea08073f 100644 --- a/compiler/optimizing/code_generator_arm_vixl.cc +++ b/compiler/optimizing/code_generator_arm_vixl.cc @@ -30,6 +30,7 @@ #include "heap_poisoning.h" #include "intrinsics_arm_vixl.h" #include "linker/arm/relative_patcher_thumb2.h" +#include "linker/linker_patch.h" #include "mirror/array-inl.h" #include "mirror/class-inl.h" #include "thread.h" @@ -9191,10 +9192,10 @@ VIXLUInt32Literal* CodeGeneratorARMVIXL::DeduplicateJitClassLiteral(const DexFil }); } -template <LinkerPatch (*Factory)(size_t, const DexFile*, uint32_t, uint32_t)> +template <linker::LinkerPatch (*Factory)(size_t, const DexFile*, uint32_t, uint32_t)> inline void CodeGeneratorARMVIXL::EmitPcRelativeLinkerPatches( const ArenaDeque<PcRelativePatchInfo>& infos, - ArenaVector<LinkerPatch>* linker_patches) { + ArenaVector<linker::LinkerPatch>* linker_patches) { for (const PcRelativePatchInfo& info : infos) { const DexFile& dex_file = info.target_dex_file; size_t offset_or_index = info.offset_or_index; @@ -9211,7 +9212,7 @@ inline void CodeGeneratorARMVIXL::EmitPcRelativeLinkerPatches( } } -void CodeGeneratorARMVIXL::EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_patches) { +void CodeGeneratorARMVIXL::EmitLinkerPatches(ArenaVector<linker::LinkerPatch>* linker_patches) { DCHECK(linker_patches->empty()); size_t size = /* MOVW+MOVT for each entry */ 2u * pc_relative_method_patches_.size() + @@ -9223,28 +9224,28 @@ void CodeGeneratorARMVIXL::EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_pa baker_read_barrier_patches_.size(); linker_patches->reserve(size); if (GetCompilerOptions().IsBootImage()) { - EmitPcRelativeLinkerPatches<LinkerPatch::RelativeMethodPatch>(pc_relative_method_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::RelativeTypePatch>(pc_relative_type_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::RelativeStringPatch>(pc_relative_string_patches_, - linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::RelativeMethodPatch>( + pc_relative_method_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::RelativeTypePatch>( + pc_relative_type_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::RelativeStringPatch>( + pc_relative_string_patches_, linker_patches); } else { DCHECK(pc_relative_method_patches_.empty()); - EmitPcRelativeLinkerPatches<LinkerPatch::TypeClassTablePatch>(pc_relative_type_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::StringInternTablePatch>(pc_relative_string_patches_, - linker_patches); - } - EmitPcRelativeLinkerPatches<LinkerPatch::MethodBssEntryPatch>(method_bss_entry_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::TypeBssEntryPatch>(type_bss_entry_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::StringBssEntryPatch>(string_bss_entry_patches_, - linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::TypeClassTablePatch>( + pc_relative_type_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::StringInternTablePatch>( + pc_relative_string_patches_, linker_patches); + } + EmitPcRelativeLinkerPatches<linker::LinkerPatch::MethodBssEntryPatch>( + method_bss_entry_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::TypeBssEntryPatch>( + type_bss_entry_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::StringBssEntryPatch>( + string_bss_entry_patches_, linker_patches); for (const BakerReadBarrierPatchInfo& info : baker_read_barrier_patches_) { - linker_patches->push_back(LinkerPatch::BakerReadBarrierBranchPatch(info.label.GetLocation(), - info.custom_data)); + linker_patches->push_back(linker::LinkerPatch::BakerReadBarrierBranchPatch( + info.label.GetLocation(), info.custom_data)); } DCHECK_EQ(size, linker_patches->size()); } diff --git a/compiler/optimizing/code_generator_arm_vixl.h b/compiler/optimizing/code_generator_arm_vixl.h index e78bc15614..337ecf1163 100644 --- a/compiler/optimizing/code_generator_arm_vixl.h +++ b/compiler/optimizing/code_generator_arm_vixl.h @@ -594,7 +594,7 @@ class CodeGeneratorARMVIXL : public CodeGenerator { dex::TypeIndex type_index, Handle<mirror::Class> handle); - void EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_patches) OVERRIDE; + void EmitLinkerPatches(ArenaVector<linker::LinkerPatch>* linker_patches) OVERRIDE; void EmitJitRootPatches(uint8_t* code, const uint8_t* roots_data) OVERRIDE; @@ -778,9 +778,9 @@ class CodeGeneratorARMVIXL : public CodeGenerator { PcRelativePatchInfo* NewPcRelativePatch(const DexFile& dex_file, uint32_t offset_or_index, ArenaDeque<PcRelativePatchInfo>* patches); - template <LinkerPatch (*Factory)(size_t, const DexFile*, uint32_t, uint32_t)> + template <linker::LinkerPatch (*Factory)(size_t, const DexFile*, uint32_t, uint32_t)> static void EmitPcRelativeLinkerPatches(const ArenaDeque<PcRelativePatchInfo>& infos, - ArenaVector<LinkerPatch>* linker_patches); + ArenaVector<linker::LinkerPatch>* linker_patches); // Labels for each block that will be compiled. // We use a deque so that the `vixl::aarch32::Label` objects do not move in memory. diff --git a/compiler/optimizing/code_generator_mips.cc b/compiler/optimizing/code_generator_mips.cc index 6256722661..8ada76a053 100644 --- a/compiler/optimizing/code_generator_mips.cc +++ b/compiler/optimizing/code_generator_mips.cc @@ -29,6 +29,7 @@ #include "heap_poisoning.h" #include "intrinsics.h" #include "intrinsics_mips.h" +#include "linker/linker_patch.h" #include "mirror/array-inl.h" #include "mirror/class-inl.h" #include "offsets.h" @@ -1628,10 +1629,10 @@ void CodeGeneratorMIPS::AddLocationAsTemp(Location location, LocationSummary* lo } } -template <LinkerPatch (*Factory)(size_t, const DexFile*, uint32_t, uint32_t)> +template <linker::LinkerPatch (*Factory)(size_t, const DexFile*, uint32_t, uint32_t)> inline void CodeGeneratorMIPS::EmitPcRelativeLinkerPatches( const ArenaDeque<PcRelativePatchInfo>& infos, - ArenaVector<LinkerPatch>* linker_patches) { + ArenaVector<linker::LinkerPatch>* linker_patches) { for (const PcRelativePatchInfo& info : infos) { const DexFile& dex_file = info.target_dex_file; size_t offset_or_index = info.offset_or_index; @@ -1647,7 +1648,7 @@ inline void CodeGeneratorMIPS::EmitPcRelativeLinkerPatches( } } -void CodeGeneratorMIPS::EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_patches) { +void CodeGeneratorMIPS::EmitLinkerPatches(ArenaVector<linker::LinkerPatch>* linker_patches) { DCHECK(linker_patches->empty()); size_t size = pc_relative_method_patches_.size() + @@ -1658,25 +1659,25 @@ void CodeGeneratorMIPS::EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_patch string_bss_entry_patches_.size(); linker_patches->reserve(size); if (GetCompilerOptions().IsBootImage()) { - EmitPcRelativeLinkerPatches<LinkerPatch::RelativeMethodPatch>(pc_relative_method_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::RelativeTypePatch>(pc_relative_type_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::RelativeStringPatch>(pc_relative_string_patches_, - linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::RelativeMethodPatch>( + pc_relative_method_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::RelativeTypePatch>( + pc_relative_type_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::RelativeStringPatch>( + pc_relative_string_patches_, linker_patches); } else { DCHECK(pc_relative_method_patches_.empty()); - EmitPcRelativeLinkerPatches<LinkerPatch::TypeClassTablePatch>(pc_relative_type_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::StringInternTablePatch>(pc_relative_string_patches_, - linker_patches); - } - EmitPcRelativeLinkerPatches<LinkerPatch::MethodBssEntryPatch>(method_bss_entry_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::TypeBssEntryPatch>(type_bss_entry_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::StringBssEntryPatch>(string_bss_entry_patches_, - linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::TypeClassTablePatch>( + pc_relative_type_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::StringInternTablePatch>( + pc_relative_string_patches_, linker_patches); + } + EmitPcRelativeLinkerPatches<linker::LinkerPatch::MethodBssEntryPatch>( + method_bss_entry_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::TypeBssEntryPatch>( + type_bss_entry_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::StringBssEntryPatch>( + string_bss_entry_patches_, linker_patches); DCHECK_EQ(size, linker_patches->size()); } diff --git a/compiler/optimizing/code_generator_mips.h b/compiler/optimizing/code_generator_mips.h index f15f8c672a..2b1075d12b 100644 --- a/compiler/optimizing/code_generator_mips.h +++ b/compiler/optimizing/code_generator_mips.h @@ -395,7 +395,7 @@ class CodeGeneratorMIPS : public CodeGenerator { const MipsAssembler& GetAssembler() const OVERRIDE { return assembler_; } // Emit linker patches. - void EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_patches) OVERRIDE; + void EmitLinkerPatches(ArenaVector<linker::LinkerPatch>* linker_patches) OVERRIDE; void EmitJitRootPatches(uint8_t* code, const uint8_t* roots_data) OVERRIDE; // Fast path implementation of ReadBarrier::Barrier for a heap @@ -679,9 +679,9 @@ class CodeGeneratorMIPS : public CodeGenerator { const PcRelativePatchInfo* info_high, ArenaDeque<PcRelativePatchInfo>* patches); - template <LinkerPatch (*Factory)(size_t, const DexFile*, uint32_t, uint32_t)> + template <linker::LinkerPatch (*Factory)(size_t, const DexFile*, uint32_t, uint32_t)> void EmitPcRelativeLinkerPatches(const ArenaDeque<PcRelativePatchInfo>& infos, - ArenaVector<LinkerPatch>* linker_patches); + ArenaVector<linker::LinkerPatch>* linker_patches); // Labels for each block that will be compiled. MipsLabel* block_labels_; diff --git a/compiler/optimizing/code_generator_mips64.cc b/compiler/optimizing/code_generator_mips64.cc index e8ae2db019..119e0f6b76 100644 --- a/compiler/optimizing/code_generator_mips64.cc +++ b/compiler/optimizing/code_generator_mips64.cc @@ -27,6 +27,7 @@ #include "heap_poisoning.h" #include "intrinsics.h" #include "intrinsics_mips64.h" +#include "linker/linker_patch.h" #include "mirror/array-inl.h" #include "mirror/class-inl.h" #include "offsets.h" @@ -1541,10 +1542,10 @@ void CodeGeneratorMIPS64::MarkGCCard(GpuRegister object, } } -template <LinkerPatch (*Factory)(size_t, const DexFile*, uint32_t, uint32_t)> +template <linker::LinkerPatch (*Factory)(size_t, const DexFile*, uint32_t, uint32_t)> inline void CodeGeneratorMIPS64::EmitPcRelativeLinkerPatches( const ArenaDeque<PcRelativePatchInfo>& infos, - ArenaVector<LinkerPatch>* linker_patches) { + ArenaVector<linker::LinkerPatch>* linker_patches) { for (const PcRelativePatchInfo& info : infos) { const DexFile& dex_file = info.target_dex_file; size_t offset_or_index = info.offset_or_index; @@ -1556,7 +1557,7 @@ inline void CodeGeneratorMIPS64::EmitPcRelativeLinkerPatches( } } -void CodeGeneratorMIPS64::EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_patches) { +void CodeGeneratorMIPS64::EmitLinkerPatches(ArenaVector<linker::LinkerPatch>* linker_patches) { DCHECK(linker_patches->empty()); size_t size = pc_relative_method_patches_.size() + @@ -1567,25 +1568,25 @@ void CodeGeneratorMIPS64::EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_pat string_bss_entry_patches_.size(); linker_patches->reserve(size); if (GetCompilerOptions().IsBootImage()) { - EmitPcRelativeLinkerPatches<LinkerPatch::RelativeMethodPatch>(pc_relative_method_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::RelativeTypePatch>(pc_relative_type_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::RelativeStringPatch>(pc_relative_string_patches_, - linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::RelativeMethodPatch>( + pc_relative_method_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::RelativeTypePatch>( + pc_relative_type_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::RelativeStringPatch>( + pc_relative_string_patches_, linker_patches); } else { DCHECK(pc_relative_method_patches_.empty()); - EmitPcRelativeLinkerPatches<LinkerPatch::TypeClassTablePatch>(pc_relative_type_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::StringInternTablePatch>(pc_relative_string_patches_, - linker_patches); - } - EmitPcRelativeLinkerPatches<LinkerPatch::MethodBssEntryPatch>(method_bss_entry_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::TypeBssEntryPatch>(type_bss_entry_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::StringBssEntryPatch>(string_bss_entry_patches_, - linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::TypeClassTablePatch>( + pc_relative_type_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::StringInternTablePatch>( + pc_relative_string_patches_, linker_patches); + } + EmitPcRelativeLinkerPatches<linker::LinkerPatch::MethodBssEntryPatch>( + method_bss_entry_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::TypeBssEntryPatch>( + type_bss_entry_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::StringBssEntryPatch>( + string_bss_entry_patches_, linker_patches); DCHECK_EQ(size, linker_patches->size()); } diff --git a/compiler/optimizing/code_generator_mips64.h b/compiler/optimizing/code_generator_mips64.h index 3035621972..9fe47ee297 100644 --- a/compiler/optimizing/code_generator_mips64.h +++ b/compiler/optimizing/code_generator_mips64.h @@ -374,7 +374,7 @@ class CodeGeneratorMIPS64 : public CodeGenerator { const Mips64Assembler& GetAssembler() const OVERRIDE { return assembler_; } // Emit linker patches. - void EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_patches) OVERRIDE; + void EmitLinkerPatches(ArenaVector<linker::LinkerPatch>* linker_patches) OVERRIDE; void EmitJitRootPatches(uint8_t* code, const uint8_t* roots_data) OVERRIDE; // Fast path implementation of ReadBarrier::Barrier for a heap @@ -643,9 +643,9 @@ class CodeGeneratorMIPS64 : public CodeGenerator { const PcRelativePatchInfo* info_high, ArenaDeque<PcRelativePatchInfo>* patches); - template <LinkerPatch (*Factory)(size_t, const DexFile*, uint32_t, uint32_t)> + template <linker::LinkerPatch (*Factory)(size_t, const DexFile*, uint32_t, uint32_t)> void EmitPcRelativeLinkerPatches(const ArenaDeque<PcRelativePatchInfo>& infos, - ArenaVector<LinkerPatch>* linker_patches); + ArenaVector<linker::LinkerPatch>* linker_patches); // Labels for each block that will be compiled. Mips64Label* block_labels_; // Indexed by block id. diff --git a/compiler/optimizing/code_generator_x86.cc b/compiler/optimizing/code_generator_x86.cc index 0b9130fa5a..99581ee9b8 100644 --- a/compiler/optimizing/code_generator_x86.cc +++ b/compiler/optimizing/code_generator_x86.cc @@ -26,6 +26,7 @@ #include "heap_poisoning.h" #include "intrinsics.h" #include "intrinsics_x86.h" +#include "linker/linker_patch.h" #include "lock_word.h" #include "mirror/array-inl.h" #include "mirror/class-inl.h" @@ -4675,10 +4676,10 @@ Label* CodeGeneratorX86::NewStringBssEntryPatch(HLoadString* load_string) { // for method patch needs to point to the embedded constant which occupies the last 4 bytes. constexpr uint32_t kLabelPositionToLiteralOffsetAdjustment = 4u; -template <LinkerPatch (*Factory)(size_t, const DexFile*, uint32_t, uint32_t)> +template <linker::LinkerPatch (*Factory)(size_t, const DexFile*, uint32_t, uint32_t)> inline void CodeGeneratorX86::EmitPcRelativeLinkerPatches( const ArenaDeque<X86PcRelativePatchInfo>& infos, - ArenaVector<LinkerPatch>* linker_patches) { + ArenaVector<linker::LinkerPatch>* linker_patches) { for (const X86PcRelativePatchInfo& info : infos) { uint32_t literal_offset = info.label.Position() - kLabelPositionToLiteralOffsetAdjustment; linker_patches->push_back(Factory( @@ -4686,7 +4687,7 @@ inline void CodeGeneratorX86::EmitPcRelativeLinkerPatches( } } -void CodeGeneratorX86::EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_patches) { +void CodeGeneratorX86::EmitLinkerPatches(ArenaVector<linker::LinkerPatch>* linker_patches) { DCHECK(linker_patches->empty()); size_t size = boot_image_method_patches_.size() + @@ -4697,24 +4698,25 @@ void CodeGeneratorX86::EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_patche string_bss_entry_patches_.size(); linker_patches->reserve(size); if (GetCompilerOptions().IsBootImage()) { - EmitPcRelativeLinkerPatches<LinkerPatch::RelativeMethodPatch>(boot_image_method_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::RelativeTypePatch>(boot_image_type_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::RelativeStringPatch>(string_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::RelativeMethodPatch>( + boot_image_method_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::RelativeTypePatch>( + boot_image_type_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::RelativeStringPatch>( + string_patches_, linker_patches); } else { DCHECK(boot_image_method_patches_.empty()); - EmitPcRelativeLinkerPatches<LinkerPatch::TypeClassTablePatch>(boot_image_type_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::StringInternTablePatch>(string_patches_, - linker_patches); - } - EmitPcRelativeLinkerPatches<LinkerPatch::MethodBssEntryPatch>(method_bss_entry_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::TypeBssEntryPatch>(type_bss_entry_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::StringBssEntryPatch>(string_bss_entry_patches_, - linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::TypeClassTablePatch>( + boot_image_type_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::StringInternTablePatch>( + string_patches_, linker_patches); + } + EmitPcRelativeLinkerPatches<linker::LinkerPatch::MethodBssEntryPatch>( + method_bss_entry_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::TypeBssEntryPatch>( + type_bss_entry_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::StringBssEntryPatch>( + string_bss_entry_patches_, linker_patches); DCHECK_EQ(size, linker_patches->size()); } diff --git a/compiler/optimizing/code_generator_x86.h b/compiler/optimizing/code_generator_x86.h index b32d57a774..e8f919d122 100644 --- a/compiler/optimizing/code_generator_x86.h +++ b/compiler/optimizing/code_generator_x86.h @@ -431,7 +431,7 @@ class CodeGeneratorX86 : public CodeGenerator { void MoveFromReturnRegister(Location trg, Primitive::Type type) OVERRIDE; // Emit linker patches. - void EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_patches) OVERRIDE; + void EmitLinkerPatches(ArenaVector<linker::LinkerPatch>* linker_patches) OVERRIDE; void PatchJitRootUse(uint8_t* code, const uint8_t* roots_data, @@ -617,9 +617,9 @@ class CodeGeneratorX86 : public CodeGenerator { HX86ComputeBaseMethodAddress* method_address; }; - template <LinkerPatch (*Factory)(size_t, const DexFile*, uint32_t, uint32_t)> + template <linker::LinkerPatch (*Factory)(size_t, const DexFile*, uint32_t, uint32_t)> void EmitPcRelativeLinkerPatches(const ArenaDeque<X86PcRelativePatchInfo>& infos, - ArenaVector<LinkerPatch>* linker_patches); + ArenaVector<linker::LinkerPatch>* linker_patches); Register GetInvokeStaticOrDirectExtraParameter(HInvokeStaticOrDirect* invoke, Register temp); diff --git a/compiler/optimizing/code_generator_x86_64.cc b/compiler/optimizing/code_generator_x86_64.cc index 39a65806a4..65b3f62104 100644 --- a/compiler/optimizing/code_generator_x86_64.cc +++ b/compiler/optimizing/code_generator_x86_64.cc @@ -25,6 +25,7 @@ #include "heap_poisoning.h" #include "intrinsics.h" #include "intrinsics_x86_64.h" +#include "linker/linker_patch.h" #include "lock_word.h" #include "mirror/array-inl.h" #include "mirror/class-inl.h" @@ -1106,10 +1107,10 @@ Label* CodeGeneratorX86_64::NewStringBssEntryPatch(HLoadString* load_string) { // for method patch needs to point to the embedded constant which occupies the last 4 bytes. constexpr uint32_t kLabelPositionToLiteralOffsetAdjustment = 4u; -template <LinkerPatch (*Factory)(size_t, const DexFile*, uint32_t, uint32_t)> +template <linker::LinkerPatch (*Factory)(size_t, const DexFile*, uint32_t, uint32_t)> inline void CodeGeneratorX86_64::EmitPcRelativeLinkerPatches( const ArenaDeque<PatchInfo<Label>>& infos, - ArenaVector<LinkerPatch>* linker_patches) { + ArenaVector<linker::LinkerPatch>* linker_patches) { for (const PatchInfo<Label>& info : infos) { uint32_t literal_offset = info.label.Position() - kLabelPositionToLiteralOffsetAdjustment; linker_patches->push_back( @@ -1117,7 +1118,7 @@ inline void CodeGeneratorX86_64::EmitPcRelativeLinkerPatches( } } -void CodeGeneratorX86_64::EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_patches) { +void CodeGeneratorX86_64::EmitLinkerPatches(ArenaVector<linker::LinkerPatch>* linker_patches) { DCHECK(linker_patches->empty()); size_t size = boot_image_method_patches_.size() + @@ -1128,24 +1129,25 @@ void CodeGeneratorX86_64::EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_pat string_bss_entry_patches_.size(); linker_patches->reserve(size); if (GetCompilerOptions().IsBootImage()) { - EmitPcRelativeLinkerPatches<LinkerPatch::RelativeMethodPatch>(boot_image_method_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::RelativeTypePatch>(boot_image_type_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::RelativeStringPatch>(string_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::RelativeMethodPatch>( + boot_image_method_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::RelativeTypePatch>( + boot_image_type_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::RelativeStringPatch>( + string_patches_, linker_patches); } else { DCHECK(boot_image_method_patches_.empty()); - EmitPcRelativeLinkerPatches<LinkerPatch::TypeClassTablePatch>(boot_image_type_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::StringInternTablePatch>(string_patches_, - linker_patches); - } - EmitPcRelativeLinkerPatches<LinkerPatch::MethodBssEntryPatch>(method_bss_entry_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::TypeBssEntryPatch>(type_bss_entry_patches_, - linker_patches); - EmitPcRelativeLinkerPatches<LinkerPatch::StringBssEntryPatch>(string_bss_entry_patches_, - linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::TypeClassTablePatch>( + boot_image_type_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::StringInternTablePatch>( + string_patches_, linker_patches); + } + EmitPcRelativeLinkerPatches<linker::LinkerPatch::MethodBssEntryPatch>( + method_bss_entry_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::TypeBssEntryPatch>( + type_bss_entry_patches_, linker_patches); + EmitPcRelativeLinkerPatches<linker::LinkerPatch::StringBssEntryPatch>( + string_bss_entry_patches_, linker_patches); DCHECK_EQ(size, linker_patches->size()); } diff --git a/compiler/optimizing/code_generator_x86_64.h b/compiler/optimizing/code_generator_x86_64.h index f5fa86bf23..8e8e695a64 100644 --- a/compiler/optimizing/code_generator_x86_64.h +++ b/compiler/optimizing/code_generator_x86_64.h @@ -424,7 +424,7 @@ class CodeGeneratorX86_64 : public CodeGenerator { void MoveFromReturnRegister(Location trg, Primitive::Type type) OVERRIDE; - void EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_patches) OVERRIDE; + void EmitLinkerPatches(ArenaVector<linker::LinkerPatch>* linker_patches) OVERRIDE; void PatchJitRootUse(uint8_t* code, const uint8_t* roots_data, @@ -586,9 +586,9 @@ class CodeGeneratorX86_64 : public CodeGenerator { static constexpr int32_t kDummy32BitOffset = 256; private: - template <LinkerPatch (*Factory)(size_t, const DexFile*, uint32_t, uint32_t)> + template <linker::LinkerPatch (*Factory)(size_t, const DexFile*, uint32_t, uint32_t)> static void EmitPcRelativeLinkerPatches(const ArenaDeque<PatchInfo<Label>>& infos, - ArenaVector<LinkerPatch>* linker_patches); + ArenaVector<linker::LinkerPatch>* linker_patches); // Labels for each block that will be compiled. Label* block_labels_; // Indexed by block id. diff --git a/compiler/optimizing/optimizing_compiler.cc b/compiler/optimizing/optimizing_compiler.cc index 8dd2762a75..7451196677 100644 --- a/compiler/optimizing/optimizing_compiler.cc +++ b/compiler/optimizing/optimizing_compiler.cc @@ -77,6 +77,7 @@ #include "jit/jit_logger.h" #include "jni/quick/jni_compiler.h" #include "licm.h" +#include "linker/linker_patch.h" #include "load_store_analysis.h" #include "load_store_elimination.h" #include "loop_optimization.h" @@ -833,13 +834,13 @@ void OptimizingCompiler::RunOptimizations(HGraph* graph, RunArchOptimizations(driver->GetInstructionSet(), graph, codegen, pass_observer); } -static ArenaVector<LinkerPatch> EmitAndSortLinkerPatches(CodeGenerator* codegen) { - ArenaVector<LinkerPatch> linker_patches(codegen->GetGraph()->GetArena()->Adapter()); +static ArenaVector<linker::LinkerPatch> EmitAndSortLinkerPatches(CodeGenerator* codegen) { + ArenaVector<linker::LinkerPatch> linker_patches(codegen->GetGraph()->GetArena()->Adapter()); codegen->EmitLinkerPatches(&linker_patches); // Sort patches by literal offset. Required for .oat_patches encoding. std::sort(linker_patches.begin(), linker_patches.end(), - [](const LinkerPatch& lhs, const LinkerPatch& rhs) { + [](const linker::LinkerPatch& lhs, const linker::LinkerPatch& rhs) { return lhs.LiteralOffset() < rhs.LiteralOffset(); }); @@ -851,7 +852,7 @@ CompiledMethod* OptimizingCompiler::Emit(ArenaAllocator* arena, CodeGenerator* codegen, CompilerDriver* compiler_driver, const DexFile::CodeItem* code_item) const { - ArenaVector<LinkerPatch> linker_patches = EmitAndSortLinkerPatches(codegen); + ArenaVector<linker::LinkerPatch> linker_patches = EmitAndSortLinkerPatches(codegen); ArenaVector<uint8_t> stack_map(arena->Adapter(kArenaAllocStackMaps)); ArenaVector<uint8_t> method_info(arena->Adapter(kArenaAllocStackMaps)); size_t stack_map_size = 0; @@ -876,7 +877,7 @@ CompiledMethod* OptimizingCompiler::Emit(ArenaAllocator* arena, ArrayRef<const uint8_t>(method_info), ArrayRef<const uint8_t>(stack_map), ArrayRef<const uint8_t>(*codegen->GetAssembler()->cfi().data()), - ArrayRef<const LinkerPatch>(linker_patches)); + ArrayRef<const linker::LinkerPatch>(linker_patches)); return compiled_method; } diff --git a/dex2oat/linker/image_test.h b/dex2oat/linker/image_test.h index 71f1fa607e..492c76bc54 100644 --- a/dex2oat/linker/image_test.h +++ b/dex2oat/linker/image_test.h @@ -302,8 +302,8 @@ inline void CompilationHelper::Compile(CompilerDriver* driver, } for (size_t i = 0, size = oat_files.size(); i != size; ++i) { - linker::MultiOatRelativePatcher patcher(driver->GetInstructionSet(), - driver->GetInstructionSetFeatures()); + MultiOatRelativePatcher patcher(driver->GetInstructionSet(), + driver->GetInstructionSetFeatures()); OatWriter* const oat_writer = oat_writers[i].get(); ElfWriter* const elf_writer = elf_writers[i].get(); std::vector<const DexFile*> cur_dex_files(1u, class_path[i]); diff --git a/dex2oat/linker/multi_oat_relative_patcher_test.cc b/dex2oat/linker/multi_oat_relative_patcher_test.cc index 1b2d43e4c5..ca9c5f1e84 100644 --- a/dex2oat/linker/multi_oat_relative_patcher_test.cc +++ b/dex2oat/linker/multi_oat_relative_patcher_test.cc @@ -19,6 +19,7 @@ #include "compiled_method.h" #include "debug/method_debug_info.h" #include "gtest/gtest.h" +#include "linker/linker_patch.h" #include "linker/vector_output_stream.h" namespace art { diff --git a/dex2oat/linker/oat_writer.cc b/dex2oat/linker/oat_writer.cc index 51c2a037a0..305d4f65dc 100644 --- a/dex2oat/linker/oat_writer.cc +++ b/dex2oat/linker/oat_writer.cc @@ -29,7 +29,7 @@ #include "base/unix_file/fd_file.h" #include "class_linker.h" #include "class_table-inl.h" -#include "compiled_method.h" +#include "compiled_method-inl.h" #include "debug/method_debug_info.h" #include "dex/verification_results.h" #include "dex_file-inl.h" @@ -43,6 +43,7 @@ #include "image_writer.h" #include "linker/buffered_output_stream.h" #include "linker/file_output_stream.h" +#include "linker/linker_patch.h" #include "linker/method_bss_mapping_encoder.h" #include "linker/multi_oat_relative_patcher.h" #include "linker/output_stream.h" @@ -1063,7 +1064,7 @@ class OatWriter::InitCodeMethodVisitor : public OatDexMethodVisitor { SafeMap<const CompiledMethod*, uint32_t, CodeOffsetsKeyComparator> dedupe_map_; // Cache writer_'s members and compiler options. - linker::MultiOatRelativePatcher* relative_patcher_; + MultiOatRelativePatcher* relative_patcher_; uint32_t executable_offset_; const bool debuggable_; const bool native_debuggable_; @@ -1920,7 +1921,7 @@ size_t OatWriter::InitMethodBssMappings(size_t offset) { DCHECK_ALIGNED(offset, 4u); oat_dex_files_[i].method_bss_mapping_offset_ = offset; - linker::MethodBssMappingEncoder encoder( + MethodBssMappingEncoder encoder( GetInstructionSetPointerSize(oat_header_->GetInstructionSet())); size_t number_of_entries = 0u; bool first_index = true; @@ -2593,7 +2594,7 @@ size_t OatWriter::WriteMethodBssMappings(OutputStream* out, "MethodBssMapping alignment check."); DCHECK_ALIGNED(relative_offset, sizeof(uint32_t)); - linker::MethodBssMappingEncoder encoder( + MethodBssMappingEncoder encoder( GetInstructionSetPointerSize(oat_header_->GetInstructionSet())); // Allocate a sufficiently large MethodBssMapping. size_t number_of_method_indexes = method_indexes.NumSetBits(); diff --git a/dex2oat/linker/oat_writer_test.cc b/dex2oat/linker/oat_writer_test.cc index 0600ceb12d..e3d25377d8 100644 --- a/dex2oat/linker/oat_writer_test.cc +++ b/dex2oat/linker/oat_writer_test.cc @@ -23,7 +23,7 @@ #include "base/unix_file/fd_file.h" #include "class_linker.h" #include "common_compiler_test.h" -#include "compiled_method.h" +#include "compiled_method-inl.h" #include "compiler.h" #include "debug/method_debug_info.h" #include "dex/quick_compiler_callbacks.h" diff --git a/oatdump/oatdump.cc b/oatdump/oatdump.cc index 36bd4bcc24..be78136f4e 100644 --- a/oatdump/oatdump.cc +++ b/oatdump/oatdump.cc @@ -36,6 +36,7 @@ #include "base/unix_file/fd_file.h" #include "class_linker-inl.h" #include "class_linker.h" +#include "compiled_method.h" #include "debug/elf_debug_writer.h" #include "debug/method_debug_info.h" #include "dex_file-inl.h" |