#include <cha.h>
Definition at line 25 of file cha.h.
◆ CHA()
dart::CHA::CHA |
( |
Thread * |
thread | ) |
|
|
inlineexplicit |
Definition at line 27 of file cha.h.
28 : thread_(thread), guarded_classes_(thread->zone(), 1) {}
◆ AddToGuardedClassesForImplementorCid()
void dart::CHA::AddToGuardedClassesForImplementorCid |
( |
const Class & |
cls, |
|
|
intptr_t |
implementor_cid |
|
) |
| |
Definition at line 46 of file cha.cc.
47 {
50 AddToGuardedClasses(cls, -1, implementor_cid, false);
51}
◆ AddToGuardedClassesForSubclassCount()
void dart::CHA::AddToGuardedClassesForSubclassCount |
( |
const Class & |
cls, |
|
|
intptr_t |
subclass_count |
|
) |
| |
Definition at line 40 of file cha.cc.
41 {
42 ASSERT(subclass_count >= 0);
43 AddToGuardedClasses(cls, subclass_count,
kIllegalCid,
false);
44}
◆ AddToGuardedClassesToTrackFuture()
void dart::CHA::AddToGuardedClassesToTrackFuture |
( |
const Class & |
cls | ) |
|
◆ ClassCanBeFuture()
bool dart::CHA::ClassCanBeFuture |
( |
const Class & |
cls | ) |
|
|
static |
Definition at line 154 of file cha.cc.
154 {
155 if (cls.can_be_future()) {
156 return true;
157 }
158
159
160
161
162
163
165 if (FLAG_use_cha_deopt || thread->isolate_group()->all_classes_finalized()) {
166 if (FLAG_use_cha_deopt) {
167 CHA& cha = thread->compiler_state().cha();
168 cha.AddToGuardedClassesToTrackFuture(cls);
169 }
170 return false;
171 }
172
173
174 return true;
175}
static Thread * Current()
◆ ConcreteSubclasses()
bool dart::CHA::ConcreteSubclasses |
( |
const Class & |
cls, |
|
|
GrowableArray< intptr_t > * |
class_ids |
|
) |
| |
|
static |
Definition at line 90 of file cha.cc.
91 {
92 if (cls.InVMIsolateHeap()) return false;
93 if (cls.IsObjectClass()) return false;
94
95 if (!cls.is_abstract()) {
96 class_ids->
Add(cls.id());
97 }
98
99
100
101 ASSERT(FLAG_precompiled_mode);
102 const GrowableObjectArray& direct_subclasses =
104 if (direct_subclasses.IsNull()) {
105 return true;
106 }
108 for (intptr_t i = 0; i < direct_subclasses.Length(); i++) {
109 subclass ^= direct_subclasses.At(i);
111 return false;
112 }
113 }
114 return true;
115}
static bool ConcreteSubclasses(const Class &cls, GrowableArray< intptr_t > *class_ids)
◆ HasOverride()
bool dart::CHA::HasOverride |
( |
const Class & |
cls, |
|
|
const String & |
function_name, |
|
|
intptr_t * |
subclass_count |
|
) |
| |
Definition at line 221 of file cha.cc.
223 {
224
225
226
227
228 if (cls.InVMIsolateHeap()) return true;
229
230
231
232 if (cls.IsObjectClass()) {
233 return true;
234 }
235
237 const GrowableObjectArray& cls_direct_subclasses =
239 if (cls_direct_subclasses.IsNull()) {
240 return false;
241 }
243 for (intptr_t i = 0; i < cls_direct_subclasses.Length(); i++) {
244 direct_subclass ^= cls_direct_subclasses.At(i);
245
246
247 if (!direct_subclass.is_finalized()) {
248 continue;
249 }
250
251 if (direct_subclass.LookupDynamicFunctionUnsafe(
function_name) !=
253 return true;
254 }
255
257 return true;
258 }
259
260 (*subclasses_count)++;
261 }
262
263 return false;
264}
bool HasOverride(const Class &cls, const String &function_name, intptr_t *subclass_count)
SafepointRwLock * program_lock()
IsolateGroup * isolate_group() const
const char *const function_name
◆ HasSingleConcreteImplementation()
bool dart::CHA::HasSingleConcreteImplementation |
( |
const Class & |
interface, |
|
|
intptr_t * |
implementation_cid |
|
) |
| |
|
static |
Definition at line 127 of file cha.cc.
128 {
129 intptr_t
cid = interface.implementor_cid();
131
133 return false;
134 }
135
137 if (FLAG_use_cha_deopt || thread->isolate_group()->all_classes_finalized()) {
138 if (FLAG_trace_cha) {
139 THR_Print(
" **(CHA) Type has one implementation: %s\n",
140 interface.ToCString());
141 }
142 if (FLAG_use_cha_deopt) {
143 CHA& cha = thread->compiler_state().cha();
144 cha.AddToGuardedClassesForImplementorCid(interface,
cid);
145 }
146 *implementation_cid =
cid;
147 return true;
148 } else {
150 return false;
151 }
152}
#define THR_Print(format,...)
◆ HasSubclasses() [1/2]
bool dart::CHA::HasSubclasses |
( |
const Class & |
cls | ) |
|
|
static |
Definition at line 64 of file cha.cc.
64 {
67
68
69
70
71 if (cls.InVMIsolateHeap()) return true;
72
73 if (cls.IsObjectClass()) {
74
75 return true;
76 }
78 SafepointReadRwLocker ml(thread, thread->isolate_group()->program_lock());
79 const GrowableObjectArray& direct_subclasses =
81 return !direct_subclasses.IsNull() && (direct_subclasses.Length() > 0);
82}
bool IsInternalOnlyClassId(intptr_t index)
◆ HasSubclasses() [2/2]
bool dart::CHA::HasSubclasses |
( |
intptr_t |
cid | ) |
const |
Definition at line 84 of file cha.cc.
84 {
88}
static bool HasSubclasses(const Class &cls)
ClassTable * class_table() const
◆ IsConsistentWithCurrentHierarchy()
bool dart::CHA::IsConsistentWithCurrentHierarchy |
( |
| ) |
const |
Definition at line 196 of file cha.cc.
196 {
197 for (intptr_t i = 0; i < guarded_classes_.
length(); i++) {
198 if (guarded_classes_[i].subclass_count != -1) {
199 intptr_t current_subclass_count =
201 if (guarded_classes_[i].subclass_count != current_subclass_count) {
202 return false;
203 }
204 }
205 if (guarded_classes_[i].implementor_cid !=
kIllegalCid) {
206 intptr_t current_implementor_cid =
207 guarded_classes_[i].cls->implementor_cid();
208 if (guarded_classes_[i].implementor_cid != current_implementor_cid) {
209 return false;
210 }
211 }
212 if (guarded_classes_[i].track_future) {
213 if (guarded_classes_[i].cls->can_be_future()) {
214 return false;
215 }
216 }
217 }
218 return true;
219}
static intptr_t CountFinalizedSubclasses(Thread *thread, const Class &cls)
◆ IsGuardedClass()
bool dart::CHA::IsGuardedClass |
( |
intptr_t |
cid | ) |
const |
Definition at line 57 of file cha.cc.
57 {
58 for (intptr_t i = 0; i < guarded_classes_.
length(); ++i) {
59 if (guarded_classes_[i].cls->id() ==
cid)
return true;
60 }
61 return false;
62}
◆ IsImplemented()
bool dart::CHA::IsImplemented |
( |
const Class & |
cls | ) |
|
|
static |
Definition at line 117 of file cha.cc.
117 {
118
119
120
121
122 if (cls.InVMIsolateHeap()) return true;
123
124 return cls.is_implemented();
125}
◆ RegisterDependencies()
void dart::CHA::RegisterDependencies |
( |
const Code & |
code | ) |
const |
Definition at line 266 of file cha.cc.
266 {
267 for (intptr_t i = 0; i < guarded_classes_.
length(); ++i) {
268 guarded_classes_[i].cls->RegisterCHACode(code);
269 }
270}
The documentation for this class was generated from the following files:
- third_party/dart-lang/sdk/runtime/vm/compiler/cha.h
- third_party/dart-lang/sdk/runtime/vm/compiler/cha.cc