1 /*
2 * Copyright (C) 2014 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 <memory>
18 #include <setjmp.h>
19
20 #include "base/macros.h"
21 #include "common_runtime_test.h"
22 #include "thread.h"
23
24 // This test checks the offsets of values in the thread TLS and entrypoint structures. A failure
25 // of this test means that offsets have changed from the last update of the test. This indicates
26 // that an oat version bump may be in order, and some defines should be carefully checked (or their
27 // corresponding tests run).
28
29 namespace art {
30
31 // OFFSETOF_MEMBER uses reinterpret_cast. This means it is not a constexpr. So we cannot use
32 // compile-time assertions. Once we find another way, adjust the define accordingly.
33 #define CHECKED(expr, name) \
34 EXPECT_TRUE(expr) << #name
35
36 // Macro to check whether two fields have an expected difference in offsets. The error is named
37 // name.
38 #define EXPECT_OFFSET_DIFF(first_type, first_field, second_type, second_field, diff, name) \
39 CHECKED(OFFSETOF_MEMBER(second_type, second_field) \
40 - OFFSETOF_MEMBER(first_type, first_field) == diff, name)
41
42 // Helper macro for when the fields are from the same type.
43 #define EXPECT_OFFSET_DIFFNP(type, first_field, second_field, diff) \
44 EXPECT_OFFSET_DIFF(type, first_field, type, second_field, diff, \
45 type ## _ ## first_field ## _ ## second_field)
46
47 // Helper macro for when the fields are from the same type and in the same member of said type.
48 #define EXPECT_OFFSET_DIFFP(type, prefix, first_field, second_field, diff) \
49 EXPECT_OFFSET_DIFF(type, prefix . first_field, type, prefix . second_field, diff, \
50 type ## _ ## prefix ## _ ## first_field ## _ ## second_field)
51
52 // Macro to check whether two fields have at least an expected difference in offsets. The error is
53 // named name.
54 #define EXPECT_OFFSET_DIFF_GT(first_type, first_field, second_type, second_field, diff, name) \
55 CHECKED(OFFSETOF_MEMBER(second_type, second_field) \
56 - OFFSETOF_MEMBER(first_type, first_field) >= diff, name)
57
58 // Helper macro for when the fields are from the same type.
59 #define EXPECT_OFFSET_DIFF_GT3(type, first_field, second_field, diff, name) \
60 EXPECT_OFFSET_DIFF_GT(type, first_field, type, second_field, diff, name)
61
62 class EntrypointsOrderTest : public CommonRuntimeTest {
63 protected:
CheckThreadOffsets()64 void CheckThreadOffsets() {
65 CHECKED(OFFSETOF_MEMBER(Thread, tls32_.state_and_flags) == 0, thread_flags_at_zero);
66 EXPECT_OFFSET_DIFFP(Thread, tls32_, state_and_flags, suspend_count, 4);
67 EXPECT_OFFSET_DIFFP(Thread, tls32_, suspend_count, debug_suspend_count, 4);
68 EXPECT_OFFSET_DIFFP(Thread, tls32_, debug_suspend_count, thin_lock_thread_id, 4);
69 EXPECT_OFFSET_DIFFP(Thread, tls32_, thin_lock_thread_id, tid, 4);
70 EXPECT_OFFSET_DIFFP(Thread, tls32_, tid, daemon, 4);
71 EXPECT_OFFSET_DIFFP(Thread, tls32_, daemon, throwing_OutOfMemoryError, 4);
72 EXPECT_OFFSET_DIFFP(Thread, tls32_, throwing_OutOfMemoryError, no_thread_suspension, 4);
73 EXPECT_OFFSET_DIFFP(Thread, tls32_, no_thread_suspension, thread_exit_check_count, 4);
74 EXPECT_OFFSET_DIFFP(Thread, tls32_, thread_exit_check_count,
75 is_exception_reported_to_instrumentation_, 4);
76 EXPECT_OFFSET_DIFFP(Thread, tls32_, is_exception_reported_to_instrumentation_,
77 handling_signal_, 4);
78
79 // TODO: Better connection. Take alignment into account.
80 EXPECT_OFFSET_DIFF_GT3(Thread, tls32_.thread_exit_check_count, tls64_.trace_clock_base, 4,
81 thread_tls32_to_tls64);
82
83 EXPECT_OFFSET_DIFFP(Thread, tls64_, trace_clock_base, deoptimization_return_value, 8);
84 EXPECT_OFFSET_DIFFP(Thread, tls64_, deoptimization_return_value, stats, 8);
85
86 // TODO: Better connection. Take alignment into account.
87 EXPECT_OFFSET_DIFF_GT3(Thread, tls64_.stats, tlsPtr_.card_table, 8, thread_tls64_to_tlsptr);
88
89 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, card_table, exception, kPointerSize);
90 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, exception, stack_end, kPointerSize);
91 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, stack_end, managed_stack, kPointerSize);
92 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, managed_stack, suspend_trigger, sizeof(ManagedStack));
93 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, suspend_trigger, jni_env, kPointerSize);
94 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, jni_env, self, kPointerSize);
95 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, self, opeer, kPointerSize);
96 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, opeer, jpeer, kPointerSize);
97 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, jpeer, stack_begin, kPointerSize);
98 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, stack_begin, stack_size, kPointerSize);
99 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, stack_size, throw_location, kPointerSize);
100 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, throw_location, stack_trace_sample, sizeof(ThrowLocation));
101 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, stack_trace_sample, wait_next, kPointerSize);
102 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, wait_next, monitor_enter_object, kPointerSize);
103 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, monitor_enter_object, top_handle_scope, kPointerSize);
104 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, top_handle_scope, class_loader_override, kPointerSize);
105 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, class_loader_override, long_jump_context, kPointerSize);
106 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, long_jump_context, instrumentation_stack, kPointerSize);
107 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, instrumentation_stack, debug_invoke_req, kPointerSize);
108 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, debug_invoke_req, single_step_control, kPointerSize);
109 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, single_step_control, deoptimization_shadow_frame,
110 kPointerSize);
111 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, deoptimization_shadow_frame,
112 shadow_frame_under_construction, kPointerSize);
113 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, shadow_frame_under_construction, name, kPointerSize);
114 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, name, pthread_self, kPointerSize);
115 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, pthread_self, last_no_thread_suspension_cause,
116 kPointerSize);
117 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, last_no_thread_suspension_cause, checkpoint_functions,
118 kPointerSize);
119 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, checkpoint_functions, interpreter_entrypoints,
120 kPointerSize * 3);
121
122 // Skip across the entrypoints structures.
123
124 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, thread_local_start, thread_local_pos, kPointerSize);
125 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, thread_local_pos, thread_local_end, kPointerSize);
126 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, thread_local_end, thread_local_objects, kPointerSize);
127 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, thread_local_objects, rosalloc_runs, kPointerSize);
128 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, rosalloc_runs, thread_local_alloc_stack_top,
129 kPointerSize * kNumRosAllocThreadLocalSizeBrackets);
130 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, thread_local_alloc_stack_top, thread_local_alloc_stack_end,
131 kPointerSize);
132 EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, thread_local_alloc_stack_end, held_mutexes, kPointerSize);
133 EXPECT_OFFSET_DIFF(Thread, tlsPtr_.held_mutexes, Thread, wait_mutex_,
134 kPointerSize * kLockLevelCount + kPointerSize, thread_tlsptr_end);
135 }
136
CheckInterpreterEntryPoints()137 void CheckInterpreterEntryPoints() {
138 CHECKED(OFFSETOF_MEMBER(InterpreterEntryPoints, pInterpreterToInterpreterBridge) == 0,
139 InterpreterEntryPoints_start_with_i2i);
140 EXPECT_OFFSET_DIFFNP(InterpreterEntryPoints, pInterpreterToInterpreterBridge,
141 pInterpreterToCompiledCodeBridge, kPointerSize);
142 CHECKED(OFFSETOF_MEMBER(InterpreterEntryPoints, pInterpreterToCompiledCodeBridge)
143 + kPointerSize == sizeof(InterpreterEntryPoints), InterpreterEntryPoints_all);
144 }
145
CheckJniEntryPoints()146 void CheckJniEntryPoints() {
147 CHECKED(OFFSETOF_MEMBER(JniEntryPoints, pDlsymLookup) == 0,
148 JniEntryPoints_start_with_dlsymlookup);
149 CHECKED(OFFSETOF_MEMBER(JniEntryPoints, pDlsymLookup)
150 + kPointerSize == sizeof(JniEntryPoints), JniEntryPoints_all);
151 }
152
CheckPortableEntryPoints()153 void CheckPortableEntryPoints() {
154 CHECKED(OFFSETOF_MEMBER(PortableEntryPoints, pPortableImtConflictTrampoline) == 0,
155 PortableEntryPoints_start_with_imt);
156 EXPECT_OFFSET_DIFFNP(PortableEntryPoints, pPortableImtConflictTrampoline,
157 pPortableResolutionTrampoline, kPointerSize);
158 EXPECT_OFFSET_DIFFNP(PortableEntryPoints, pPortableResolutionTrampoline,
159 pPortableToInterpreterBridge, kPointerSize);
160 CHECKED(OFFSETOF_MEMBER(PortableEntryPoints, pPortableToInterpreterBridge)
161 + kPointerSize == sizeof(PortableEntryPoints), PortableEntryPoints_all);
162 }
163
CheckQuickEntryPoints()164 void CheckQuickEntryPoints() {
165 CHECKED(OFFSETOF_MEMBER(QuickEntryPoints, pAllocArray) == 0,
166 QuickEntryPoints_start_with_allocarray);
167 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pAllocArray, pAllocArrayResolved, kPointerSize);
168 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pAllocArrayResolved, pAllocArrayWithAccessCheck,
169 kPointerSize);
170 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pAllocArrayWithAccessCheck, pAllocObject, kPointerSize);
171 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pAllocObject, pAllocObjectResolved, kPointerSize);
172 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pAllocObjectResolved, pAllocObjectInitialized,
173 kPointerSize);
174 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pAllocObjectInitialized, pAllocObjectWithAccessCheck,
175 kPointerSize);
176 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pAllocObjectWithAccessCheck, pCheckAndAllocArray,
177 kPointerSize);
178 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pCheckAndAllocArray, pCheckAndAllocArrayWithAccessCheck,
179 kPointerSize);
180 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pCheckAndAllocArrayWithAccessCheck,
181 pInstanceofNonTrivial, kPointerSize);
182 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pInstanceofNonTrivial, pCheckCast, kPointerSize);
183 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pCheckCast, pInitializeStaticStorage, kPointerSize);
184 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pInitializeStaticStorage, pInitializeTypeAndVerifyAccess,
185 kPointerSize);
186 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pInitializeTypeAndVerifyAccess, pInitializeType,
187 kPointerSize);
188 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pInitializeType, pResolveString, kPointerSize);
189 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pResolveString, pSet32Instance, kPointerSize);
190 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pSet32Instance, pSet32Static, kPointerSize);
191 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pSet32Static, pSet64Instance, kPointerSize);
192 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pSet64Instance, pSet64Static, kPointerSize);
193 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pSet64Static, pSetObjInstance, kPointerSize);
194 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pSetObjInstance, pSetObjStatic, kPointerSize);
195 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pSetObjStatic, pGet32Instance, kPointerSize);
196 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pGet32Instance, pGet32Static, kPointerSize);
197 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pGet32Static, pGet64Instance, kPointerSize);
198 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pGet64Instance, pGet64Static, kPointerSize);
199 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pGet64Static, pGetObjInstance, kPointerSize);
200 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pGetObjInstance, pGetObjStatic, kPointerSize);
201 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pGetObjStatic, pAputObjectWithNullAndBoundCheck,
202 kPointerSize);
203 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pAputObjectWithNullAndBoundCheck,
204 pAputObjectWithBoundCheck, kPointerSize);
205 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pAputObjectWithBoundCheck, pAputObject, kPointerSize);
206 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pAputObject, pHandleFillArrayData, kPointerSize);
207 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pHandleFillArrayData, pJniMethodStart, kPointerSize);
208 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pJniMethodStart, pJniMethodStartSynchronized,
209 kPointerSize);
210 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pJniMethodStartSynchronized, pJniMethodEnd,
211 kPointerSize);
212 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pJniMethodEnd, pJniMethodEndSynchronized, kPointerSize);
213 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pJniMethodEndSynchronized, pJniMethodEndWithReference,
214 kPointerSize);
215 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pJniMethodEndWithReference,
216 pJniMethodEndWithReferenceSynchronized, kPointerSize);
217 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pJniMethodEndWithReferenceSynchronized,
218 pQuickGenericJniTrampoline, kPointerSize);
219 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pQuickGenericJniTrampoline, pLockObject, kPointerSize);
220 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pLockObject, pUnlockObject, kPointerSize);
221 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pUnlockObject, pCmpgDouble, kPointerSize);
222 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pCmpgDouble, pCmpgFloat, kPointerSize);
223 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pCmpgFloat, pCmplDouble, kPointerSize);
224 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pCmplDouble, pCmplFloat, kPointerSize);
225 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pCmplFloat, pFmod, kPointerSize);
226 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pFmod, pL2d, kPointerSize);
227 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pL2d, pFmodf, kPointerSize);
228 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pFmodf, pL2f, kPointerSize);
229 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pL2f, pD2iz, kPointerSize);
230 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pD2iz, pF2iz, kPointerSize);
231 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pF2iz, pIdivmod, kPointerSize);
232 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pIdivmod, pD2l, kPointerSize);
233 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pD2l, pF2l, kPointerSize);
234 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pF2l, pLdiv, kPointerSize);
235 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pLdiv, pLmod, kPointerSize);
236 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pLmod, pLmul, kPointerSize);
237 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pLmul, pShlLong, kPointerSize);
238 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pShlLong, pShrLong, kPointerSize);
239 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pShrLong, pUshrLong, kPointerSize);
240 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pUshrLong, pIndexOf, kPointerSize);
241 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pIndexOf, pStringCompareTo, kPointerSize);
242 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pStringCompareTo, pMemcpy, kPointerSize);
243 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pMemcpy, pQuickImtConflictTrampoline, kPointerSize);
244 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pQuickImtConflictTrampoline, pQuickResolutionTrampoline,
245 kPointerSize);
246 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pQuickResolutionTrampoline, pQuickToInterpreterBridge,
247 kPointerSize);
248 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pQuickToInterpreterBridge,
249 pInvokeDirectTrampolineWithAccessCheck, kPointerSize);
250 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pInvokeDirectTrampolineWithAccessCheck,
251 pInvokeInterfaceTrampolineWithAccessCheck, kPointerSize);
252 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pInvokeInterfaceTrampolineWithAccessCheck,
253 pInvokeStaticTrampolineWithAccessCheck, kPointerSize);
254 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pInvokeStaticTrampolineWithAccessCheck,
255 pInvokeSuperTrampolineWithAccessCheck, kPointerSize);
256 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pInvokeSuperTrampolineWithAccessCheck,
257 pInvokeVirtualTrampolineWithAccessCheck, kPointerSize);
258 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pInvokeVirtualTrampolineWithAccessCheck,
259 pTestSuspend, kPointerSize);
260 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pTestSuspend, pDeliverException, kPointerSize);
261
262 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pDeliverException, pThrowArrayBounds, kPointerSize);
263 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pThrowArrayBounds, pThrowDivZero, kPointerSize);
264 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pThrowDivZero, pThrowNoSuchMethod, kPointerSize);
265 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pThrowNoSuchMethod, pThrowNullPointer, kPointerSize);
266 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pThrowNullPointer, pThrowStackOverflow, kPointerSize);
267 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pThrowStackOverflow, pA64Load, kPointerSize);
268 EXPECT_OFFSET_DIFFNP(QuickEntryPoints, pA64Load, pA64Store, kPointerSize);
269
270 CHECKED(OFFSETOF_MEMBER(QuickEntryPoints, pA64Store)
271 + kPointerSize == sizeof(QuickEntryPoints), QuickEntryPoints_all);
272 }
273 };
274
TEST_F(EntrypointsOrderTest,ThreadOffsets)275 TEST_F(EntrypointsOrderTest, ThreadOffsets) {
276 CheckThreadOffsets();
277 }
278
TEST_F(EntrypointsOrderTest,InterpreterEntryPoints)279 TEST_F(EntrypointsOrderTest, InterpreterEntryPoints) {
280 CheckInterpreterEntryPoints();
281 }
282
TEST_F(EntrypointsOrderTest,JniEntryPoints)283 TEST_F(EntrypointsOrderTest, JniEntryPoints) {
284 CheckJniEntryPoints();
285 }
286
TEST_F(EntrypointsOrderTest,PortableEntryPoints)287 TEST_F(EntrypointsOrderTest, PortableEntryPoints) {
288 CheckPortableEntryPoints();
289 }
290
TEST_F(EntrypointsOrderTest,QuickEntryPoints)291 TEST_F(EntrypointsOrderTest, QuickEntryPoints) {
292 CheckQuickEntryPoints();
293 }
294
295 } // namespace art
296