blob: 39fc89e56221203ae9173849b6e78f829b5433d0 [file] [log] [blame]
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef ART_SRC_MIRROR_METHOD_INL_H_
18#define ART_SRC_MIRROR_METHOD_INL_H_
19
20#include "abstract_method.h"
21
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080022#include "dex_file.h"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070023#include "object_array.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080024#include "runtime.h"
Jeff Hao58df3272013-04-22 15:28:53 -070025#include "runtime_support.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080026
27namespace art {
28namespace mirror {
29
30inline Class* AbstractMethod::GetDeclaringClass() const {
31 Class* result = GetFieldObject<Class*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, declaring_class_), false);
32 DCHECK(result != NULL) << this;
33 DCHECK(result->IsIdxLoaded() || result->IsErroneous()) << this;
34 return result;
35}
36
37inline void AbstractMethod::SetDeclaringClass(Class *new_declaring_class) {
38 SetFieldObject(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, declaring_class_), new_declaring_class, false);
39}
40
41inline uint32_t AbstractMethod::GetAccessFlags() const {
42 DCHECK(GetDeclaringClass()->IsIdxLoaded() || GetDeclaringClass()->IsErroneous());
43 return GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, access_flags_), false);
44}
45
46inline uint16_t AbstractMethod::GetMethodIndex() const {
47 DCHECK(GetDeclaringClass()->IsResolved() || GetDeclaringClass()->IsErroneous());
48 return GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, method_index_), false);
49}
50
51inline uint32_t AbstractMethod::GetDexMethodIndex() const {
52 DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
53 return GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, method_dex_index_), false);
54}
55
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070056inline ObjectArray<String>* AbstractMethod::GetDexCacheStrings() const {
57 return GetFieldObject<ObjectArray<String>*>(
58 OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_strings_), false);
59}
60
61inline ObjectArray<AbstractMethod>* AbstractMethod::GetDexCacheResolvedMethods() const {
62 return GetFieldObject<ObjectArray<AbstractMethod>*>(
63 OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_resolved_methods_), false);
64}
65
66inline ObjectArray<Class>* AbstractMethod::GetDexCacheResolvedTypes() const {
67 return GetFieldObject<ObjectArray<Class>*>(
68 OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_resolved_types_), false);
69}
70
71inline ObjectArray<StaticStorageBase>* AbstractMethod::GetDexCacheInitializedStaticStorage() const {
72 return GetFieldObject<ObjectArray<StaticStorageBase>*>(
73 OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_initialized_static_storage_),
74 false);
75}
76
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080077inline uint32_t AbstractMethod::GetCodeSize() const {
78 DCHECK(!IsRuntimeMethod() && !IsProxyMethod()) << PrettyMethod(this);
Jeff Haoaa4a7932013-05-13 11:28:27 -070079 uintptr_t code = reinterpret_cast<uintptr_t>(GetEntryPointFromCompiledCode());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080080 if (code == 0) {
81 return 0;
82 }
83 // TODO: make this Thumb2 specific
84 code &= ~0x1;
85 return reinterpret_cast<uint32_t*>(code)[-1];
86}
87
88inline bool AbstractMethod::CheckIncompatibleClassChange(InvokeType type) {
89 switch (type) {
90 case kStatic:
91 return !IsStatic();
92 case kDirect:
93 return !IsDirect() || IsStatic();
94 case kVirtual: {
95 Class* methods_class = GetDeclaringClass();
96 return IsDirect() || (methods_class->IsInterface() && !IsMiranda());
97 }
98 case kSuper:
99 return false; // TODO: appropriate checks for call to super class.
100 case kInterface: {
101 Class* methods_class = GetDeclaringClass();
102 return IsDirect() || !(methods_class->IsInterface() || methods_class->IsObjectClass());
103 }
104 default:
105 LOG(FATAL) << "Unreachable - invocation type: " << type;
106 return true;
107 }
108}
109
110inline void AbstractMethod::AssertPcIsWithinCode(uintptr_t pc) const {
111 if (!kIsDebugBuild) {
112 return;
113 }
114 if (IsNative() || IsRuntimeMethod() || IsProxyMethod()) {
115 return;
116 }
Jeff Hao65d15d92013-07-16 16:39:33 -0700117 if (pc == GetInstrumentationExitPc()) {
118 return;
119 }
120 const void* code = GetEntryPointFromCompiledCode();
121 if (code == GetInterpreterEntryPoint() || code == GetInstrumentationEntryPoint()) {
Ian Rogers62d6c772013-02-27 08:32:07 -0800122 return;
123 }
Jeff Hao0aba0ba2013-06-03 14:49:28 -0700124 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
Jeff Hao65d15d92013-07-16 16:39:33 -0700125 if (code == GetResolutionTrampoline(class_linker)) {
126 return;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800127 }
128 DCHECK(IsWithinCode(pc))
129 << PrettyMethod(this)
130 << " pc=" << std::hex << pc
Jeff Hao65d15d92013-07-16 16:39:33 -0700131 << " code=" << code
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800132 << " size=" << GetCodeSize();
133}
134
135inline uint32_t AbstractMethod::GetOatCodeOffset() const {
136 DCHECK(!Runtime::Current()->IsStarted());
Jeff Haoaa4a7932013-05-13 11:28:27 -0700137 return reinterpret_cast<uint32_t>(GetEntryPointFromCompiledCode());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800138}
139
140inline void AbstractMethod::SetOatCodeOffset(uint32_t code_offset) {
141 DCHECK(!Runtime::Current()->IsStarted());
Jeff Haoaa4a7932013-05-13 11:28:27 -0700142 SetEntryPointFromCompiledCode(reinterpret_cast<void*>(code_offset));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800143}
144
145inline uint32_t AbstractMethod::GetOatMappingTableOffset() const {
146 DCHECK(!Runtime::Current()->IsStarted());
147 return reinterpret_cast<uint32_t>(GetMappingTableRaw());
148}
149
150inline void AbstractMethod::SetOatMappingTableOffset(uint32_t mapping_table_offset) {
151 DCHECK(!Runtime::Current()->IsStarted());
152 SetMappingTable(reinterpret_cast<const uint32_t*>(mapping_table_offset));
153}
154
155inline uint32_t AbstractMethod::GetOatVmapTableOffset() const {
156 DCHECK(!Runtime::Current()->IsStarted());
157 return reinterpret_cast<uint32_t>(GetVmapTableRaw());
158}
159
160inline void AbstractMethod::SetOatVmapTableOffset(uint32_t vmap_table_offset) {
161 DCHECK(!Runtime::Current()->IsStarted());
162 SetVmapTable(reinterpret_cast<uint16_t*>(vmap_table_offset));
163}
164
165inline void AbstractMethod::SetOatNativeGcMapOffset(uint32_t gc_map_offset) {
166 DCHECK(!Runtime::Current()->IsStarted());
167 SetNativeGcMap(reinterpret_cast<uint8_t*>(gc_map_offset));
168}
169
170inline uint32_t AbstractMethod::GetOatNativeGcMapOffset() const {
171 DCHECK(!Runtime::Current()->IsStarted());
172 return reinterpret_cast<uint32_t>(GetNativeGcMap());
173}
174
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800175inline bool AbstractMethod::IsRuntimeMethod() const {
176 return GetDexMethodIndex() == DexFile::kDexNoIndex16;
177}
178
179inline bool AbstractMethod::IsCalleeSaveMethod() const {
180 if (!IsRuntimeMethod()) {
181 return false;
182 }
183 Runtime* runtime = Runtime::Current();
184 bool result = false;
185 for (int i = 0; i < Runtime::kLastCalleeSaveType; i++) {
186 if (this == runtime->GetCalleeSaveMethod(Runtime::CalleeSaveType(i))) {
187 result = true;
188 break;
189 }
190 }
191 return result;
192}
193
194inline bool AbstractMethod::IsResolutionMethod() const {
195 bool result = this == Runtime::Current()->GetResolutionMethod();
196 // Check that if we do think it is phony it looks like the resolution method.
197 DCHECK(!result || IsRuntimeMethod());
198 return result;
199}
200} // namespace mirror
201} // namespace art
202
203#endif // ART_SRC_MIRROR_METHOD_INL_H_