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 #include "art_method-inl.h"
18 #include "base/callee_save_type.h"
19 #include "callee_save_frame.h"
20 #include "class_linker-inl.h"
21 #include "class_table-inl.h"
22 #include "dex/dex_file-inl.h"
23 #include "dex/dex_file_types.h"
24 #include "entrypoints/entrypoint_utils-inl.h"
25 #include "gc/heap.h"
26 #include "mirror/class-inl.h"
27 #include "mirror/class_loader.h"
28 #include "mirror/object-inl.h"
29 #include "mirror/object_array-inl.h"
30 #include "oat_file.h"
31 #include "runtime.h"
32
33 namespace art {
34
StoreObjectInBss(ArtMethod * outer_method,const OatFile * oat_file,size_t bss_offset,ObjPtr<mirror::Object> object)35 static void StoreObjectInBss(ArtMethod* outer_method,
36 const OatFile* oat_file,
37 size_t bss_offset,
38 ObjPtr<mirror::Object> object) REQUIRES_SHARED(Locks::mutator_lock_) {
39 // Used for storing Class or String in .bss GC roots.
40 static_assert(sizeof(GcRoot<mirror::Class>) == sizeof(GcRoot<mirror::Object>), "Size check.");
41 static_assert(sizeof(GcRoot<mirror::String>) == sizeof(GcRoot<mirror::Object>), "Size check.");
42 DCHECK_NE(bss_offset, IndexBssMappingLookup::npos);
43 DCHECK_ALIGNED(bss_offset, sizeof(GcRoot<mirror::Object>));
44 if (UNLIKELY(!oat_file->IsExecutable())) {
45 // There are situations where we execute bytecode tied to an oat file opened
46 // as non-executable (i.e. the AOT-compiled code cannot be executed) and we
47 // can JIT that bytecode and get here without the .bss being mmapped.
48 return;
49 }
50 GcRoot<mirror::Object>* slot = reinterpret_cast<GcRoot<mirror::Object>*>(
51 const_cast<uint8_t*>(oat_file->BssBegin() + bss_offset));
52 DCHECK_GE(slot, oat_file->GetBssGcRoots().data());
53 DCHECK_LT(slot, oat_file->GetBssGcRoots().data() + oat_file->GetBssGcRoots().size());
54 if (slot->IsNull()) {
55 // This may race with another thread trying to store the very same value but that's OK.
56 std::atomic<GcRoot<mirror::Object>>* atomic_slot =
57 reinterpret_cast<std::atomic<GcRoot<mirror::Object>>*>(slot);
58 static_assert(sizeof(*slot) == sizeof(*atomic_slot), "Size check");
59 atomic_slot->store(GcRoot<mirror::Object>(object), std::memory_order_release);
60 // We need a write barrier for the class loader that holds the GC roots in the .bss.
61 ObjPtr<mirror::ClassLoader> class_loader = outer_method->GetClassLoader();
62 Runtime* runtime = Runtime::Current();
63 if (kIsDebugBuild) {
64 ClassTable* class_table = runtime->GetClassLinker()->ClassTableForClassLoader(class_loader);
65 CHECK(class_table != nullptr && !class_table->InsertOatFile(oat_file))
66 << "Oat file with .bss GC roots was not registered in class table: "
67 << oat_file->GetLocation();
68 }
69 if (class_loader != nullptr) {
70 WriteBarrier::ForEveryFieldWrite(class_loader);
71 } else {
72 runtime->GetClassLinker()->WriteBarrierForBootOatFileBssRoots(oat_file);
73 }
74 } else {
75 // Each slot serves to store exactly one Class or String.
76 DCHECK_EQ(object, slot->Read());
77 }
78 }
79
StoreTypeInBss(ArtMethod * outer_method,dex::TypeIndex type_idx,ObjPtr<mirror::Class> resolved_type)80 static inline void StoreTypeInBss(ArtMethod* outer_method,
81 dex::TypeIndex type_idx,
82 ObjPtr<mirror::Class> resolved_type)
83 REQUIRES_SHARED(Locks::mutator_lock_) {
84 const DexFile* dex_file = outer_method->GetDexFile();
85 DCHECK(dex_file != nullptr);
86 const OatDexFile* oat_dex_file = dex_file->GetOatDexFile();
87 if (oat_dex_file != nullptr) {
88 auto store = [=](const IndexBssMapping* mapping) REQUIRES_SHARED(Locks::mutator_lock_) {
89 size_t bss_offset = IndexBssMappingLookup::GetBssOffset(mapping,
90 type_idx.index_,
91 dex_file->NumTypeIds(),
92 sizeof(GcRoot<mirror::Class>));
93 if (bss_offset != IndexBssMappingLookup::npos) {
94 StoreObjectInBss(outer_method, oat_dex_file->GetOatFile(), bss_offset, resolved_type);
95 }
96 };
97 store(oat_dex_file->GetTypeBssMapping());
98 if (resolved_type->IsPublic()) {
99 store(oat_dex_file->GetPublicTypeBssMapping());
100 }
101 if (resolved_type->IsPublic() ||
102 resolved_type->GetClassLoader() == outer_method->GetClassLoader()) {
103 store(oat_dex_file->GetPackageTypeBssMapping());
104 }
105 }
106 }
107
StoreStringInBss(ArtMethod * outer_method,dex::StringIndex string_idx,ObjPtr<mirror::String> resolved_string)108 static inline void StoreStringInBss(ArtMethod* outer_method,
109 dex::StringIndex string_idx,
110 ObjPtr<mirror::String> resolved_string)
111 REQUIRES_SHARED(Locks::mutator_lock_) {
112 const DexFile* dex_file = outer_method->GetDexFile();
113 DCHECK(dex_file != nullptr);
114 const OatDexFile* oat_dex_file = dex_file->GetOatDexFile();
115 if (oat_dex_file != nullptr) {
116 size_t bss_offset = IndexBssMappingLookup::GetBssOffset(oat_dex_file->GetStringBssMapping(),
117 string_idx.index_,
118 dex_file->NumStringIds(),
119 sizeof(GcRoot<mirror::Class>));
120 if (bss_offset != IndexBssMappingLookup::npos) {
121 StoreObjectInBss(outer_method, oat_dex_file->GetOatFile(), bss_offset, resolved_string);
122 }
123 }
124 }
125
CanReferenceBss(ArtMethod * outer_method,ArtMethod * caller)126 static ALWAYS_INLINE bool CanReferenceBss(ArtMethod* outer_method, ArtMethod* caller)
127 REQUIRES_SHARED(Locks::mutator_lock_) {
128 // .bss references are used only for AOT-compiled code and only when the instruction
129 // originates from the outer method's dex file and the type or string index is tied to
130 // that dex file. As we do not want to check if the call is coming from AOT-compiled
131 // code (that could be expensive), simply check if the caller has the same dex file.
132 //
133 // If we've accepted running AOT-compiled code despite the runtime class loader
134 // resolving the caller to a different dex file, this check shall prevent us from
135 // filling the .bss slot and we shall keep going through the slow path. This is slow
136 // but correct; we do not really care that much about performance in this odd case.
137 //
138 // JIT can inline throwing instructions across dex files and this check prevents
139 // looking up the index in the wrong dex file in that case. If the caller and outer
140 // method have the same dex file, we may or may not find a .bss slot to update;
141 // if we do, this can still benefit AOT-compiled code executed later.
142 return outer_method->GetDexFile() == caller->GetDexFile();
143 }
144
artInitializeStaticStorageFromCode(mirror::Class * klass,Thread * self)145 extern "C" mirror::Class* artInitializeStaticStorageFromCode(mirror::Class* klass, Thread* self)
146 REQUIRES_SHARED(Locks::mutator_lock_) {
147 // Called to ensure static storage base is initialized for direct static field reads and writes.
148 // A class may be accessing another class' fields when it doesn't have access, as access has been
149 // given by inheritance.
150 ScopedQuickEntrypointChecks sqec(self);
151 DCHECK(klass != nullptr);
152 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
153 StackHandleScope<1> hs(self);
154 Handle<mirror::Class> h_klass = hs.NewHandle(klass);
155 bool success = class_linker->EnsureInitialized(
156 self, h_klass, /* can_init_fields= */ true, /* can_init_parents= */ true);
157 if (UNLIKELY(!success)) {
158 return nullptr;
159 }
160 return h_klass.Get();
161 }
162
artResolveTypeFromCode(uint32_t type_idx,Thread * self)163 extern "C" mirror::Class* artResolveTypeFromCode(uint32_t type_idx, Thread* self)
164 REQUIRES_SHARED(Locks::mutator_lock_) {
165 // Called when the .bss slot was empty or for main-path runtime call.
166 ScopedQuickEntrypointChecks sqec(self);
167 auto caller_and_outer = GetCalleeSaveMethodCallerAndOuterMethod(
168 self, CalleeSaveType::kSaveEverythingForClinit);
169 ArtMethod* caller = caller_and_outer.caller;
170 ObjPtr<mirror::Class> result = ResolveVerifyAndClinit(dex::TypeIndex(type_idx),
171 caller,
172 self,
173 /* can_run_clinit= */ false,
174 /* verify_access= */ false);
175 if (LIKELY(result != nullptr) && CanReferenceBss(caller_and_outer.outer_method, caller)) {
176 StoreTypeInBss(caller_and_outer.outer_method, dex::TypeIndex(type_idx), result);
177 }
178 return result.Ptr();
179 }
180
artResolveTypeAndVerifyAccessFromCode(uint32_t type_idx,Thread * self)181 extern "C" mirror::Class* artResolveTypeAndVerifyAccessFromCode(uint32_t type_idx, Thread* self)
182 REQUIRES_SHARED(Locks::mutator_lock_) {
183 // Called when caller isn't guaranteed to have access to a type.
184 ScopedQuickEntrypointChecks sqec(self);
185 auto caller_and_outer = GetCalleeSaveMethodCallerAndOuterMethod(self,
186 CalleeSaveType::kSaveEverything);
187 ArtMethod* caller = caller_and_outer.caller;
188 ObjPtr<mirror::Class> result = ResolveVerifyAndClinit(dex::TypeIndex(type_idx),
189 caller,
190 self,
191 /* can_run_clinit= */ false,
192 /* verify_access= */ true);
193 if (LIKELY(result != nullptr) && CanReferenceBss(caller_and_outer.outer_method, caller)) {
194 StoreTypeInBss(caller_and_outer.outer_method, dex::TypeIndex(type_idx), result);
195 }
196 return result.Ptr();
197 }
198
artResolveMethodHandleFromCode(uint32_t method_handle_idx,Thread * self)199 extern "C" mirror::MethodHandle* artResolveMethodHandleFromCode(uint32_t method_handle_idx,
200 Thread* self)
201 REQUIRES_SHARED(Locks::mutator_lock_) {
202 ScopedQuickEntrypointChecks sqec(self);
203 auto caller_and_outer =
204 GetCalleeSaveMethodCallerAndOuterMethod(self, CalleeSaveType::kSaveEverything);
205 ArtMethod* caller = caller_and_outer.caller;
206 ObjPtr<mirror::MethodHandle> result = ResolveMethodHandleFromCode(caller, method_handle_idx);
207 return result.Ptr();
208 }
209
artResolveMethodTypeFromCode(uint32_t proto_idx,Thread * self)210 extern "C" mirror::MethodType* artResolveMethodTypeFromCode(uint32_t proto_idx, Thread* self)
211 REQUIRES_SHARED(Locks::mutator_lock_) {
212 ScopedQuickEntrypointChecks sqec(self);
213 auto caller_and_outer = GetCalleeSaveMethodCallerAndOuterMethod(self,
214 CalleeSaveType::kSaveEverything);
215 ArtMethod* caller = caller_and_outer.caller;
216 ObjPtr<mirror::MethodType> result = ResolveMethodTypeFromCode(caller, dex::ProtoIndex(proto_idx));
217 return result.Ptr();
218 }
219
artResolveStringFromCode(int32_t string_idx,Thread * self)220 extern "C" mirror::String* artResolveStringFromCode(int32_t string_idx, Thread* self)
221 REQUIRES_SHARED(Locks::mutator_lock_) {
222 ScopedQuickEntrypointChecks sqec(self);
223 auto caller_and_outer = GetCalleeSaveMethodCallerAndOuterMethod(self,
224 CalleeSaveType::kSaveEverything);
225 ArtMethod* caller = caller_and_outer.caller;
226 ObjPtr<mirror::String> result =
227 Runtime::Current()->GetClassLinker()->ResolveString(dex::StringIndex(string_idx), caller);
228 if (LIKELY(result != nullptr) && CanReferenceBss(caller_and_outer.outer_method, caller)) {
229 StoreStringInBss(caller_and_outer.outer_method, dex::StringIndex(string_idx), result);
230 }
231 return result.Ptr();
232 }
233
234 } // namespace art
235