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
|
/*
* Copyright (C) 2011 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_REFLECTION_H_
#define ART_RUNTIME_REFLECTION_H_
#include "base/locks.h"
#include "dex/primitive.h"
#include "jni.h"
#include "obj_ptr.h"
namespace art {
namespace mirror {
class Class;
class Object;
} // namespace mirror
class ArtField;
class ArtMethod;
union JValue;
class ScopedObjectAccessAlreadyRunnable;
class ShadowFrame;
ObjPtr<mirror::Object> BoxPrimitive(Primitive::Type src_class, const JValue& value)
REQUIRES_SHARED(Locks::mutator_lock_);
bool UnboxPrimitiveForField(ObjPtr<mirror::Object> o,
ObjPtr<mirror::Class> dst_class,
ArtField* f,
JValue* unboxed_value)
REQUIRES_SHARED(Locks::mutator_lock_);
bool UnboxPrimitiveForResult(ObjPtr<mirror::Object> o,
ObjPtr<mirror::Class> dst_class,
JValue* unboxed_value)
REQUIRES_SHARED(Locks::mutator_lock_);
ALWAYS_INLINE bool ConvertPrimitiveValueNoThrow(Primitive::Type src_class,
Primitive::Type dst_class,
const JValue& src,
JValue* dst)
REQUIRES_SHARED(Locks::mutator_lock_);
ALWAYS_INLINE bool ConvertPrimitiveValue(bool unbox_for_result,
Primitive::Type src_class,
Primitive::Type dst_class,
const JValue& src,
JValue* dst)
REQUIRES_SHARED(Locks::mutator_lock_);
// Invokes the given method (either an ArtMethod or a jmethodID) with direct/static semantics.
template<typename MethodType>
JValue InvokeWithVarArgs(const ScopedObjectAccessAlreadyRunnable& soa,
jobject obj,
MethodType mid,
va_list args)
REQUIRES_SHARED(Locks::mutator_lock_);
// Invokes the given method (either an ArtMethod or a jmethodID) with reflection semantics.
template<typename MethodType>
JValue InvokeWithJValues(const ScopedObjectAccessAlreadyRunnable& soa,
jobject obj,
MethodType mid,
const jvalue* args)
REQUIRES_SHARED(Locks::mutator_lock_);
// Invokes the given method (either an ArtMethod or a jmethodID) with virtual/interface semantics.
// Note this will perform lookup based on the 'obj' to determine which implementation of the given
// method should be invoked.
template<typename MethodType>
JValue InvokeVirtualOrInterfaceWithJValues(const ScopedObjectAccessAlreadyRunnable& soa,
jobject obj,
MethodType mid,
const jvalue* args)
REQUIRES_SHARED(Locks::mutator_lock_);
// Invokes the given method (either an ArtMethod or a jmethodID) with virtual/interface semantics.
// Note this will perform lookup based on the 'obj' to determine which implementation of the given
// method should be invoked.
template<typename MethodType>
JValue InvokeVirtualOrInterfaceWithVarArgs(const ScopedObjectAccessAlreadyRunnable& soa,
jobject obj,
MethodType mid,
va_list args)
REQUIRES_SHARED(Locks::mutator_lock_);
// num_frames is number of frames we look up for access check.
jobject InvokeMethod(const ScopedObjectAccessAlreadyRunnable& soa,
jobject method,
jobject receiver,
jobject args,
size_t num_frames = 1)
REQUIRES_SHARED(Locks::mutator_lock_);
// Special-casing of the above. Assumes that the method is the correct constructor, the class is
// initialized, and that the receiver is an instance of the class.
void InvokeConstructor(const ScopedObjectAccessAlreadyRunnable& soa,
ArtMethod* constructor,
ObjPtr<mirror::Object> receiver,
jobject args)
REQUIRES_SHARED(Locks::mutator_lock_);
ALWAYS_INLINE bool VerifyObjectIsClass(ObjPtr<mirror::Object> o, ObjPtr<mirror::Class> c)
REQUIRES_SHARED(Locks::mutator_lock_);
bool VerifyAccess(Thread* self,
ObjPtr<mirror::Object> obj,
ObjPtr<mirror::Class> declaring_class,
uint32_t access_flags,
ObjPtr<mirror::Class>* calling_class,
size_t num_frames)
REQUIRES_SHARED(Locks::mutator_lock_);
// This version takes a known calling class.
bool VerifyAccess(ObjPtr<mirror::Object> obj,
ObjPtr<mirror::Class> declaring_class,
uint32_t access_flags,
ObjPtr<mirror::Class> calling_class)
REQUIRES_SHARED(Locks::mutator_lock_);
// Get the calling class by using a stack visitor, may return null for unattached native threads.
ObjPtr<mirror::Class> GetCallingClass(Thread* self, size_t num_frames)
REQUIRES_SHARED(Locks::mutator_lock_);
void InvalidReceiverError(ObjPtr<mirror::Object> o, ObjPtr<mirror::Class> c)
REQUIRES_SHARED(Locks::mutator_lock_);
void UpdateReference(Thread* self, jobject obj, ObjPtr<mirror::Object> result)
REQUIRES_SHARED(Locks::mutator_lock_);
} // namespace art
#endif // ART_RUNTIME_REFLECTION_H_
|
