eb68fa344b42659d2b57a36c4af5e003d7743907
[WebKit-https.git] / Source / JavaScriptCore / dfg / DFGDriver.cpp
1 /*
2  * Copyright (C) 2011, 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 #include "config.h"
27 #include "DFGDriver.h"
28
29 #include "JSObject.h"
30 #include "JSString.h"
31
32
33 #if ENABLE(DFG_JIT)
34
35 #include "DFGArgumentsSimplificationPhase.h"
36 #include "DFGByteCodeParser.h"
37 #include "DFGCFAPhase.h"
38 #include "DFGCFGSimplificationPhase.h"
39 #include "DFGCSEPhase.h"
40 #include "DFGConstantFoldingPhase.h"
41 #include "DFGFixupPhase.h"
42 #include "DFGJITCompiler.h"
43 #include "DFGPredictionPropagationPhase.h"
44 #include "DFGStructureCheckHoistingPhase.h"
45 #include "DFGValidate.h"
46 #include "DFGVirtualRegisterAllocationPhase.h"
47 #include "Options.h"
48
49 namespace JSC { namespace DFG {
50
51 static unsigned numCompilations;
52
53 unsigned getNumCompilations()
54 {
55     return numCompilations;
56 }
57
58 enum CompileMode { CompileFunction, CompileOther };
59 inline bool compile(CompileMode compileMode, ExecState* exec, CodeBlock* codeBlock, JITCode& jitCode, MacroAssemblerCodePtr* jitCodeWithArityCheck, unsigned osrEntryBytecodeIndex)
60 {
61     SamplingRegion samplingRegion("DFG Compilation (Driver)");
62     
63     numCompilations++;
64     
65     ASSERT(codeBlock);
66     ASSERT(codeBlock->alternative());
67     ASSERT(codeBlock->alternative()->getJITType() == JITCode::BaselineJIT);
68     
69     ASSERT(osrEntryBytecodeIndex != UINT_MAX);
70
71     if (!Options::useDFGJIT())
72         return false;
73     
74 #if DFG_ENABLE(DEBUG_VERBOSE)
75     dataLog("DFG compiling code block %p(%p) for executable %p, number of instructions = %u.\n", codeBlock, codeBlock->alternative(), codeBlock->ownerExecutable(), codeBlock->instructionCount());
76 #endif
77     
78     // Derive our set of must-handle values. The compilation must be at least conservative
79     // enough to allow for OSR entry with these values.
80     unsigned numVarsWithValues;
81     if (osrEntryBytecodeIndex)
82         numVarsWithValues = codeBlock->m_numVars;
83     else
84         numVarsWithValues = 0;
85     Operands<JSValue> mustHandleValues(codeBlock->numParameters(), numVarsWithValues);
86     for (size_t i = 0; i < mustHandleValues.size(); ++i) {
87         int operand = mustHandleValues.operandForIndex(i);
88         if (operandIsArgument(operand)
89             && !operandToArgument(operand)
90             && compileMode == CompileFunction
91             && codeBlock->specializationKind() == CodeForConstruct) {
92             // Ugh. If we're in a constructor, the 'this' argument may hold garbage. It will
93             // also never be used. It doesn't matter what we put into the value for this,
94             // but it has to be an actual value that can be grokked by subsequent DFG passes,
95             // so we sanitize it here by turning it into Undefined.
96             mustHandleValues[i] = jsUndefined();
97         } else
98             mustHandleValues[i] = exec->uncheckedR(operand).jsValue();
99     }
100     
101     Graph dfg(exec->globalData(), codeBlock, osrEntryBytecodeIndex, mustHandleValues);
102     if (!parse(exec, dfg))
103         return false;
104     
105     if (compileMode == CompileFunction)
106         dfg.predictArgumentTypes();
107     
108     // By this point the DFG bytecode parser will have potentially mutated various tables
109     // in the CodeBlock. This is a good time to perform an early shrink, which is more
110     // powerful than a late one. It's safe to do so because we haven't generated any code
111     // that references any of the tables directly, yet.
112     codeBlock->shrinkToFit(CodeBlock::EarlyShrink);
113
114     validate(dfg);
115     performPredictionPropagation(dfg);
116     performFixup(dfg);
117     performStructureCheckHoisting(dfg);
118     unsigned cnt = 1;
119     dfg.m_fixpointState = FixpointNotConverged;
120     for (;; ++cnt) {
121 #if DFG_ENABLE(DEBUG_VERBOSE)
122         dataLog("DFG beginning optimization fixpoint iteration #%u.\n", cnt);
123 #endif
124         bool changed = false;
125         performCFA(dfg);
126         changed |= performConstantFolding(dfg);
127         changed |= performArgumentsSimplification(dfg);
128         changed |= performCFGSimplification(dfg);
129         changed |= performCSE(dfg);
130         if (!changed)
131             break;
132         dfg.resetExitStates();
133         performFixup(dfg);
134     }
135     dfg.m_fixpointState = FixpointConverged;
136     performCSE(dfg);
137 #if DFG_ENABLE(DEBUG_VERBOSE)
138     dataLog("DFG optimization fixpoint converged in %u iterations.\n", cnt);
139 #endif
140     performVirtualRegisterAllocation(dfg);
141
142     GraphDumpMode modeForFinalValidate = DumpGraph;
143 #if DFG_ENABLE(DEBUG_VERBOSE)
144     dataLog("Graph after optimization:\n");
145     dfg.dump();
146     modeForFinalValidate = DontDumpGraph;
147 #endif
148     validate(dfg, modeForFinalValidate);
149     
150     JITCompiler dataFlowJIT(dfg);
151     bool result;
152     if (compileMode == CompileFunction) {
153         ASSERT(jitCodeWithArityCheck);
154         
155         result = dataFlowJIT.compileFunction(jitCode, *jitCodeWithArityCheck);
156     } else {
157         ASSERT(compileMode == CompileOther);
158         ASSERT(!jitCodeWithArityCheck);
159         
160         result = dataFlowJIT.compile(jitCode);
161     }
162     
163     return result;
164 }
165
166 bool tryCompile(ExecState* exec, CodeBlock* codeBlock, JITCode& jitCode, unsigned bytecodeIndex)
167 {
168     return compile(CompileOther, exec, codeBlock, jitCode, 0, bytecodeIndex);
169 }
170
171 bool tryCompileFunction(ExecState* exec, CodeBlock* codeBlock, JITCode& jitCode, MacroAssemblerCodePtr& jitCodeWithArityCheck, unsigned bytecodeIndex)
172 {
173     return compile(CompileFunction, exec, codeBlock, jitCode, &jitCodeWithArityCheck, bytecodeIndex);
174 }
175
176 } } // namespace JSC::DFG
177
178 #endif // ENABLE(DFG_JIT)
179