git.saurik.com Git - apple/javascriptcore.git/blob

1 /*

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 */

26 #ifndef DFGPlan_h

27 #define DFGPlan_h

29 #include "CompilationResult.h"

30 #include "DFGCompilationKey.h"

31 #include "DFGCompilationMode.h"

32 #include "DFGDesiredIdentifiers.h"

33 #include "DFGDesiredTransitions.h"

34 #include "DFGDesiredWatchpoints.h"

35 #include "DFGDesiredWeakReferences.h"

36 #include "DFGDesiredWriteBarriers.h"

37 #include "DFGFinalizer.h"

38 #include "DeferredCompilationCallback.h"

39 #include "Operands.h"

40 #include "ProfilerCompilation.h"

41 #include <wtf/ThreadSafeRefCounted.h>

43 namespace JSC {

45 class CodeBlock;

46 class CodeBlockSet;

47 class SlotVisitor;

49 namespace DFG {

51 class LongLivedState;

52 class ThreadData;

54 #if ENABLE(DFG_JIT)

 struct Plan : public ThreadSafeRefCounted<Plan> {

57 Plan(

         PassRefPtr<CodeBlock> codeBlockToCompile, CodeBlock* profiledDFGCodeBlock,

59 CompilationMode, unsigned osrEntryBytecodeIndex,

60 const Operands<JSValue>& mustHandleValues);

61 ~Plan();

     void compileInThread(LongLivedState&, ThreadData*);

65 CompilationResult finalizeWithoutNotifyingCallback();

66 void finalizeAndNotifyCallback();

68 void notifyCompiling();

69 void notifyCompiled();

70 void notifyReady();

72 CompilationKey key();

     void checkLivenessAndVisitChildren(SlotVisitor&, CodeBlockSet&);

75 bool isKnownToBeLiveDuringGC();

76 void cancel();

78 VM& vm;

79 RefPtr<CodeBlock> codeBlock;

80 RefPtr<CodeBlock> profiledDFGCodeBlock;

81 CompilationMode mode;

82 const unsigned osrEntryBytecodeIndex;

83 Operands<JSValue> mustHandleValues;

85 ThreadData* threadData;

     RefPtr<Profiler::Compilation> compilation;

     std::unique_ptr<Finalizer> finalizer;

91 RefPtr<InlineCallFrameSet> inlineCallFrames;

92 DesiredWatchpoints watchpoints;

93 DesiredIdentifiers identifiers;

94 DesiredWeakReferences weakReferences;

95 DesiredWriteBarriers writeBarriers;

96 DesiredTransitions transitions;

98 bool willTryToTierUp;

     enum Stage { Preparing, Compiling, Compiled, Ready, Cancelled };

101 Stage stage;

102

103 RefPtr<DeferredCompilationCallback> callback;

104

105 private:

     bool reportCompileTimes() const;

107

     enum CompilationPath { FailPath, DFGPath, FTLPath, CancelPath };

109 CompilationPath compileInThreadImpl(LongLivedState&);

110

111 bool isStillValid();

112 void reallyAdd(CommonData*);

113

114 double m_timeBeforeFTL;

115 };

116

117 #else // ENABLE(DFG_JIT)

118

 class Plan : public RefCounted<Plan> {

120 // Dummy class to allow !ENABLE(DFG_JIT) to build.

121 };

122

123 #endif // ENABLE(DFG_JIT)

124

125 } } // namespace JSC::DFG

126

127 #endif // DFGPlan_h

128