ChakraCore/lib/Jsrt/JsrtHelper.cpp

//-------------------------------------------------------------------------------------------------------
// Copyright (C) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
//-------------------------------------------------------------------------------------------------------
#include "JsrtPch.h"
#include "jsrtHelper.h"
#include "Base/ThreadContextTlsEntry.h"

#ifdef DYNAMIC_PROFILE_STORAGE
#include "Language/DynamicProfileStorage.h"
#endif

#ifdef CHAKRA_STATIC_LIBRARY
#include "Core/ConfigParser.h"

void ChakraBinaryAutoSystemInfoInit(AutoSystemInfo * autoSystemInfo)
{
    autoSystemInfo->buildDateHash = JsUtil::CharacterBuffer<char>::StaticGetHashCode(__DATE__, _countof(__DATE__));
    autoSystemInfo->buildTimeHash = JsUtil::CharacterBuffer<char>::StaticGetHashCode(__TIME__, _countof(__TIME__));
}

bool ConfigParserAPI::FillConsoleTitle(__ecount(cchBufferSize) LPWSTR buffer, size_t cchBufferSize, __in LPWSTR moduleName)
{
    return false;
}

void ConfigParserAPI::DisplayInitialOutput(__in LPWSTR moduleName)
{
}

LPCWSTR JsUtil::ExternalApi::GetFeatureKeyName()
{
    return _u("");
}
#endif

JsrtCallbackState::JsrtCallbackState(ThreadContext* currentThreadContext)
{
    if (currentThreadContext == nullptr)
    {
        originalThreadContext = ThreadContext::GetContextForCurrentThread();
    }
    else
    {
        originalThreadContext = currentThreadContext;
    }
    originalJsrtContext = JsrtContext::GetCurrent();
    Assert(originalJsrtContext == nullptr || originalThreadContext == originalJsrtContext->GetScriptContext()->GetThreadContext());
}

JsrtCallbackState::~JsrtCallbackState()
{
    if (originalJsrtContext != nullptr)
    {
        if (originalJsrtContext != JsrtContext::GetCurrent())
        {
            // This shouldn't fail as the context was previously set on the current thread.
            bool isSet = JsrtContext::TrySetCurrent(originalJsrtContext);
            if (!isSet)
            {
                Js::Throw::FatalInternalError();
            }
        }
    }
    else
    {
        bool isSet = ThreadContextTLSEntry::TrySetThreadContext(originalThreadContext);
        if (!isSet)
        {
            Js::Throw::FatalInternalError();
        }
    }
}

void JsrtCallbackState::ObjectBeforeCallectCallbackWrapper(JsObjectBeforeCollectCallback callback, void* object, void* callbackState, void* threadContext)
{
    JsrtCallbackState scope(reinterpret_cast<ThreadContext*>(threadContext));
    callback(object, callbackState);
}

// todo: We need an interface for thread/process exit.
// At the moment we do handle thread exit for non main threads on xplat
// However, it could be nice/necessary to provide an interface to make sure
// we cover additional edge cases.
#if defined(CHAKRA_STATIC_LIBRARY) || !defined(_WIN32)
    #include "Core/ConfigParser.h"
    #include "Base/ThreadBoundThreadContextManager.h"

#ifndef _WIN32
    #include <pthread.h>
    static pthread_key_t s_threadLocalDummy;
#endif

    static THREAD_LOCAL bool s_threadWasEntered = false;

    _NOINLINE void DISPOSE_CHAKRA_CORE_THREAD(void *_)
    {
        free(_);
        ThreadBoundThreadContextManager::DestroyContextAndEntryForCurrentThread();
    }

    _NOINLINE bool InitializeProcess()
    {
#if !defined(_WIN32)
        pthread_key_create(&s_threadLocalDummy, DISPOSE_CHAKRA_CORE_THREAD);
#endif

#if defined(CHAKRA_STATIC_LIBRARY)

    // Attention: shared library is handled under (see ChakraCore/ChakraCoreDllFunc.cpp)
    // todo: consolidate similar parts from shared and static library initialization
#ifndef _WIN32
        PAL_InitializeChakraCore(0, NULL);
#endif

        HMODULE mod = GetModuleHandleW(NULL);

        if (!ThreadContextTLSEntry::InitializeProcess() || !JsrtContext::Initialize())
        {
            return FALSE;
        }

        AutoSystemInfo::SaveModuleFileName(mod);

    #if defined(_M_IX86) && !defined(__clang__)
        // Enable SSE2 math functions in CRT if SSE2 is available
    #pragma prefast(suppress:6031, "We don't require SSE2, but will use it if available")
        _set_SSE2_enable(TRUE);
    #endif

        {
            CmdLineArgsParser parser;
            ConfigParser::ParseOnModuleLoad(parser, mod);
        }

    #ifdef ENABLE_JS_ETW
        EtwTrace::Register();
    #endif
        ValueType::Initialize();
        ThreadContext::GlobalInitialize();

        // Needed to make sure that only ChakraCore is loaded into the process
        // This is unnecessary on Linux since there aren't other flavors of
        // Chakra binaries that can be loaded into the process
    #ifdef _WIN32
        char16 *engine = szChakraCoreLock;
        if (::FindAtom(szChakraLock) != 0)
        {
            AssertMsg(FALSE, "Expecting to load chakracore.dll but process already loaded chakra.dll");
            Binary_Inconsistency_fatal_error();
        }
        lockedDll = ::AddAtom(engine);
        AssertMsg(lockedDll, "Failed to lock chakracore.dll");
    #endif // _WIN32

    #ifdef ENABLE_BASIC_TELEMETRY
        g_TraceLoggingClient = NoCheckHeapNewStruct(TraceLoggingClient);
    #endif

    #ifdef DYNAMIC_PROFILE_STORAGE
        DynamicProfileStorage::Initialize();
    #endif
#endif // STATIC_LIBRARY
        return true;
    }

    _NOINLINE void VALIDATE_ENTER_CURRENT_THREAD()
    {
        // We do also initialize the process part here
        // This is thread safe by the standard
        // Let's hope compiler doesn't fail
        static bool _has_init = InitializeProcess();

        if (!_has_init) // do not assert this.
        {
            abort();
        }

        if (s_threadWasEntered) return;
        s_threadWasEntered = true;

        ThreadContextTLSEntry::InitializeThread();
    #ifdef HEAP_TRACK_ALLOC
        HeapAllocator::InitializeThread();
    #endif

#ifndef _WIN32
        // put something into key to make sure destructor is going to be called
        pthread_setspecific(s_threadLocalDummy, malloc(1));
#endif
    }
#endif