We should be able to inline getter/setter calls inside an inline cache even when...
[WebKit-https.git] / Source / JavaScriptCore / ftl / FTLJITCode.cpp
1 /*
2  * Copyright (C) 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 "FTLJITCode.h"
28
29 #if ENABLE(FTL_JIT)
30
31 #include "FTLState.h"
32
33 namespace JSC { namespace FTL {
34
35 JITCode::JITCode()
36     : JSC::JITCode(FTLJIT)
37 {
38 }
39
40 JITCode::~JITCode()
41 {
42     if (FTL::shouldShowDisassembly()) {
43         dataLog("Destroying FTL JIT code at ");
44         CommaPrinter comma;
45         for (auto& handle : m_handles)
46             dataLog(comma, pointerDump(handle.get()));
47         dataLog(comma, pointerDump(m_arityCheckEntrypoint.executableMemory()));
48         dataLog(comma, pointerDump(m_exitThunks.executableMemory()));
49         dataLog("\n");
50     }
51 }
52
53 void JITCode::initializeExitThunks(CodeRef exitThunks)
54 {
55     m_exitThunks = exitThunks;
56 }
57
58 void JITCode::addHandle(PassRefPtr<ExecutableMemoryHandle> handle)
59 {
60     m_handles.append(handle);
61 }
62
63 void JITCode::addDataSection(PassRefPtr<DataSection> dataSection)
64 {
65     m_dataSections.append(dataSection);
66 }
67
68 void JITCode::initializeArityCheckEntrypoint(CodeRef entrypoint)
69 {
70     m_arityCheckEntrypoint = entrypoint;
71 }
72
73 void JITCode::initializeAddressForCall(CodePtr address)
74 {
75     m_addressForCall = address;
76 }
77
78 JITCode::CodePtr JITCode::addressForCall(ArityCheckMode arityCheck)
79 {
80     switch (arityCheck) {
81     case ArityCheckNotRequired:
82         return m_addressForCall;
83     case MustCheckArity:
84         return m_arityCheckEntrypoint.code();
85     }
86     RELEASE_ASSERT_NOT_REACHED();
87     return CodePtr();
88 }
89
90 void* JITCode::executableAddressAtOffset(size_t offset)
91 {
92     return reinterpret_cast<char*>(m_addressForCall.executableAddress()) + offset;
93 }
94
95 void* JITCode::dataAddressAtOffset(size_t)
96 {
97     // We can't patch FTL code, yet. Even if we did, it's not clear that we would do so
98     // through this API.
99     RELEASE_ASSERT_NOT_REACHED();
100     return 0;
101 }
102
103 unsigned JITCode::offsetOf(void*)
104 {
105     // We currently don't have visibility into the FTL code.
106     RELEASE_ASSERT_NOT_REACHED();
107     return 0;
108 }
109
110 size_t JITCode::size()
111 {
112     // We don't know the size of FTL code, yet. Make a wild guess. This is mostly used for
113     // GC load estimates.
114     return 1000;
115 }
116
117 bool JITCode::contains(void*)
118 {
119     // We have no idea what addresses the FTL code contains, yet.
120     RELEASE_ASSERT_NOT_REACHED();
121     return false;
122 }
123
124 JITCode::CodePtr JITCode::exitThunks()
125 {
126     return m_exitThunks.code();
127 }
128
129 JITCode* JITCode::ftl()
130 {
131     return this;
132 }
133
134 DFG::CommonData* JITCode::dfgCommon()
135 {
136     return &common;
137 }
138
139 void JITCode::validateReferences(const TrackedReferences& trackedReferences)
140 {
141     common.validateReferences(trackedReferences);
142     
143     for (OSRExit& exit : osrExit)
144         exit.validateReferences(trackedReferences);
145 }
146
147 RegisterSet JITCode::liveRegistersToPreserveAtExceptionHandlingCallSite(CodeBlock*, CallSiteIndex)
148 {
149     // FIXME: implement this when FTL implements try/catch.
150     // https://bugs.webkit.org/show_bug.cgi?id=149409
151     return RegisterSet();
152 }
153
154 } } // namespace JSC::FTL
155
156 #endif // ENABLE(FTL_JIT)
157