1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ART_RUNTIME_MIRROR_METHOD_HANDLE_IMPL_H_
#define ART_RUNTIME_MIRROR_METHOD_HANDLE_IMPL_H_
#include "art_field.h"
#include "art_method.h"
#include "class.h"
#include "method_type.h"
#include "obj_ptr.h"
#include "object.h"
namespace art {
struct MethodHandleOffsets;
struct MethodHandleImplOffsets;
class ReflectiveValueVisitor;
namespace mirror {
// C++ mirror of java.lang.invoke.MethodHandle
class MANAGED MethodHandle : public Object {
public:
// Defines the behaviour of a given method handle. The behaviour
// of a handle of a given kind is identical to the dex bytecode behaviour
// of the equivalent instruction.
//
// NOTE: These must be kept in sync with the constants defined in
// java.lang.invoke.MethodHandle.
enum Kind {
kInvokeVirtual = 0,
kInvokeSuper,
kInvokeDirect,
kInvokeStatic,
kInvokeInterface,
kInvokeTransform,
kInvokeCallSiteTransform,
kInvokeVarHandle,
kInvokeVarHandleExact,
kInstanceGet,
kInstancePut,
kStaticGet,
kStaticPut,
kLastValidKind = kStaticPut,
kFirstAccessorKind = kInstanceGet,
kLastAccessorKind = kStaticPut,
kLastInvokeKind = kInvokeVarHandleExact
};
Kind GetHandleKind() REQUIRES_SHARED(Locks::mutator_lock_) {
const int32_t handle_kind = GetField32(OFFSET_OF_OBJECT_MEMBER(MethodHandle, handle_kind_));
DCHECK(handle_kind >= 0 &&
handle_kind <= static_cast<int32_t>(Kind::kLastValidKind));
return static_cast<Kind>(handle_kind);
}
ALWAYS_INLINE ObjPtr<mirror::MethodType> GetMethodType() REQUIRES_SHARED(Locks::mutator_lock_);
ALWAYS_INLINE ObjPtr<mirror::MethodType> GetNominalType() REQUIRES_SHARED(Locks::mutator_lock_);
ArtField* GetTargetField() REQUIRES_SHARED(Locks::mutator_lock_) {
return reinterpret_cast<ArtField*>(
GetField64(OFFSET_OF_OBJECT_MEMBER(MethodHandle, art_field_or_method_)));
}
ArtMethod* GetTargetMethod() REQUIRES_SHARED(Locks::mutator_lock_) {
return reinterpret_cast<ArtMethod*>(
GetField64(OFFSET_OF_OBJECT_MEMBER(MethodHandle, art_field_or_method_)));
}
// Gets the return type for a named invoke method, or nullptr if the invoke method is not
// supported.
static const char* GetReturnTypeDescriptor(const char* invoke_method_name);
// Used when classes become structurally obsolete to change the MethodHandle to refer to the new
// method or field.
void VisitTarget(ReflectiveValueVisitor* v) REQUIRES(Locks::mutator_lock_);
protected:
void Initialize(uintptr_t art_field_or_method, Kind kind, Handle<MethodType> method_type)
REQUIRES_SHARED(Locks::mutator_lock_);
private:
HeapReference<mirror::MethodHandle> cached_spread_invoker_;
HeapReference<mirror::MethodType> nominal_type_;
HeapReference<mirror::MethodType> method_type_;
uint32_t handle_kind_;
uint64_t art_field_or_method_;
private:
static MemberOffset CachedSpreadInvokerOffset() {
return MemberOffset(OFFSETOF_MEMBER(MethodHandle, cached_spread_invoker_));
}
static MemberOffset NominalTypeOffset() {
return MemberOffset(OFFSETOF_MEMBER(MethodHandle, nominal_type_));
}
static MemberOffset MethodTypeOffset() {
return MemberOffset(OFFSETOF_MEMBER(MethodHandle, method_type_));
}
static MemberOffset ArtFieldOrMethodOffset() {
return MemberOffset(OFFSETOF_MEMBER(MethodHandle, art_field_or_method_));
}
static MemberOffset HandleKindOffset() {
return MemberOffset(OFFSETOF_MEMBER(MethodHandle, handle_kind_));
}
friend struct art::MethodHandleOffsets; // for verifying offset information
DISALLOW_IMPLICIT_CONSTRUCTORS(MethodHandle);
};
// C++ mirror of java.lang.invoke.MethodHandleImpl
class MANAGED MethodHandleImpl : public MethodHandle {
public:
static ObjPtr<mirror::MethodHandleImpl> Create(Thread* const self,
uintptr_t art_field_or_method,
MethodHandle::Kind kind,
Handle<MethodType> method_type)
REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
private:
static MemberOffset InfoOffset() {
return MemberOffset(OFFSETOF_MEMBER(MethodHandleImpl, info_));
}
HeapReference<mirror::Object> info_; // Unused by the runtime.
friend struct art::MethodHandleImplOffsets; // for verifying offset information
DISALLOW_IMPLICIT_CONSTRUCTORS(MethodHandleImpl);
};
} // namespace mirror
} // namespace art
#endif // ART_RUNTIME_MIRROR_METHOD_HANDLE_IMPL_H_
|
