[Re-landing] DFG::SpeculativeJIT::pickCanTrample() is wrongly ignoring result registers.
[WebKit-https.git] / Source / JavaScriptCore / dfg / DFGCallArrayAllocatorSlowPathGenerator.h
1 /*
2  * Copyright (C) 2012-2017 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         for (unsigned i = m_plans.size(); i--;)
61             jit->silentFill(m_plans[i]);
62         jit->m_jit.exceptionCheck();
63         jit->m_jit.loadPtr(MacroAssembler::Address(m_resultGPR, JSObject::butterflyOffset()), m_storageGPR);
64         jumpTo(jit);
65     }
66     
67 private:
68     P_JITOperation_EStZB m_function;
69     GPRReg m_resultGPR;
70     GPRReg m_storageGPR;
71     RegisteredStructure m_structure;
72     size_t m_size;
73     Vector<SilentRegisterSavePlan, 2> m_plans;
74 };
75
76 class CallArrayAllocatorWithVariableSizeSlowPathGenerator : public JumpingSlowPathGenerator<MacroAssembler::JumpList> {
77 public:
78     CallArrayAllocatorWithVariableSizeSlowPathGenerator(
79         MacroAssembler::JumpList from, SpeculativeJIT* jit, P_JITOperation_EStZB function,
80         GPRReg resultGPR, RegisteredStructure contiguousStructure, RegisteredStructure arrayStorageStructure, GPRReg sizeGPR, GPRReg storageGPR)
81         : JumpingSlowPathGenerator<MacroAssembler::JumpList>(from, jit)
82         , m_function(function)
83         , m_resultGPR(resultGPR)
84         , m_contiguousStructure(contiguousStructure)
85         , m_arrayStorageOrContiguousStructure(arrayStorageStructure)
86         , m_sizeGPR(sizeGPR)
87         , m_storageGPR(storageGPR)
88     {
89         jit->silentSpillAllRegistersImpl(false, m_plans, resultGPR);
90     }
91
92 protected:
93     void generateInternal(SpeculativeJIT* jit) override
94     {
95         linkFrom(jit);
96         for (unsigned i = 0; i < m_plans.size(); ++i)
97             jit->silentSpill(m_plans[i]);
98         GPRReg scratchGPR = AssemblyHelpers::selectScratchGPR(m_sizeGPR, m_storageGPR);
99         if (m_contiguousStructure.get() != m_arrayStorageOrContiguousStructure.get()) {
100             MacroAssembler::Jump bigLength = jit->m_jit.branch32(MacroAssembler::AboveOrEqual, m_sizeGPR, MacroAssembler::TrustedImm32(MIN_ARRAY_STORAGE_CONSTRUCTION_LENGTH));
101             jit->m_jit.move(SpeculativeJIT::TrustedImmPtr(m_contiguousStructure), scratchGPR);
102             MacroAssembler::Jump done = jit->m_jit.jump();
103             bigLength.link(&jit->m_jit);
104             jit->m_jit.move(SpeculativeJIT::TrustedImmPtr(m_arrayStorageOrContiguousStructure), scratchGPR);
105             done.link(&jit->m_jit);
106         } else
107             jit->m_jit.move(SpeculativeJIT::TrustedImmPtr(m_contiguousStructure), scratchGPR);
108         jit->callOperation(m_function, m_resultGPR, scratchGPR, m_sizeGPR, m_storageGPR);
109         for (unsigned i = m_plans.size(); i--;)
110             jit->silentFill(m_plans[i]);
111         jit->m_jit.exceptionCheck();
112         jumpTo(jit);
113     }
114     
115 private:
116     P_JITOperation_EStZB m_function;
117     GPRReg m_resultGPR;
118     RegisteredStructure m_contiguousStructure;
119     RegisteredStructure m_arrayStorageOrContiguousStructure;
120     GPRReg m_sizeGPR;
121     GPRReg m_storageGPR;
122     Vector<SilentRegisterSavePlan, 2> m_plans;
123 };
124
125 class CallArrayAllocatorWithVariableStructureVariableSizeSlowPathGenerator : public JumpingSlowPathGenerator<MacroAssembler::JumpList> {
126 public:
127     CallArrayAllocatorWithVariableStructureVariableSizeSlowPathGenerator(
128         MacroAssembler::JumpList from, SpeculativeJIT* jit, P_JITOperation_EStZB function,
129         GPRReg resultGPR, GPRReg structureGPR, GPRReg sizeGPR, GPRReg storageGPR)
130         : JumpingSlowPathGenerator<MacroAssembler::JumpList>(from, jit)
131         , m_function(function)
132         , m_resultGPR(resultGPR)
133         , m_structureGPR(structureGPR)
134         , m_sizeGPR(sizeGPR)
135         , m_storageGPR(storageGPR)
136     {
137         jit->silentSpillAllRegistersImpl(false, m_plans, resultGPR);
138     }
139
140 protected:
141     void generateInternal(SpeculativeJIT* jit) override
142     {
143         linkFrom(jit);
144         for (unsigned i = 0; i < m_plans.size(); ++i)
145             jit->silentSpill(m_plans[i]);
146         jit->callOperation(m_function, m_resultGPR, m_structureGPR, m_sizeGPR, m_storageGPR);
147         for (unsigned i = m_plans.size(); i--;)
148             jit->silentFill(m_plans[i]);
149         jit->m_jit.exceptionCheck();
150         jumpTo(jit);
151     }
152     
153 private:
154     P_JITOperation_EStZB m_function;
155     GPRReg m_resultGPR;
156     GPRReg m_structureGPR;
157     GPRReg m_sizeGPR;
158     GPRReg m_storageGPR;
159     Vector<SilentRegisterSavePlan, 2> m_plans;
160 };
161
162 } } // namespace JSC::DFG
163
164 #endif // ENABLE(DFG_JIT)