59c4092c264848448e4e6998d8d34701d1b8f49f
[WebKit-https.git] / Source / JavaScriptCore / dfg / DFGCallArrayAllocatorSlowPathGenerator.h
1 /*
2  * Copyright (C) 2012 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 #pragma once
27
28 #if ENABLE(DFG_JIT)
29
30 #include "DFGCommon.h"
31 #include "DFGSlowPathGenerator.h"
32 #include "DFGSpeculativeJIT.h"
33 #include <wtf/Vector.h>
34
35 namespace JSC { namespace DFG {
36
37 class CallArrayAllocatorSlowPathGenerator : public JumpingSlowPathGenerator<MacroAssembler::JumpList> {
38 public:
39     CallArrayAllocatorSlowPathGenerator(
40         MacroAssembler::JumpList from, SpeculativeJIT* jit, P_JITOperation_EStZB function,
41         GPRReg resultGPR, GPRReg storageGPR, RegisteredStructure structure, size_t size)
42         : JumpingSlowPathGenerator<MacroAssembler::JumpList>(from, jit)
43         , m_function(function)
44         , m_resultGPR(resultGPR)
45         , m_storageGPR(storageGPR)
46         , m_structure(structure)
47         , m_size(size)
48     {
49         ASSERT(size < static_cast<size_t>(std::numeric_limits<int32_t>::max()));
50         jit->silentSpillAllRegistersImpl(false, m_plans, resultGPR);
51     }
52
53 protected:
54     void generateInternal(SpeculativeJIT* jit) override
55     {
56         linkFrom(jit);
57         for (unsigned i = 0; i < m_plans.size(); ++i)
58             jit->silentSpill(m_plans[i]);
59         jit->callOperation(m_function, m_resultGPR, m_structure, m_size, m_storageGPR);
60         GPRReg canTrample = SpeculativeJIT::pickCanTrample(m_resultGPR);
61         for (unsigned i = m_plans.size(); i--;)
62             jit->silentFill(m_plans[i], canTrample);
63         jit->m_jit.exceptionCheck();
64         jit->m_jit.loadPtr(MacroAssembler::Address(m_resultGPR, JSObject::butterflyOffset()), m_storageGPR);
65         jumpTo(jit);
66     }
67     
68 private:
69     P_JITOperation_EStZB m_function;
70     GPRReg m_resultGPR;
71     GPRReg m_storageGPR;
72     RegisteredStructure m_structure;
73     size_t m_size;
74     Vector<SilentRegisterSavePlan, 2> m_plans;
75 };
76
77 class CallArrayAllocatorWithVariableSizeSlowPathGenerator : public JumpingSlowPathGenerator<MacroAssembler::JumpList> {
78 public:
79     CallArrayAllocatorWithVariableSizeSlowPathGenerator(
80         MacroAssembler::JumpList from, SpeculativeJIT* jit, P_JITOperation_EStZB function,
81         GPRReg resultGPR, RegisteredStructure contiguousStructure, RegisteredStructure arrayStorageStructure, GPRReg sizeGPR, GPRReg storageGPR)
82         : JumpingSlowPathGenerator<MacroAssembler::JumpList>(from, jit)
83         , m_function(function)
84         , m_resultGPR(resultGPR)
85         , m_contiguousStructure(contiguousStructure)
86         , m_arrayStorageOrContiguousStructure(arrayStorageStructure)
87         , m_sizeGPR(sizeGPR)
88         , m_storageGPR(storageGPR)
89     {
90         jit->silentSpillAllRegistersImpl(false, m_plans, resultGPR);
91     }
92
93 protected:
94     void generateInternal(SpeculativeJIT* jit) override
95     {
96         linkFrom(jit);
97         for (unsigned i = 0; i < m_plans.size(); ++i)
98             jit->silentSpill(m_plans[i]);
99         GPRReg scratchGPR = AssemblyHelpers::selectScratchGPR(m_sizeGPR, m_storageGPR);
100         if (m_contiguousStructure.get() != m_arrayStorageOrContiguousStructure.get()) {
101             MacroAssembler::Jump bigLength = jit->m_jit.branch32(MacroAssembler::AboveOrEqual, m_sizeGPR, MacroAssembler::TrustedImm32(MIN_ARRAY_STORAGE_CONSTRUCTION_LENGTH));
102             jit->m_jit.move(SpeculativeJIT::TrustedImmPtr(m_contiguousStructure), scratchGPR);
103             MacroAssembler::Jump done = jit->m_jit.jump();
104             bigLength.link(&jit->m_jit);
105             jit->m_jit.move(SpeculativeJIT::TrustedImmPtr(m_arrayStorageOrContiguousStructure), scratchGPR);
106             done.link(&jit->m_jit);
107         } else
108             jit->m_jit.move(SpeculativeJIT::TrustedImmPtr(m_contiguousStructure), scratchGPR);
109         jit->callOperation(m_function, m_resultGPR, scratchGPR, m_sizeGPR, m_storageGPR);
110         GPRReg canTrample = SpeculativeJIT::pickCanTrample(m_resultGPR);
111         for (unsigned i = m_plans.size(); i--;)
112             jit->silentFill(m_plans[i], canTrample);
113         jit->m_jit.exceptionCheck();
114         jumpTo(jit);
115     }
116     
117 private:
118     P_JITOperation_EStZB m_function;
119     GPRReg m_resultGPR;
120     RegisteredStructure m_contiguousStructure;
121     RegisteredStructure m_arrayStorageOrContiguousStructure;
122     GPRReg m_sizeGPR;
123     GPRReg m_storageGPR;
124     Vector<SilentRegisterSavePlan, 2> m_plans;
125 };
126
127 class CallArrayAllocatorWithVariableStructureVariableSizeSlowPathGenerator : public JumpingSlowPathGenerator<MacroAssembler::JumpList> {
128 public:
129     CallArrayAllocatorWithVariableStructureVariableSizeSlowPathGenerator(
130         MacroAssembler::JumpList from, SpeculativeJIT* jit, P_JITOperation_EStZB function,
131         GPRReg resultGPR, GPRReg structureGPR, GPRReg sizeGPR, GPRReg storageGPR, GPRReg scratchGPR)
132         : JumpingSlowPathGenerator<MacroAssembler::JumpList>(from, jit)
133         , m_function(function)
134         , m_resultGPR(resultGPR)
135         , m_structureGPR(structureGPR)
136         , m_sizeGPR(sizeGPR)
137         , m_storageGPR(storageGPR)
138         , m_scratchGPR(scratchGPR)
139     {
140         jit->silentSpillAllRegistersImpl(false, m_plans, resultGPR, m_scratchGPR);
141     }
142
143 protected:
144     void generateInternal(SpeculativeJIT* jit) override
145     {
146         linkFrom(jit);
147         for (unsigned i = 0; i < m_plans.size(); ++i)
148             jit->silentSpill(m_plans[i]);
149         jit->callOperation(m_function, m_resultGPR, m_structureGPR, m_sizeGPR, m_storageGPR);
150         for (unsigned i = m_plans.size(); i--;)
151             jit->silentFill(m_plans[i], m_scratchGPR);
152         jit->m_jit.exceptionCheck();
153         jumpTo(jit);
154     }
155     
156 private:
157     P_JITOperation_EStZB m_function;
158     GPRReg m_resultGPR;
159     GPRReg m_structureGPR;
160     GPRReg m_sizeGPR;
161     GPRReg m_storageGPR;
162     GPRReg m_scratchGPR;
163     Vector<SilentRegisterSavePlan, 2> m_plans;
164 };
165
166 } } // namespace JSC::DFG
167
168 #endif // ENABLE(DFG_JIT)