We should support CreateThis in the FTL
[WebKit-https.git] / Source / JavaScriptCore / bytecode / CodeOrigin.h
1 /*
2  * Copyright (C) 2011-2018 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 #include "CodeBlockHash.h"
29 #include "ExitingInlineKind.h"
30 #include <limits.h>
31 #include <wtf/HashMap.h>
32 #include <wtf/PrintStream.h>
33 #include <wtf/StdLibExtras.h>
34 #include <wtf/Vector.h>
35
36 namespace JSC {
37
38 class CodeBlock;
39 struct DumpContext;
40 struct InlineCallFrame;
41
42 struct CodeOrigin {
43     static const unsigned invalidBytecodeIndex = UINT_MAX;
44     
45     // Bytecode offset that you'd use to re-execute this instruction, and the
46     // bytecode index of the bytecode instruction that produces some result that
47     // you're interested in (used for mapping Nodes whose values you're using
48     // to bytecode instructions that have the appropriate value profile).
49     unsigned bytecodeIndex;
50     
51     InlineCallFrame* inlineCallFrame;
52     
53     CodeOrigin()
54         : bytecodeIndex(invalidBytecodeIndex)
55         , inlineCallFrame(0)
56     {
57     }
58     
59     CodeOrigin(WTF::HashTableDeletedValueType)
60         : bytecodeIndex(invalidBytecodeIndex)
61         , inlineCallFrame(deletedMarker())
62     {
63     }
64     
65     explicit CodeOrigin(unsigned bytecodeIndex, InlineCallFrame* inlineCallFrame = 0)
66         : bytecodeIndex(bytecodeIndex)
67         , inlineCallFrame(inlineCallFrame)
68     {
69         ASSERT(bytecodeIndex < invalidBytecodeIndex);
70     }
71     
72     bool isSet() const { return bytecodeIndex != invalidBytecodeIndex; }
73     explicit operator bool() const { return isSet(); }
74     
75     bool isHashTableDeletedValue() const
76     {
77         return bytecodeIndex == invalidBytecodeIndex && !!inlineCallFrame;
78     }
79     
80     // The inline depth is the depth of the inline stack, so 1 = not inlined,
81     // 2 = inlined one deep, etc.
82     unsigned inlineDepth() const;
83     
84     // If the code origin corresponds to inlined code, gives you the heap object that
85     // would have owned the code if it had not been inlined. Otherwise returns 0.
86     CodeBlock* codeOriginOwner() const;
87     
88     int stackOffset() const;
89     
90     static unsigned inlineDepthForCallFrame(InlineCallFrame*);
91     
92     ExitingInlineKind exitingInlineKind() const
93     {
94         return inlineCallFrame ? ExitFromInlined : ExitFromNotInlined;
95     }
96     
97     unsigned hash() const;
98     bool operator==(const CodeOrigin& other) const;
99     bool operator!=(const CodeOrigin& other) const { return !(*this == other); }
100     
101     // This checks if the two code origins correspond to the same stack trace snippets,
102     // but ignore whether the InlineCallFrame's are identical.
103     bool isApproximatelyEqualTo(const CodeOrigin& other, InlineCallFrame* terminal = nullptr) const;
104     
105     unsigned approximateHash(InlineCallFrame* terminal = nullptr) const;
106
107     template <typename Function>
108     void walkUpInlineStack(const Function&);
109     
110     // Get the inline stack. This is slow, and is intended for debugging only.
111     Vector<CodeOrigin> inlineStack() const;
112     
113     JS_EXPORT_PRIVATE void dump(PrintStream&) const;
114     void dumpInContext(PrintStream&, DumpContext*) const;
115     
116 private:
117     static InlineCallFrame* deletedMarker()
118     {
119         return bitwise_cast<InlineCallFrame*>(static_cast<uintptr_t>(1));
120     }
121 };
122
123 inline unsigned CodeOrigin::hash() const
124 {
125     return WTF::IntHash<unsigned>::hash(bytecodeIndex) +
126         WTF::PtrHash<InlineCallFrame*>::hash(inlineCallFrame);
127 }
128
129 inline bool CodeOrigin::operator==(const CodeOrigin& other) const
130 {
131     return bytecodeIndex == other.bytecodeIndex
132         && inlineCallFrame == other.inlineCallFrame;
133 }
134
135 struct CodeOriginHash {
136     static unsigned hash(const CodeOrigin& key) { return key.hash(); }
137     static bool equal(const CodeOrigin& a, const CodeOrigin& b) { return a == b; }
138     static const bool safeToCompareToEmptyOrDeleted = true;
139 };
140
141 struct CodeOriginApproximateHash {
142     static unsigned hash(const CodeOrigin& key) { return key.approximateHash(); }
143     static bool equal(const CodeOrigin& a, const CodeOrigin& b) { return a.isApproximatelyEqualTo(b); }
144     static const bool safeToCompareToEmptyOrDeleted = true;
145 };
146
147 } // namespace JSC
148
149 namespace WTF {
150
151 template<typename T> struct DefaultHash;
152 template<> struct DefaultHash<JSC::CodeOrigin> {
153     typedef JSC::CodeOriginHash Hash;
154 };
155
156 template<typename T> struct HashTraits;
157 template<> struct HashTraits<JSC::CodeOrigin> : SimpleClassHashTraits<JSC::CodeOrigin> {
158     static const bool emptyValueIsZero = false;
159 };
160
161 } // namespace WTF