blob: e131c96a81f6f3b5f272609af6e22c5345ae1833 [file] [log] [blame]
/*
* Copyright (C) 2014 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_DEX_MIR_METHOD_INFO_H_
#define ART_COMPILER_DEX_MIR_METHOD_INFO_H_
#include "base/logging.h"
#include "base/macros.h"
#include "base/mutex.h"
#include "invoke_type.h"
#include "method_reference.h"
namespace art {
class CompilerDriver;
class DexCompilationUnit;
class DexFile;
class MirMethodInfo {
public:
uint16_t MethodIndex() const {
return method_idx_;
}
bool IsStatic() const {
return (flags_ & kFlagIsStatic) != 0u;
}
bool IsResolved() const {
return declaring_dex_file_ != nullptr;
}
const DexFile* DeclaringDexFile() const {
return declaring_dex_file_;
}
void SetDeclaringDexFile(const DexFile* dex_file) {
declaring_dex_file_ = dex_file;
}
uint16_t DeclaringClassIndex() const {
return declaring_class_idx_;
}
uint16_t DeclaringMethodIndex() const {
return declaring_method_idx_;
}
protected:
enum {
kBitIsStatic = 0,
kMethodInfoBitEnd
};
static_assert(kMethodInfoBitEnd <= 16, "Too many flags");
static constexpr uint16_t kFlagIsStatic = 1u << kBitIsStatic;
MirMethodInfo(uint16_t method_idx, uint16_t flags)
: method_idx_(method_idx),
flags_(flags),
declaring_method_idx_(0u),
declaring_class_idx_(0u),
declaring_dex_file_(nullptr) {
}
// Make copy-ctor/assign/dtor protected to avoid slicing.
MirMethodInfo(const MirMethodInfo& other) = default;
MirMethodInfo& operator=(const MirMethodInfo& other) = default;
~MirMethodInfo() = default;
// The method index in the compiling method's dex file.
uint16_t method_idx_;
// Flags, for volatility and derived class data.
uint16_t flags_;
// The method index in the dex file that defines the method, 0 if unresolved.
uint16_t declaring_method_idx_;
// The type index of the class declaring the method, 0 if unresolved.
uint16_t declaring_class_idx_;
// The dex file that defines the class containing the method and the method,
// nullptr if unresolved.
const DexFile* declaring_dex_file_;
};
class MirMethodLoweringInfo : public MirMethodInfo {
public:
// For each requested method retrieve the method's declaring location (dex file, class
// index and method index) and compute whether we can fast path the method call. For fast
// path methods, retrieve the method's vtable index and direct code and method when applicable.
static void Resolve(CompilerDriver* compiler_driver, const DexCompilationUnit* mUnit,
MirMethodLoweringInfo* method_infos, size_t count)
LOCKS_EXCLUDED(Locks::mutator_lock_);
MirMethodLoweringInfo(uint16_t method_idx, InvokeType type, bool is_quickened)
: MirMethodInfo(method_idx,
((type == kStatic) ? kFlagIsStatic : 0u) |
(static_cast<uint16_t>(type) << kBitInvokeTypeBegin) |
(static_cast<uint16_t>(type) << kBitSharpTypeBegin) |
(is_quickened ? kFlagQuickened : 0u)),
direct_code_(0u),
direct_method_(0u),
target_dex_file_(nullptr),
target_method_idx_(0u),
vtable_idx_(0u),
stats_flags_(0) {
}
void SetDevirtualizationTarget(const MethodReference& ref) {
DCHECK(target_dex_file_ == nullptr);
DCHECK_EQ(target_method_idx_, 0u);
DCHECK_LE(ref.dex_method_index, 0xffffu);
target_dex_file_ = ref.dex_file;
target_method_idx_ = ref.dex_method_index;
}
bool FastPath() const {
return (flags_ & kFlagFastPath) != 0u;
}
bool IsReferrersClass() const {
return (flags_ & kFlagIsReferrersClass) != 0;
}
bool IsClassInitialized() const {
return (flags_ & kFlagClassIsInitialized) != 0u;
}
// Returns true iff the method invoke is INVOKE_VIRTUAL_QUICK or INVOKE_VIRTUAL_RANGE_QUICK.
bool IsQuickened() const {
return (flags_ & kFlagQuickened) != 0u;
}
InvokeType GetInvokeType() const {
return static_cast<InvokeType>((flags_ >> kBitInvokeTypeBegin) & kInvokeTypeMask);
}
art::InvokeType GetSharpType() const {
return static_cast<InvokeType>((flags_ >> kBitSharpTypeBegin) & kInvokeTypeMask);
}
MethodReference GetTargetMethod() const {
return MethodReference(target_dex_file_, target_method_idx_);
}
uint16_t VTableIndex() const {
return vtable_idx_;
}
void SetVTableIndex(uint16_t index) {
vtable_idx_ = index;
}
uintptr_t DirectCode() const {
return direct_code_;
}
uintptr_t DirectMethod() const {
return direct_method_;
}
int StatsFlags() const {
return stats_flags_;
}
void CheckEquals(const MirMethodLoweringInfo& info) const {
CHECK_EQ(method_idx_, info.method_idx_);
CHECK_EQ(flags_, info.flags_);
CHECK_EQ(declaring_method_idx_, info.declaring_method_idx_);
CHECK_EQ(declaring_class_idx_, info.declaring_class_idx_);
CHECK_EQ(declaring_dex_file_, info.declaring_dex_file_);
CHECK_EQ(direct_code_, info.direct_code_);
CHECK_EQ(direct_method_, info.direct_method_);
CHECK_EQ(target_dex_file_, info.target_dex_file_);
CHECK_EQ(target_method_idx_, info.target_method_idx_);
CHECK_EQ(vtable_idx_, info.vtable_idx_);
CHECK_EQ(stats_flags_, info.stats_flags_);
}
private:
enum {
kBitFastPath = kMethodInfoBitEnd,
kBitInvokeTypeBegin,
kBitInvokeTypeEnd = kBitInvokeTypeBegin + 3, // 3 bits for invoke type.
kBitSharpTypeBegin,
kBitSharpTypeEnd = kBitSharpTypeBegin + 3, // 3 bits for sharp type.
kBitIsReferrersClass = kBitSharpTypeEnd,
kBitClassIsInitialized,
kBitQuickened,
kMethodLoweringInfoBitEnd
};
static_assert(kMethodLoweringInfoBitEnd <= 16, "Too many flags");
static constexpr uint16_t kFlagFastPath = 1u << kBitFastPath;
static constexpr uint16_t kFlagIsReferrersClass = 1u << kBitIsReferrersClass;
static constexpr uint16_t kFlagClassIsInitialized = 1u << kBitClassIsInitialized;
static constexpr uint16_t kFlagQuickened = 1u << kBitQuickened;
static constexpr uint16_t kInvokeTypeMask = 7u;
static_assert((1u << (kBitInvokeTypeEnd - kBitInvokeTypeBegin)) - 1u == kInvokeTypeMask,
"assert invoke type bits failed");
static_assert((1u << (kBitSharpTypeEnd - kBitSharpTypeBegin)) - 1u == kInvokeTypeMask,
"assert sharp type bits failed");
uintptr_t direct_code_;
uintptr_t direct_method_;
// Before Resolve(), target_dex_file_ and target_method_idx_ hold the verification-based
// devirtualized invoke target if available, nullptr and 0u otherwise.
// After Resolve() they hold the actual target method that will be called; it will be either
// a devirtualized target method or the compilation's unit's dex file and MethodIndex().
const DexFile* target_dex_file_;
uint16_t target_method_idx_;
uint16_t vtable_idx_;
int stats_flags_;
friend class MirOptimizationTest;
};
} // namespace art
#endif // ART_COMPILER_DEX_MIR_METHOD_INFO_H_