blob: f748e572fce86075c87ba111449159f75a7fa6d8 [file] [log] [blame]
/*
* Copyright (C) 2011 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_SRC_DEX_CACHE_H_
#define ART_SRC_DEX_CACHE_H_
#include "dex_file.h"
#include "globals.h"
#include "macros.h"
#include "object.h"
namespace art {
class Class;
class Field;
class ImageWriter;
class Method;
class String;
union JValue;
class MANAGED CodeAndDirectMethods : public IntArray {
public:
void* GetResolvedCode(uint32_t method_idx) const {
return reinterpret_cast<byte*>(Get(CodeIndex(method_idx)));
}
Method* GetResolvedMethod(uint32_t method_idx) const {
return reinterpret_cast<Method*>(Get(MethodIndex(method_idx)));
}
void SetResolvedDirectMethodTrampoline(uint32_t method_idx, ByteArray* code_array) {
CHECK(code_array != NULL);
int32_t code = reinterpret_cast<int32_t>(code_array->GetData());
Set(CodeIndex(method_idx), code);
Set(MethodIndex(method_idx), method_idx);
}
void SetResolvedDirectMethodTraceEntry(uint32_t method_idx, const void* pcode);
void SetResolvedDirectMethod(uint32_t method_idx, Method* method);
static size_t LengthAsArray(size_t elements) {
return kMax * elements;
}
// Offset of resolved method entry from start of code_and_direct_methods_
static size_t MethodOffsetInBytes(uint32_t method_idx) {
return (MethodIndex(method_idx) * sizeof(ElementType) + Array::DataOffset().Int32Value());
}
// Offset of resolved method's code_ from start of code_and_direct_methods_
static size_t CodeOffsetInBytes(uint32_t method_idx) {
return (CodeIndex(method_idx) * sizeof(ElementType) + Array::DataOffset().Int32Value());
}
size_t NumCodeAndDirectMethods() const {
return GetLength() / kMax;
}
static size_t CodeIndex(uint32_t method_idx) {
return method_idx * kMax + kCode;
}
static size_t MethodIndex(uint32_t method_idx) {
return method_idx * kMax + kMethod;
}
private:
enum TupleIndex {
kCode = 0,
kMethod = 1,
kMax = 2,
};
// grant friend status to ImageWriter fixup code that needs to know internal layout
friend class ImageWriter;
DISALLOW_IMPLICIT_CONSTRUCTORS(CodeAndDirectMethods);
};
class MANAGED DexCache : public ObjectArray<Object> {
public:
void Init(String* location,
ObjectArray<String>* strings,
ObjectArray<Class>* types,
ObjectArray<Method>* methods,
ObjectArray<Field>* fields,
CodeAndDirectMethods* code_and_direct_methods,
ObjectArray<StaticStorageBase>* initialized_static_storage);
String* GetLocation() const {
return Get(kLocation)->AsString();
}
static MemberOffset StringsOffset() {
return MemberOffset(DataOffset().Int32Value() +
kStrings * sizeof(Object*));
}
static MemberOffset ResolvedFieldsOffset() {
return MemberOffset(DataOffset().Int32Value() +
kResolvedFields * sizeof(Object*));
}
static MemberOffset ResolvedMethodsOffset() {
return MemberOffset(DataOffset().Int32Value() +
kResolvedMethods * sizeof(Object*));
}
size_t NumStrings() const {
return GetStrings()->GetLength();
}
size_t NumResolvedTypes() const {
return GetResolvedTypes()->GetLength();
}
size_t NumResolvedMethods() const {
return GetResolvedMethods()->GetLength();
}
size_t NumResolvedFields() const {
return GetResolvedFields()->GetLength();
}
size_t NumCodeAndDirectMethods() const {
return GetCodeAndDirectMethods()->NumCodeAndDirectMethods();
}
size_t NumInitializedStaticStorage() const {
return GetInitializedStaticStorage()->GetLength();
}
String* GetResolvedString(uint32_t string_idx) const {
return GetStrings()->Get(string_idx);
}
void SetResolvedString(uint32_t string_idx, String* resolved) {
GetStrings()->Set(string_idx, resolved);
}
Class* GetResolvedType(uint32_t type_idx) const {
return GetResolvedTypes()->Get(type_idx);
}
void SetResolvedType(uint32_t type_idx, Class* resolved) {
GetResolvedTypes()->Set(type_idx, resolved);
}
Method* GetResolvedMethod(uint32_t method_idx) const {
return GetResolvedMethods()->Get(method_idx);
}
void SetResolvedMethod(uint32_t method_idx, Method* resolved) {
GetResolvedMethods()->Set(method_idx, resolved);
}
Field* GetResolvedField(uint32_t field_idx) const {
return GetResolvedFields()->Get(field_idx);
}
void SetResolvedField(uint32_t field_idx, Field* resolved) {
GetResolvedFields()->Set(field_idx, resolved);
}
ObjectArray<String>* GetStrings() const {
return static_cast<ObjectArray<String>*>(GetNonNull(kStrings));
}
ObjectArray<Class>* GetResolvedTypes() const {
return static_cast<ObjectArray<Class>*>(GetNonNull(kResolvedTypes));
}
ObjectArray<Method>* GetResolvedMethods() const {
return static_cast<ObjectArray<Method>*>(GetNonNull(kResolvedMethods));
}
ObjectArray<Field>* GetResolvedFields() const {
return static_cast<ObjectArray<Field>*>(GetNonNull(kResolvedFields));
}
CodeAndDirectMethods* GetCodeAndDirectMethods() const {
return static_cast<CodeAndDirectMethods*>(GetNonNull(kCodeAndDirectMethods));
}
ObjectArray<StaticStorageBase>* GetInitializedStaticStorage() const {
return static_cast<ObjectArray<StaticStorageBase>*>(GetNonNull(kInitializedStaticStorage));
}
static size_t LengthAsArray() {
return kMax;
}
private:
enum ArrayIndex {
kLocation = 0,
kStrings = 1,
kResolvedTypes = 2,
kResolvedMethods = 3,
kResolvedFields = 4,
kCodeAndDirectMethods = 5,
kInitializedStaticStorage = 6,
kMax = 7,
};
Object* GetNonNull(ArrayIndex array_index) const {
Object* obj = Get(array_index);
DCHECK(obj != NULL);
return obj;
}
DISALLOW_IMPLICIT_CONSTRUCTORS(DexCache);
};
} // namespace art
#endif // ART_SRC_DEX_CACHE_H_