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