compiler_driver-inl.h revision 1a5337fff2cc6cb9d563c8b32aca75f485d23373 
1/*
2 * Copyright (C) 2012 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_COMPILER_DRIVER_COMPILER_DRIVER_INL_H_
18#define ART_COMPILER_DRIVER_COMPILER_DRIVER_INL_H_
19
20#include "compiler_driver.h"
21
22#include "art_field-inl.h"
23#include "art_method-inl.h"
24#include "base/enums.h"
25#include "class_linker-inl.h"
26#include "dex_compilation_unit.h"
27#include "mirror/class_loader.h"
28#include "mirror/dex_cache-inl.h"
29#include "scoped_thread_state_change-inl.h"
30#include "handle_scope-inl.h"
31
32namespace art {
33
34inline mirror::ClassLoader* CompilerDriver::GetClassLoader(const ScopedObjectAccess& soa,
35                                                           const DexCompilationUnit* mUnit) {
36  return soa.Decode<mirror::ClassLoader>(mUnit->GetClassLoader()).Ptr();
37}
38
39inline mirror::Class* CompilerDriver::ResolveClass(
40    const ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache,
41    Handle<mirror::ClassLoader> class_loader, uint16_t cls_index,
42    const DexCompilationUnit* mUnit) {
43  DCHECK_EQ(dex_cache->GetDexFile(), mUnit->GetDexFile());
44  DCHECK_EQ(class_loader.Get(), GetClassLoader(soa, mUnit));
45  mirror::Class* cls = mUnit->GetClassLinker()->ResolveType(
46      *mUnit->GetDexFile(), cls_index, dex_cache, class_loader);
47  DCHECK_EQ(cls == nullptr, soa.Self()->IsExceptionPending());
48  if (UNLIKELY(cls == nullptr)) {
49    // Clean up any exception left by type resolution.
50    soa.Self()->ClearException();
51  }
52  return cls;
53}
54
55inline mirror::Class* CompilerDriver::ResolveCompilingMethodsClass(
56    const ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache,
57    Handle<mirror::ClassLoader> class_loader, const DexCompilationUnit* mUnit) {
58  DCHECK_EQ(dex_cache->GetDexFile(), mUnit->GetDexFile());
59  DCHECK_EQ(class_loader.Get(), GetClassLoader(soa, mUnit));
60  const DexFile::MethodId& referrer_method_id =
61      mUnit->GetDexFile()->GetMethodId(mUnit->GetDexMethodIndex());
62  return ResolveClass(soa, dex_cache, class_loader, referrer_method_id.class_idx_, mUnit);
63}
64
65inline ArtField* CompilerDriver::ResolveFieldWithDexFile(
66    const ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache,
67    Handle<mirror::ClassLoader> class_loader, const DexFile* dex_file,
68    uint32_t field_idx, bool is_static) {
69  DCHECK_EQ(dex_cache->GetDexFile(), dex_file);
70  ArtField* resolved_field = Runtime::Current()->GetClassLinker()->ResolveField(
71      *dex_file, field_idx, dex_cache, class_loader, is_static);
72  DCHECK_EQ(resolved_field == nullptr, soa.Self()->IsExceptionPending());
73  if (UNLIKELY(resolved_field == nullptr)) {
74    // Clean up any exception left by type resolution.
75    soa.Self()->ClearException();
76    return nullptr;
77  }
78  if (UNLIKELY(resolved_field->IsStatic() != is_static)) {
79    // ClassLinker can return a field of the wrong kind directly from the DexCache.
80    // Silently return null on such incompatible class change.
81    return nullptr;
82  }
83  return resolved_field;
84}
85
86inline ArtField* CompilerDriver::ResolveField(
87    const ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache,
88    Handle<mirror::ClassLoader> class_loader, const DexCompilationUnit* mUnit,
89    uint32_t field_idx, bool is_static) {
90  DCHECK_EQ(class_loader.Get(), GetClassLoader(soa, mUnit));
91  return ResolveFieldWithDexFile(soa, dex_cache, class_loader, mUnit->GetDexFile(), field_idx,
92                                 is_static);
93}
94
95inline std::pair<bool, bool> CompilerDriver::IsFastInstanceField(
96    mirror::DexCache* dex_cache, mirror::Class* referrer_class,
97    ArtField* resolved_field, uint16_t field_idx) {
98  DCHECK(!resolved_field->IsStatic());
99  ObjPtr<mirror::Class> fields_class = resolved_field->GetDeclaringClass();
100  bool fast_get = referrer_class != nullptr &&
101      referrer_class->CanAccessResolvedField(fields_class,
102                                             resolved_field,
103                                             dex_cache,
104                                             field_idx);
105  bool fast_put = fast_get && (!resolved_field->IsFinal() || fields_class == referrer_class);
106  return std::make_pair(fast_get, fast_put);
107}
108
109template <typename ArtMember>
110inline bool CompilerDriver::CanAccessResolvedMember(mirror::Class* referrer_class ATTRIBUTE_UNUSED,
111                                                    mirror::Class* access_to ATTRIBUTE_UNUSED,
112                                                    ArtMember* member ATTRIBUTE_UNUSED,
113                                                    mirror::DexCache* dex_cache ATTRIBUTE_UNUSED,
114                                                    uint32_t field_idx ATTRIBUTE_UNUSED) {
115  // Not defined for ArtMember values other than ArtField or ArtMethod.
116  UNREACHABLE();
117}
118
119template <>
120inline bool CompilerDriver::CanAccessResolvedMember<ArtField>(mirror::Class* referrer_class,
121                                                              mirror::Class* access_to,
122                                                              ArtField* field,
123                                                              mirror::DexCache* dex_cache,
124                                                              uint32_t field_idx) {
125  return referrer_class->CanAccessResolvedField(access_to, field, dex_cache, field_idx);
126}
127
128template <>
129inline bool CompilerDriver::CanAccessResolvedMember<ArtMethod>(
130    mirror::Class* referrer_class,
131    mirror::Class* access_to,
132    ArtMethod* method,
133    mirror::DexCache* dex_cache,
134    uint32_t field_idx) {
135  return referrer_class->CanAccessResolvedMethod(access_to, method, dex_cache, field_idx);
136}
137
138template <typename ArtMember>
139inline std::pair<bool, bool> CompilerDriver::IsClassOfStaticMemberAvailableToReferrer(
140    mirror::DexCache* dex_cache,
141    mirror::Class* referrer_class,
142    ArtMember* resolved_member,
143    uint16_t member_idx,
144    uint32_t* storage_index) {
145  DCHECK(resolved_member->IsStatic());
146  if (LIKELY(referrer_class != nullptr)) {
147    ObjPtr<mirror::Class> members_class = resolved_member->GetDeclaringClass();
148    if (members_class == referrer_class) {
149      *storage_index = members_class->GetDexTypeIndex();
150      return std::make_pair(true, true);
151    }
152    if (CanAccessResolvedMember<ArtMember>(
153        referrer_class, members_class.Ptr(), resolved_member, dex_cache, member_idx)) {
154      // We have the resolved member, we must make it into a index for the referrer
155      // in its static storage (which may fail if it doesn't have a slot for it)
156      // TODO: for images we can elide the static storage base null check
157      // if we know there's a non-null entry in the image
158      const DexFile* dex_file = dex_cache->GetDexFile();
159      uint32_t storage_idx = DexFile::kDexNoIndex;
160      if (LIKELY(members_class->GetDexCache() == dex_cache)) {
161        // common case where the dex cache of both the referrer and the member are the same,
162        // no need to search the dex file
163        storage_idx = members_class->GetDexTypeIndex();
164      } else {
165        // Search dex file for localized ssb index, may fail if member's class is a parent
166        // of the class mentioned in the dex file and there is no dex cache entry.
167        storage_idx = resolved_member->GetDeclaringClass()->FindTypeIndexInOtherDexFile(*dex_file);
168      }
169      if (storage_idx != DexFile::kDexNoIndex) {
170        *storage_index = storage_idx;
171        return std::make_pair(true, !resolved_member->IsFinal());
172      }
173    }
174  }
175  // Conservative defaults.
176  *storage_index = DexFile::kDexNoIndex;
177  return std::make_pair(false, false);
178}
179
180inline std::pair<bool, bool> CompilerDriver::IsFastStaticField(
181    mirror::DexCache* dex_cache, mirror::Class* referrer_class,
182    ArtField* resolved_field, uint16_t field_idx, uint32_t* storage_index) {
183  return IsClassOfStaticMemberAvailableToReferrer(
184      dex_cache, referrer_class, resolved_field, field_idx, storage_index);
185}
186
187inline bool CompilerDriver::IsClassOfStaticMethodAvailableToReferrer(
188    mirror::DexCache* dex_cache, mirror::Class* referrer_class,
189    ArtMethod* resolved_method, uint16_t method_idx, uint32_t* storage_index) {
190  std::pair<bool, bool> result = IsClassOfStaticMemberAvailableToReferrer(
191      dex_cache, referrer_class, resolved_method, method_idx, storage_index);
192  // Only the first member of `result` is meaningful, as there is no
193  // "write access" to a method.
194  return result.first;
195}
196
197inline ArtMethod* CompilerDriver::ResolveMethod(
198    ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache,
199    Handle<mirror::ClassLoader> class_loader, const DexCompilationUnit* mUnit,
200    uint32_t method_idx, InvokeType invoke_type, bool check_incompatible_class_change) {
201  DCHECK_EQ(class_loader.Get(), GetClassLoader(soa, mUnit));
202  ArtMethod* resolved_method =
203      check_incompatible_class_change
204          ? mUnit->GetClassLinker()->ResolveMethod<ClassLinker::kForceICCECheck>(
205              *dex_cache->GetDexFile(), method_idx, dex_cache, class_loader, nullptr, invoke_type)
206          : mUnit->GetClassLinker()->ResolveMethod<ClassLinker::kNoICCECheckForCache>(
207              *dex_cache->GetDexFile(), method_idx, dex_cache, class_loader, nullptr, invoke_type);
208  if (UNLIKELY(resolved_method == nullptr)) {
209    DCHECK(soa.Self()->IsExceptionPending());
210    // Clean up any exception left by type resolution.
211    soa.Self()->ClearException();
212  }
213  return resolved_method;
214}
215
216}  // namespace art
217
218#endif  // ART_COMPILER_DRIVER_COMPILER_DRIVER_INL_H_
219