Use WTF::Lock and WTF::Condition instead of WTF::Mutex, WTF::ThreadCondition, std...
[WebKit-https.git] / Source / JavaScriptCore / jit / JITThunks.cpp
1 /*
2  * Copyright (C) 2012, 2013, 2015 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #include "config.h"
27 #include "JITThunks.h"
28
29 #if ENABLE(JIT)
30
31 #include "Executable.h"
32 #include "JIT.h"
33 #include "VM.h"
34 #include "JSCInlines.h"
35
36 namespace JSC {
37
38 JITThunks::JITThunks()
39     : m_hostFunctionStubMap(std::make_unique<HostFunctionStubMap>())
40 {
41 }
42
43 JITThunks::~JITThunks()
44 {
45 }
46
47 MacroAssemblerCodePtr JITThunks::ctiNativeCall(VM* vm)
48 {
49     if (!vm->canUseJIT())
50         return MacroAssemblerCodePtr::createLLIntCodePtr(llint_native_call_trampoline);
51     return ctiStub(vm, nativeCallGenerator).code();
52 }
53
54 MacroAssemblerCodePtr JITThunks::ctiNativeConstruct(VM* vm)
55 {
56     if (!vm->canUseJIT())
57         return MacroAssemblerCodePtr::createLLIntCodePtr(llint_native_construct_trampoline);
58     return ctiStub(vm, nativeConstructGenerator).code();
59 }
60
61 MacroAssemblerCodePtr JITThunks::ctiNativeTailCall(VM* vm)
62 {
63     ASSERT(vm->canUseJIT());
64     return ctiStub(vm, nativeTailCallGenerator).code();
65 }
66
67 MacroAssemblerCodeRef JITThunks::ctiStub(VM* vm, ThunkGenerator generator)
68 {
69     LockHolder locker(m_lock);
70     CTIStubMap::AddResult entry = m_ctiStubMap.add(generator, MacroAssemblerCodeRef());
71     if (entry.isNewEntry) {
72         // Compilation thread can only retrieve existing entries.
73         ASSERT(!isCompilationThread());
74         entry.iterator->value = generator(vm);
75     }
76     return entry.iterator->value;
77 }
78
79 void JITThunks::finalize(Handle<Unknown> handle, void*)
80 {
81     auto* nativeExecutable = jsCast<NativeExecutable*>(handle.get().asCell());
82     weakRemove(*m_hostFunctionStubMap, std::make_pair(nativeExecutable->function(), nativeExecutable->constructor()), nativeExecutable);
83 }
84
85 NativeExecutable* JITThunks::hostFunctionStub(VM* vm, NativeFunction function, NativeFunction constructor)
86 {
87     ASSERT(!isCompilationThread());
88
89     if (NativeExecutable* nativeExecutable = m_hostFunctionStubMap->get(std::make_pair(function, constructor)))
90         return nativeExecutable;
91
92     NativeExecutable* nativeExecutable = NativeExecutable::create(
93         *vm,
94         adoptRef(new NativeJITCode(JIT::compileCTINativeCall(vm, function), JITCode::HostCallThunk)),
95         function,
96         adoptRef(new NativeJITCode(MacroAssemblerCodeRef::createSelfManagedCodeRef(ctiNativeConstruct(vm)), JITCode::HostCallThunk)),
97         constructor, NoIntrinsic);
98     weakAdd(*m_hostFunctionStubMap, std::make_pair(function, constructor), Weak<NativeExecutable>(nativeExecutable, this));
99     return nativeExecutable;
100 }
101
102 NativeExecutable* JITThunks::hostFunctionStub(VM* vm, NativeFunction function, ThunkGenerator generator, Intrinsic intrinsic)
103 {
104     ASSERT(!isCompilationThread());    
105     ASSERT(vm->canUseJIT());
106
107     if (NativeExecutable* nativeExecutable = m_hostFunctionStubMap->get(std::make_pair(function, &callHostFunctionAsConstructor)))
108         return nativeExecutable;
109
110     RefPtr<JITCode> forCall;
111     if (generator) {
112         MacroAssemblerCodeRef entry = generator(vm);
113         forCall = adoptRef(new DirectJITCode(entry, entry.code(), JITCode::HostCallThunk));
114     } else
115         forCall = adoptRef(new NativeJITCode(JIT::compileCTINativeCall(vm, function), JITCode::HostCallThunk));
116     
117     RefPtr<JITCode> forConstruct = adoptRef(new NativeJITCode(MacroAssemblerCodeRef::createSelfManagedCodeRef(ctiNativeConstruct(vm)), JITCode::HostCallThunk));
118     
119     NativeExecutable* nativeExecutable = NativeExecutable::create(*vm, forCall, function, forConstruct, callHostFunctionAsConstructor, intrinsic);
120     weakAdd(*m_hostFunctionStubMap, std::make_pair(function, &callHostFunctionAsConstructor), Weak<NativeExecutable>(nativeExecutable, this));
121     return nativeExecutable;
122 }
123
124 void JITThunks::clearHostFunctionStubs()
125 {
126     m_hostFunctionStubMap = nullptr;
127 }
128
129 } // namespace JSC
130
131 #endif // ENABLE(JIT)