/*
|
* 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.
|
*/
|
|
#ifndef ART_DEX2OAT_LINKER_MULTI_OAT_RELATIVE_PATCHER_H_
|
#define ART_DEX2OAT_LINKER_MULTI_OAT_RELATIVE_PATCHER_H_
|
|
#include "arch/instruction_set.h"
|
#include "base/safe_map.h"
|
#include "debug/method_debug_info.h"
|
#include "dex/method_reference.h"
|
#include "linker/relative_patcher.h"
|
|
namespace art {
|
|
class CompiledMethod;
|
class CompiledMethodStorage;
|
class InstructionSetFeatures;
|
|
namespace linker {
|
|
// MultiOatRelativePatcher is a helper class for handling patching across
|
// any number of oat files. It provides storage for method code offsets
|
// and wraps RelativePatcher calls, adjusting relative offsets according
|
// to the value set by SetAdjustment().
|
class MultiOatRelativePatcher final {
|
public:
|
using const_iterator = SafeMap<MethodReference, uint32_t>::const_iterator;
|
|
MultiOatRelativePatcher(InstructionSet instruction_set,
|
const InstructionSetFeatures* features,
|
CompiledMethodStorage* storage);
|
|
// Mark the start of a new oat file (for statistics retrieval) and set the
|
// adjustment for a new oat file to apply to all relative offsets that are
|
// passed to the MultiOatRelativePatcher.
|
//
|
// The adjustment should be the global offset of the base from which relative
|
// offsets are calculated, such as the start of .rodata for the current oat file.
|
// It must must never point directly to a method's code to avoid relative offsets
|
// with value 0 because this value is used as a missing offset indication in
|
// GetOffset() and an error indication in WriteThunks(). Additionally, it must be
|
// page-aligned, so that it does not skew alignment calculations, say arm64 ADRP.
|
void StartOatFile(uint32_t adjustment);
|
|
// Get relative offset. Returns 0 when the offset has not been set yet.
|
uint32_t GetOffset(MethodReference method_ref) {
|
auto it = method_offset_map_.map.find(method_ref);
|
return (it != method_offset_map_.map.end()) ? it->second - adjustment_ : 0u;
|
}
|
|
// Set the offset.
|
void SetOffset(MethodReference method_ref, uint32_t offset) {
|
method_offset_map_.map.Put(method_ref, offset + adjustment_);
|
}
|
|
// Wrapper around RelativePatcher::ReserveSpace(), doing offset adjustment.
|
uint32_t ReserveSpace(uint32_t offset,
|
const CompiledMethod* compiled_method,
|
MethodReference method_ref) {
|
offset += adjustment_;
|
offset = relative_patcher_->ReserveSpace(offset, compiled_method, method_ref);
|
offset -= adjustment_;
|
return offset;
|
}
|
|
// Wrapper around RelativePatcher::ReserveSpaceEnd(), doing offset adjustment.
|
uint32_t ReserveSpaceEnd(uint32_t offset) {
|
offset += adjustment_;
|
offset = relative_patcher_->ReserveSpaceEnd(offset);
|
offset -= adjustment_;
|
return offset;
|
}
|
|
// Wrapper around RelativePatcher::WriteThunks(), doing offset adjustment.
|
uint32_t WriteThunks(OutputStream* out, uint32_t offset) {
|
offset += adjustment_;
|
offset = relative_patcher_->WriteThunks(out, offset);
|
if (offset != 0u) { // 0u indicates write error.
|
offset -= adjustment_;
|
}
|
return offset;
|
}
|
|
// Wrapper around RelativePatcher::PatchCall(), doing offset adjustment.
|
void PatchCall(std::vector<uint8_t>* code,
|
uint32_t literal_offset,
|
uint32_t patch_offset,
|
uint32_t target_offset) {
|
patch_offset += adjustment_;
|
target_offset += adjustment_;
|
relative_patcher_->PatchCall(code, literal_offset, patch_offset, target_offset);
|
}
|
|
// Wrapper around RelativePatcher::PatchPcRelativeReference(), doing offset adjustment.
|
void PatchPcRelativeReference(std::vector<uint8_t>* code,
|
const LinkerPatch& patch,
|
uint32_t patch_offset,
|
uint32_t target_offset) {
|
patch_offset += adjustment_;
|
target_offset += adjustment_;
|
relative_patcher_->PatchPcRelativeReference(code, patch, patch_offset, target_offset);
|
}
|
|
void PatchBakerReadBarrierBranch(std::vector<uint8_t>* code,
|
const LinkerPatch& patch,
|
uint32_t patch_offset) {
|
patch_offset += adjustment_;
|
relative_patcher_->PatchBakerReadBarrierBranch(code, patch, patch_offset);
|
}
|
|
std::vector<debug::MethodDebugInfo> GenerateThunkDebugInfo(size_t executable_offset) {
|
executable_offset += adjustment_;
|
return relative_patcher_->GenerateThunkDebugInfo(executable_offset);
|
}
|
|
// Wrappers around RelativePatcher for statistics retrieval.
|
uint32_t CodeAlignmentSize() const;
|
uint32_t RelativeCallThunksSize() const;
|
uint32_t MiscThunksSize() const;
|
|
private:
|
class ThunkProvider : public RelativePatcherThunkProvider {
|
public:
|
explicit ThunkProvider(CompiledMethodStorage* storage)
|
: storage_(storage) {}
|
|
void GetThunkCode(const LinkerPatch& patch,
|
/*out*/ ArrayRef<const uint8_t>* code,
|
/*out*/ std::string* debug_name) override;
|
|
private:
|
CompiledMethodStorage* storage_;
|
};
|
|
// Map method reference to assigned offset.
|
// Wrap the map in a class implementing RelativePatcherTargetProvider.
|
class MethodOffsetMap : public RelativePatcherTargetProvider {
|
public:
|
std::pair<bool, uint32_t> FindMethodOffset(MethodReference ref) override;
|
SafeMap<MethodReference, uint32_t> map;
|
};
|
|
ThunkProvider thunk_provider_;
|
MethodOffsetMap method_offset_map_;
|
std::unique_ptr<RelativePatcher> relative_patcher_;
|
uint32_t adjustment_;
|
InstructionSet instruction_set_;
|
|
uint32_t start_size_code_alignment_;
|
uint32_t start_size_relative_call_thunks_;
|
uint32_t start_size_misc_thunks_;
|
|
friend class MultiOatRelativePatcherTest;
|
|
DISALLOW_COPY_AND_ASSIGN(MultiOatRelativePatcher);
|
};
|
|
} // namespace linker
|
} // namespace art
|
|
#endif // ART_DEX2OAT_LINKER_MULTI_OAT_RELATIVE_PATCHER_H_
|
