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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
/*
* Copyright (C) 2018 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_LIBDEXFILE_DEX_CLASS_ACCESSOR_H_
#define ART_LIBDEXFILE_DEX_CLASS_ACCESSOR_H_
#include "base/utils.h"
#include "code_item_accessors.h"
#include "dex_file.h"
#include "invoke_type.h"
#include "method_reference.h"
#include "modifiers.h"
namespace art {
class ClassIteratorData;
// Classes to access Dex data.
class ClassAccessor {
private:
class BaseItem {
public:
uint32_t GetIndex() const {
return index_;
}
uint32_t GetAccessFlags() const {
return access_flags_;
}
bool IsFinal() const {
return (GetAccessFlags() & kAccFinal) != 0;
}
public:
uint32_t index_ = 0u;
uint32_t access_flags_ = 0u;
};
public:
// A decoded version of the method of a class_data_item.
class Method : public BaseItem {
public:
uint32_t GetCodeItemOffset() const {
return code_off_;
}
InvokeType GetInvokeType(uint32_t class_access_flags) const {
return is_static_or_direct_
? GetDirectMethodInvokeType()
: GetVirtualMethodInvokeType(class_access_flags);
}
MethodReference GetReference() const {
return MethodReference(&dex_file_, GetIndex());
}
CodeItemInstructionAccessor GetInstructions() const;
const DexFile::CodeItem* GetCodeItem() const;
private:
explicit Method(const DexFile& dex_file, bool is_static_or_direct)
: dex_file_(dex_file),
is_static_or_direct_(is_static_or_direct) {}
const uint8_t* Read(const uint8_t* ptr);
InvokeType GetDirectMethodInvokeType() const {
return (GetAccessFlags() & kAccStatic) != 0 ? kStatic : kDirect;
}
InvokeType GetVirtualMethodInvokeType(uint32_t class_access_flags) const {
DCHECK_EQ(GetAccessFlags() & kAccStatic, 0U);
if ((class_access_flags & kAccInterface) != 0) {
return kInterface;
} else if ((GetAccessFlags() & kAccConstructor) != 0) {
return kSuper;
} else {
return kVirtual;
}
}
const DexFile& dex_file_;
const bool is_static_or_direct_;
uint32_t code_off_ = 0u;
friend class ClassAccessor;
};
// A decoded version of the field of a class_data_item.
class Field : public BaseItem {
private:
const uint8_t* Read(const uint8_t* ptr);
friend class ClassAccessor;
};
// Not explicit specifically for range-based loops.
ALWAYS_INLINE ClassAccessor(const ClassIteratorData& data);
ClassAccessor(const DexFile& dex_file, const DexFile::ClassDef& class_def);
// Return the code item for a method.
const DexFile::CodeItem* GetCodeItem(const Method& method) const;
// Iterator data is not very iterator friendly, use visitors to get around this.
// No thread safety analysis since the visitor may require capabilities.
template <typename StaticFieldVisitor,
typename InstanceFieldVisitor,
typename DirectMethodVisitor,
typename VirtualMethodVisitor>
void VisitFieldsAndMethods(const StaticFieldVisitor& static_field_visitor,
const InstanceFieldVisitor& instance_field_visitor,
const DirectMethodVisitor& direct_method_visitor,
const VirtualMethodVisitor& virtual_method_visitor) const
NO_THREAD_SAFETY_ANALYSIS;
template <typename DirectMethodVisitor,
typename VirtualMethodVisitor>
void VisitMethods(const DirectMethodVisitor& direct_method_visitor,
const VirtualMethodVisitor& virtual_method_visitor) const;
template <typename StaticFieldVisitor,
typename InstanceFieldVisitor>
void VisitFields(const StaticFieldVisitor& static_field_visitor,
const InstanceFieldVisitor& instance_field_visitor) const;
// Visit direct and virtual methods.
template <typename MethodVisitor>
void VisitMethods(const MethodVisitor& method_visitor) const;
uint32_t NumStaticFields() const {
return num_static_fields_;
}
uint32_t NumInstanceFields() const {
return num_instance_fields_;
}
uint32_t NumDirectMethods() const {
return num_direct_methods_;
}
uint32_t NumVirtualMethods() const {
return num_virtual_methods_;
}
const char* GetDescriptor() const;
dex::TypeIndex GetClassIdx() const {
return descriptor_index_;
}
const DexFile& GetDexFile() const {
return dex_file_;
}
protected:
const DexFile& dex_file_;
const dex::TypeIndex descriptor_index_ = {};
const uint8_t* ptr_pos_ = nullptr; // Pointer into stream of class_data_item.
const uint32_t num_static_fields_ = 0u;
const uint32_t num_instance_fields_ = 0u;
const uint32_t num_direct_methods_ = 0u;
const uint32_t num_virtual_methods_ = 0u;
};
} // namespace art
#endif // ART_LIBDEXFILE_DEX_CLASS_ACCESSOR_H_
|