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 "entrypoints/entrypoint_utils.h"
18 
19 #include "art_field-inl.h"
20 #include "art_method-inl.h"
21 #include "base/enums.h"
22 #include "base/mutex.h"
23 #include "base/sdk_version.h"
24 #include "class_linker-inl.h"
25 #include "dex/dex_file-inl.h"
26 #include "dex/method_reference.h"
27 #include "entrypoints/entrypoint_utils-inl.h"
28 #include "entrypoints/quick/callee_save_frame.h"
29 #include "entrypoints/runtime_asm_entrypoints.h"
30 #include "gc/accounting/card_table-inl.h"
31 #include "index_bss_mapping.h"
32 #include "jni/java_vm_ext.h"
33 #include "mirror/class-inl.h"
34 #include "mirror/method.h"
35 #include "mirror/object-inl.h"
36 #include "mirror/object_array-inl.h"
37 #include "nth_caller_visitor.h"
38 #include "oat_file.h"
39 #include "oat_quick_method_header.h"
40 #include "reflection.h"
41 #include "scoped_thread_state_change-inl.h"
42 #include "well_known_classes.h"
43 
44 namespace art {
45 
CheckReferenceResult(Handle<mirror::Object> o,Thread * self)46 void CheckReferenceResult(Handle<mirror::Object> o, Thread* self) {
47   if (o == nullptr) {
48     return;
49   }
50   // Make sure that the result is an instance of the type this method was expected to return.
51   ArtMethod* method = self->GetCurrentMethod(nullptr);
52   ObjPtr<mirror::Class> return_type = method->ResolveReturnType();
53 
54   if (!o->InstanceOf(return_type)) {
55     Runtime::Current()->GetJavaVM()->JniAbortF(nullptr,
56                                                "attempt to return an instance of %s from %s",
57                                                o->PrettyTypeOf().c_str(),
58                                                method->PrettyMethod().c_str());
59   }
60 }
61 
InvokeProxyInvocationHandler(ScopedObjectAccessAlreadyRunnable & soa,const char * shorty,jobject rcvr_jobj,jobject interface_method_jobj,std::vector<jvalue> & args)62 JValue InvokeProxyInvocationHandler(ScopedObjectAccessAlreadyRunnable& soa,
63                                     const char* shorty,
64                                     jobject rcvr_jobj,
65                                     jobject interface_method_jobj,
66                                     std::vector<jvalue>& args) {
67   DCHECK(soa.Env()->IsInstanceOf(rcvr_jobj, WellKnownClasses::java_lang_reflect_Proxy));
68 
69   // Build argument array possibly triggering GC.
70   soa.Self()->AssertThreadSuspensionIsAllowable();
71   jobjectArray args_jobj = nullptr;
72   const JValue zero;
73   uint32_t target_sdk_version = Runtime::Current()->GetTargetSdkVersion();
74   // Do not create empty arrays unless needed to maintain Dalvik bug compatibility.
75   if (args.size() > 0 || IsSdkVersionSetAndAtMost(target_sdk_version, SdkVersion::kL)) {
76     args_jobj = soa.Env()->NewObjectArray(args.size(), WellKnownClasses::java_lang_Object, nullptr);
77     if (args_jobj == nullptr) {
78       CHECK(soa.Self()->IsExceptionPending());
79       return zero;
80     }
81     for (size_t i = 0; i < args.size(); ++i) {
82       if (shorty[i + 1] == 'L') {
83         jobject val = args[i].l;
84         soa.Env()->SetObjectArrayElement(args_jobj, i, val);
85       } else {
86         JValue jv;
87         jv.SetJ(args[i].j);
88         ObjPtr<mirror::Object> val = BoxPrimitive(Primitive::GetType(shorty[i + 1]), jv);
89         if (val == nullptr) {
90           CHECK(soa.Self()->IsExceptionPending());
91           return zero;
92         }
93         soa.Decode<mirror::ObjectArray<mirror::Object>>(args_jobj)->Set<false>(i, val);
94       }
95     }
96   }
97 
98   // Call Proxy.invoke(Proxy proxy, Method method, Object[] args).
99   jvalue invocation_args[3];
100   invocation_args[0].l = rcvr_jobj;
101   invocation_args[1].l = interface_method_jobj;
102   invocation_args[2].l = args_jobj;
103   jobject result =
104       soa.Env()->CallStaticObjectMethodA(WellKnownClasses::java_lang_reflect_Proxy,
105                                          WellKnownClasses::java_lang_reflect_Proxy_invoke,
106                                          invocation_args);
107 
108   // Unbox result and handle error conditions.
109   if (LIKELY(!soa.Self()->IsExceptionPending())) {
110     if (shorty[0] == 'V' || (shorty[0] == 'L' && result == nullptr)) {
111       // Do nothing.
112       return zero;
113     } else {
114       ArtMethod* interface_method =
115           soa.Decode<mirror::Method>(interface_method_jobj)->GetArtMethod();
116       // This can cause thread suspension.
117       ObjPtr<mirror::Class> result_type = interface_method->ResolveReturnType();
118       ObjPtr<mirror::Object> result_ref = soa.Decode<mirror::Object>(result);
119       JValue result_unboxed;
120       if (!UnboxPrimitiveForResult(result_ref, result_type, &result_unboxed)) {
121         DCHECK(soa.Self()->IsExceptionPending());
122         return zero;
123       }
124       return result_unboxed;
125     }
126   } else {
127     // In the case of checked exceptions that aren't declared, the exception must be wrapped by
128     // a UndeclaredThrowableException.
129     ObjPtr<mirror::Throwable> exception = soa.Self()->GetException();
130     if (exception->IsCheckedException()) {
131       bool declares_exception = false;
132       {
133         ScopedAssertNoThreadSuspension ants(__FUNCTION__);
134         ObjPtr<mirror::Object> rcvr = soa.Decode<mirror::Object>(rcvr_jobj);
135         ObjPtr<mirror::Class> proxy_class = rcvr->GetClass();
136         ObjPtr<mirror::Method> interface_method = soa.Decode<mirror::Method>(interface_method_jobj);
137         ArtMethod* proxy_method = rcvr->GetClass()->FindVirtualMethodForInterface(
138             interface_method->GetArtMethod(), kRuntimePointerSize);
139         auto virtual_methods = proxy_class->GetVirtualMethodsSlice(kRuntimePointerSize);
140         size_t num_virtuals = proxy_class->NumVirtualMethods();
141         size_t method_size = ArtMethod::Size(kRuntimePointerSize);
142         // Rely on the fact that the methods are contiguous to determine the index of the method in
143         // the slice.
144         int throws_index = (reinterpret_cast<uintptr_t>(proxy_method) -
145             reinterpret_cast<uintptr_t>(&virtual_methods[0])) / method_size;
146         CHECK_LT(throws_index, static_cast<int>(num_virtuals));
147         ObjPtr<mirror::ObjectArray<mirror::Class>> declared_exceptions =
148             proxy_class->GetProxyThrows()->Get(throws_index);
149         ObjPtr<mirror::Class> exception_class = exception->GetClass();
150         for (int32_t i = 0; i < declared_exceptions->GetLength() && !declares_exception; i++) {
151           ObjPtr<mirror::Class> declared_exception = declared_exceptions->Get(i);
152           declares_exception = declared_exception->IsAssignableFrom(exception_class);
153         }
154       }
155       if (!declares_exception) {
156         soa.Self()->ThrowNewWrappedException("Ljava/lang/reflect/UndeclaredThrowableException;",
157                                              nullptr);
158       }
159     }
160     return zero;
161   }
162 }
163 
FillArrayData(ObjPtr<mirror::Object> obj,const Instruction::ArrayDataPayload * payload)164 bool FillArrayData(ObjPtr<mirror::Object> obj, const Instruction::ArrayDataPayload* payload) {
165   DCHECK_EQ(payload->ident, static_cast<uint16_t>(Instruction::kArrayDataSignature));
166   if (UNLIKELY(obj == nullptr)) {
167     ThrowNullPointerException("null array in FILL_ARRAY_DATA");
168     return false;
169   }
170   ObjPtr<mirror::Array> array = obj->AsArray();
171   DCHECK(!array->IsObjectArray());
172   if (UNLIKELY(static_cast<int32_t>(payload->element_count) > array->GetLength())) {
173     Thread* self = Thread::Current();
174     self->ThrowNewExceptionF("Ljava/lang/ArrayIndexOutOfBoundsException;",
175                              "failed FILL_ARRAY_DATA; length=%d, index=%d",
176                              array->GetLength(), payload->element_count);
177     return false;
178   }
179   // Copy data from dex file to memory assuming both are little endian.
180   uint32_t size_in_bytes = payload->element_count * payload->element_width;
181   memcpy(array->GetRawData(payload->element_width, 0), payload->data, size_in_bytes);
182   return true;
183 }
184 
DoGetCalleeSaveMethodOuterCallerAndPc(ArtMethod ** sp,CalleeSaveType type)185 static inline std::pair<ArtMethod*, uintptr_t> DoGetCalleeSaveMethodOuterCallerAndPc(
186     ArtMethod** sp, CalleeSaveType type) REQUIRES_SHARED(Locks::mutator_lock_) {
187   DCHECK_EQ(*sp, Runtime::Current()->GetCalleeSaveMethod(type));
188 
189   const size_t callee_frame_size = RuntimeCalleeSaveFrame::GetFrameSize(type);
190   auto** caller_sp = reinterpret_cast<ArtMethod**>(
191       reinterpret_cast<uintptr_t>(sp) + callee_frame_size);
192   const size_t callee_return_pc_offset = RuntimeCalleeSaveFrame::GetReturnPcOffset(type);
193   uintptr_t caller_pc = *reinterpret_cast<uintptr_t*>(
194       (reinterpret_cast<uint8_t*>(sp) + callee_return_pc_offset));
195   ArtMethod* outer_method = *caller_sp;
196   return std::make_pair(outer_method, caller_pc);
197 }
198 
DoGetCalleeSaveMethodCaller(ArtMethod * outer_method,uintptr_t caller_pc,bool do_caller_check)199 static inline ArtMethod* DoGetCalleeSaveMethodCaller(ArtMethod* outer_method,
200                                                      uintptr_t caller_pc,
201                                                      bool do_caller_check)
202     REQUIRES_SHARED(Locks::mutator_lock_) {
203   ArtMethod* caller = outer_method;
204   if (LIKELY(caller_pc != reinterpret_cast<uintptr_t>(GetQuickInstrumentationExitPc()))) {
205     if (outer_method != nullptr) {
206       const OatQuickMethodHeader* current_code = outer_method->GetOatQuickMethodHeader(caller_pc);
207       DCHECK(current_code != nullptr);
208       if (current_code->IsOptimized() &&
209           CodeInfo::HasInlineInfo(current_code->GetOptimizedCodeInfoPtr())) {
210         uintptr_t native_pc_offset = current_code->NativeQuickPcOffset(caller_pc);
211         CodeInfo code_info = CodeInfo::DecodeInlineInfoOnly(current_code);
212         StackMap stack_map = code_info.GetStackMapForNativePcOffset(native_pc_offset);
213         DCHECK(stack_map.IsValid());
214         BitTableRange<InlineInfo> inline_infos = code_info.GetInlineInfosOf(stack_map);
215         if (!inline_infos.empty()) {
216           caller = GetResolvedMethod(outer_method, code_info, inline_infos);
217         }
218       }
219     }
220     if (kIsDebugBuild && do_caller_check) {
221       // Note that do_caller_check is optional, as this method can be called by
222       // stubs, and tests without a proper call stack.
223       NthCallerVisitor visitor(Thread::Current(), 1, true);
224       visitor.WalkStack();
225       CHECK_EQ(caller, visitor.caller);
226     }
227   } else {
228     // We're instrumenting, just use the StackVisitor which knows how to
229     // handle instrumented frames.
230     NthCallerVisitor visitor(Thread::Current(), 1, true);
231     visitor.WalkStack();
232     caller = visitor.caller;
233   }
234   return caller;
235 }
236 
GetCalleeSaveMethodCaller(ArtMethod ** sp,CalleeSaveType type,bool do_caller_check)237 ArtMethod* GetCalleeSaveMethodCaller(ArtMethod** sp, CalleeSaveType type, bool do_caller_check)
238     REQUIRES_SHARED(Locks::mutator_lock_) {
239   ScopedAssertNoThreadSuspension ants(__FUNCTION__);
240   auto outer_caller_and_pc = DoGetCalleeSaveMethodOuterCallerAndPc(sp, type);
241   ArtMethod* outer_method = outer_caller_and_pc.first;
242   uintptr_t caller_pc = outer_caller_and_pc.second;
243   ArtMethod* caller = DoGetCalleeSaveMethodCaller(outer_method, caller_pc, do_caller_check);
244   return caller;
245 }
246 
GetCalleeSaveMethodCallerAndOuterMethod(Thread * self,CalleeSaveType type)247 CallerAndOuterMethod GetCalleeSaveMethodCallerAndOuterMethod(Thread* self, CalleeSaveType type) {
248   CallerAndOuterMethod result;
249   ScopedAssertNoThreadSuspension ants(__FUNCTION__);
250   ArtMethod** sp = self->GetManagedStack()->GetTopQuickFrameKnownNotTagged();
251   auto outer_caller_and_pc = DoGetCalleeSaveMethodOuterCallerAndPc(sp, type);
252   result.outer_method = outer_caller_and_pc.first;
253   uintptr_t caller_pc = outer_caller_and_pc.second;
254   result.caller =
255       DoGetCalleeSaveMethodCaller(result.outer_method, caller_pc, /* do_caller_check= */ true);
256   return result;
257 }
258 
GetCalleeSaveOuterMethod(Thread * self,CalleeSaveType type)259 ArtMethod* GetCalleeSaveOuterMethod(Thread* self, CalleeSaveType type) {
260   ScopedAssertNoThreadSuspension ants(__FUNCTION__);
261   ArtMethod** sp = self->GetManagedStack()->GetTopQuickFrameKnownNotTagged();
262   return DoGetCalleeSaveMethodOuterCallerAndPc(sp, type).first;
263 }
264 
ResolveMethodHandleFromCode(ArtMethod * referrer,uint32_t method_handle_idx)265 ObjPtr<mirror::MethodHandle> ResolveMethodHandleFromCode(ArtMethod* referrer,
266                                                          uint32_t method_handle_idx) {
267   Thread::PoisonObjectPointersIfDebug();
268   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
269   return class_linker->ResolveMethodHandle(Thread::Current(), method_handle_idx, referrer);
270 }
271 
ResolveMethodTypeFromCode(ArtMethod * referrer,dex::ProtoIndex proto_idx)272 ObjPtr<mirror::MethodType> ResolveMethodTypeFromCode(ArtMethod* referrer,
273                                                      dex::ProtoIndex proto_idx) {
274   Thread::PoisonObjectPointersIfDebug();
275   ObjPtr<mirror::MethodType> method_type =
276       referrer->GetDexCache()->GetResolvedMethodType(proto_idx);
277   if (UNLIKELY(method_type == nullptr)) {
278     StackHandleScope<2> hs(Thread::Current());
279     Handle<mirror::DexCache> dex_cache(hs.NewHandle(referrer->GetDexCache()));
280     Handle<mirror::ClassLoader> class_loader(hs.NewHandle(referrer->GetClassLoader()));
281     ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
282     method_type = class_linker->ResolveMethodType(hs.Self(), proto_idx, dex_cache, class_loader);
283   }
284   return method_type;
285 }
286 
MaybeUpdateBssMethodEntry(ArtMethod * callee,MethodReference callee_reference)287 void MaybeUpdateBssMethodEntry(ArtMethod* callee, MethodReference callee_reference) {
288   DCHECK(callee != nullptr);
289   if (callee_reference.dex_file->GetOatDexFile() != nullptr) {
290     size_t bss_offset = IndexBssMappingLookup::GetBssOffset(
291         callee_reference.dex_file->GetOatDexFile()->GetMethodBssMapping(),
292         callee_reference.index,
293         callee_reference.dex_file->NumMethodIds(),
294         static_cast<size_t>(kRuntimePointerSize));
295     if (bss_offset != IndexBssMappingLookup::npos) {
296       DCHECK_ALIGNED(bss_offset, static_cast<size_t>(kRuntimePointerSize));
297       const OatFile* oat_file = callee_reference.dex_file->GetOatDexFile()->GetOatFile();
298       ArtMethod** method_entry = reinterpret_cast<ArtMethod**>(const_cast<uint8_t*>(
299           oat_file->BssBegin() + bss_offset));
300       DCHECK_GE(method_entry, oat_file->GetBssMethods().data());
301       DCHECK_LT(method_entry,
302                 oat_file->GetBssMethods().data() + oat_file->GetBssMethods().size());
303       std::atomic<ArtMethod*>* atomic_entry =
304           reinterpret_cast<std::atomic<ArtMethod*>*>(method_entry);
305       static_assert(sizeof(*method_entry) == sizeof(*atomic_entry), "Size check.");
306       atomic_entry->store(callee, std::memory_order_release);
307     }
308   }
309 }
310 
311 }  // namespace art
312