1 /*
2  * Copyright (C) 2016 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 "method_handle_impl-inl.h"
18 
19 #include "class-alloc-inl.h"
20 #include "class_root-inl.h"
21 
22 namespace art {
23 namespace mirror {
24 
GetReturnTypeDescriptor(const char * invoke_method_name)25 const char* MethodHandle::GetReturnTypeDescriptor(const char* invoke_method_name) {
26   if (strcmp(invoke_method_name, "invoke") == 0 || strcmp(invoke_method_name, "invokeExact") == 0) {
27     return "Ljava/lang/Object;";
28   } else {
29     return nullptr;
30   }
31 }
32 
Initialize(uintptr_t art_field_or_method,Kind kind,Handle<MethodType> method_type)33 void MethodHandle::Initialize(uintptr_t art_field_or_method,
34                               Kind kind,
35                               Handle<MethodType> method_type)
36     REQUIRES_SHARED(Locks::mutator_lock_) {
37   CHECK(!Runtime::Current()->IsActiveTransaction());
38   SetFieldObject<false>(CachedSpreadInvokerOffset(), nullptr);
39   SetFieldObject<false>(NominalTypeOffset(), nullptr);
40   SetFieldObject<false>(MethodTypeOffset(), method_type.Get());
41   SetField32<false>(HandleKindOffset(), static_cast<uint32_t>(kind));
42   SetField64<false>(ArtFieldOrMethodOffset(), art_field_or_method);
43 }
44 
Create(Thread * const self,uintptr_t art_field_or_method,MethodHandle::Kind kind,Handle<MethodType> method_type)45 ObjPtr<mirror::MethodHandleImpl> MethodHandleImpl::Create(Thread* const self,
46                                                           uintptr_t art_field_or_method,
47                                                           MethodHandle::Kind kind,
48                                                           Handle<MethodType> method_type)
49     REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_) {
50   StackHandleScope<1> hs(self);
51   Handle<mirror::MethodHandleImpl> mh(hs.NewHandle(ObjPtr<MethodHandleImpl>::DownCast(
52       GetClassRoot<MethodHandleImpl>()->AllocObject(self))));
53   mh->Initialize(art_field_or_method, kind, method_type);
54   return mh.Get();
55 }
56 
VisitTarget(ReflectiveValueVisitor * v)57 void MethodHandle::VisitTarget(ReflectiveValueVisitor* v) {
58   void* target = GetTargetField();
59   void* result;
60   HeapReflectiveSourceInfo hrsi(kSourceJavaLangInvokeMethodHandle, this);
61   if (GetHandleKind() < kFirstAccessorKind) {
62     result = v->VisitMethod(GetTargetMethod(), hrsi);
63   } else {
64     result = v->VisitField(GetTargetField(), hrsi);
65   }
66   if (result != target) {
67     SetField64<false>(ArtFieldOrMethodOffset(), reinterpret_cast<uintptr_t>(result));
68   }
69 }
70 
71 
72 }  // namespace mirror
73 }  // namespace art
74