op_mul/ArithMul(Untyped,Untyped) should be an IC
[WebKit-https.git] / Source / JavaScriptCore / jit / JITMathIC.h
1 /*
2  * Copyright (C) 2016 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(JIT)
29
30 #include "CCallHelpers.h"
31 #include "JITAddGenerator.h"
32 #include "JITMathICInlineResult.h"
33 #include "JITMulGenerator.h"
34 #include "LinkBuffer.h"
35 #include "Repatch.h"
36 #include "SnippetOperand.h"
37
38 namespace JSC {
39
40 class LinkBuffer;
41
42 struct MathICGenerationState {
43     MacroAssembler::Label fastPathStart;
44     MacroAssembler::Label fastPathEnd;
45     MacroAssembler::Label slowPathStart;
46     MacroAssembler::Call slowPathCall;
47     MacroAssembler::JumpList slowPathJumps;
48     bool shouldSlowPathRepatch;
49 };
50
51 template <typename GeneratorType>
52 class JITMathIC {
53 public:
54     CodeLocationLabel doneLocation() { return m_inlineStart.labelAtOffset(m_inlineSize); }
55     CodeLocationLabel slowPathStartLocation() { return m_inlineStart.labelAtOffset(m_deltaFromStartToSlowPathStart); }
56     CodeLocationCall slowPathCallLocation() { return m_inlineStart.callAtOffset(m_deltaFromStartToSlowPathCallLocation); }
57
58     bool isLeftOperandValidConstant() const { return m_generator.isLeftOperandValidConstant(); }
59     bool isRightOperandValidConstant() const { return m_generator.isRightOperandValidConstant(); }
60
61     bool generateInline(CCallHelpers& jit, MathICGenerationState& state, bool shouldEmitProfiling = true)
62     {
63         state.fastPathStart = jit.label();
64         size_t startSize = jit.m_assembler.buffer().codeSize();
65         JITMathICInlineResult result = m_generator.generateInline(jit, state);
66
67         switch (result) {
68         case JITMathICInlineResult::GeneratedFastPath: {
69             size_t inlineSize = jit.m_assembler.buffer().codeSize() - startSize;
70             if (static_cast<ptrdiff_t>(inlineSize) < MacroAssembler::maxJumpReplacementSize()) {
71                 size_t nopsToEmitInBytes = MacroAssembler::maxJumpReplacementSize() - inlineSize;
72                 jit.emitNops(nopsToEmitInBytes);
73             }
74             state.shouldSlowPathRepatch = true;
75             state.fastPathEnd = jit.label();
76             return true;
77         }
78         case JITMathICInlineResult::GenerateFullSnippet: {
79             MacroAssembler::JumpList endJumpList;
80             bool result = m_generator.generateFastPath(jit, endJumpList, state.slowPathJumps, shouldEmitProfiling);
81             if (result) {
82                 state.fastPathEnd = jit.label();
83                 state.shouldSlowPathRepatch = false;
84                 endJumpList.link(&jit);
85                 return true;
86             }
87             return false;
88         }
89         case JITMathICInlineResult::DontGenerate: {
90             return false;
91         }
92         default:
93             ASSERT_NOT_REACHED();
94         }
95
96         return false;
97     }
98
99     void generateOutOfLine(VM& vm, CodeBlock* codeBlock, FunctionPtr callReplacement)
100     {
101         // We rewire to the alternate regardless of whether or not we can allocate the out of line path
102         // because if we fail allocating the out of line path, we don't want to waste time trying to
103         // allocate it in the future.
104         ftlThunkAwareRepatchCall(codeBlock, slowPathCallLocation(), callReplacement);
105
106         {
107             CCallHelpers jit(&vm, codeBlock);
108
109             MacroAssembler::JumpList endJumpList; 
110             MacroAssembler::JumpList slowPathJumpList; 
111
112             bool shouldEmitProfiling = !JITCode::isOptimizingJIT(codeBlock->jitType());
113             bool emittedFastPath = m_generator.generateFastPath(jit, endJumpList, slowPathJumpList, shouldEmitProfiling);
114             if (!emittedFastPath)
115                 return;
116             endJumpList.append(jit.jump());
117
118             LinkBuffer linkBuffer(vm, jit, codeBlock, JITCompilationCanFail);
119             if (linkBuffer.didFailToAllocate())
120                 return;
121
122             linkBuffer.link(endJumpList, doneLocation());
123             linkBuffer.link(slowPathJumpList, slowPathStartLocation());
124
125             m_code = FINALIZE_CODE_FOR(
126                 codeBlock, linkBuffer, ("JITMathIC: generating out of line IC snippet"));
127         }
128
129         {
130             CCallHelpers jit(&vm, codeBlock);
131             auto jump = jit.jump();
132             // We don't need a nop sled here because nobody should be jumping into the middle of an IC.
133             bool needsBranchCompaction = false;
134             RELEASE_ASSERT(jit.m_assembler.buffer().codeSize() <= static_cast<size_t>(m_inlineSize));
135             LinkBuffer linkBuffer(jit, m_inlineStart.dataLocation(), jit.m_assembler.buffer().codeSize(), JITCompilationMustSucceed, needsBranchCompaction);
136             RELEASE_ASSERT(linkBuffer.isValid());
137             linkBuffer.link(jump, CodeLocationLabel(m_code.code()));
138             FINALIZE_CODE(linkBuffer, ("JITMathIC: linking constant jump to out of line stub"));
139         }
140     }
141
142     void finalizeInlineCode(const MathICGenerationState& state, LinkBuffer& linkBuffer)
143     {
144         CodeLocationLabel start = linkBuffer.locationOf(state.fastPathStart);
145         m_inlineStart = start;
146
147         m_inlineSize = MacroAssembler::differenceBetweenCodePtr(
148             start, linkBuffer.locationOf(state.fastPathEnd));
149         ASSERT(m_inlineSize > 0);
150
151         m_deltaFromStartToSlowPathCallLocation = MacroAssembler::differenceBetweenCodePtr(
152             start, linkBuffer.locationOf(state.slowPathCall));
153         m_deltaFromStartToSlowPathStart = MacroAssembler::differenceBetweenCodePtr(
154             start, linkBuffer.locationOf(state.slowPathStart));
155     }
156
157     MacroAssemblerCodeRef m_code;
158     CodeLocationLabel m_inlineStart;
159     int32_t m_inlineSize;
160     int32_t m_deltaFromStartToSlowPathCallLocation;
161     int32_t m_deltaFromStartToSlowPathStart;
162     GeneratorType m_generator;
163 };
164
165 typedef JITMathIC<JITAddGenerator> JITAddIC;
166 typedef JITMathIC<JITMulGenerator> JITMulIC;
167
168 } // namespace JSC
169
170 #endif // ENABLE(JIT)