core/win32/callback.c
/* If we receive an asynch event while we've lost control but before we
 * reach the image entry point or our other retakeover points we should
 * retakeover, to minimize the amount of code run natively -- these should
 * be rare during init and perf hit of repeated flushing and re-walking
 * memory list shouldn't be an issue.
 * Separated from asynch_take_over to not force its callers to do this.
 */
If we receive an asynch event while we've lost control but before we
reach the image entry point or our other retakeover points we should
retakeover, to minimize the amount of code run natively -- these should
be rare during init and perf hit of repeated flushing and re-walking
memory list shouldn't be an issue.
Separated from asynch_take_over to not force its callers to do this.
If we receive an asynch event while we ' ve lost control but before we reach the image entry point or our other retakeover points we should retakeover to minimize the amount of code run natively -- these should be rare during init and perf hit of repeated flushing and re - walking memory list shouldn ' t be an issue . Separated from asynch_take_over to not force its callers to do this .
static inline void
asynch_retakeover_if_native()
{
    thread_record_t *tr = thread_lookup(get_thread_id());
    ASSERT(tr != NULL);
    if (tr->under_dynamo_control == UNDER_DYN_HACK) {
        ASSERT(!reached_image_entry_yet());
        retakeover_after_native(tr, INTERCEPT_EARLY_ASYNCH);
    }
}
static inline void asynch_retakeover_if_native ( ) { thread_record_t * tr = thread_lookup ( get_thread_id ( ) ) ; ASSERT ( tr != NULL ) ; if ( tr -> under_dynamo_control == UNDER_DYN_HACK ) { ASSERT ( ! reached_image_entry_yet ( ) ) ; retakeover_after_native ( tr , INTERCEPT_EARLY_ASYNCH ) ; } }
If we receive an asynch event while we've lost control but before we
 reach the image entry point or our other retakeover points we should
 retakeover, to minimize the amount of code run natively -- these should
 be rare during init and perf hit of repeated flushing and re-walking
 memory list shouldn't be an issue.
If we receive an asynch event while we ' ve lost control but before we reach the image entry point or our other retakeover points we should retakeover to minimize the amount of code run natively -- these should be rare during init and perf hit of repeated flushing and re - walking memory list shouldn ' t be an issue .
/* must do a complete takeover-after-native */