JavaScriptCore-7601.1.46.3.tar.gz

[apple/javascriptcore.git] / dfg / DFGInsertionSet.h

diff --git a/dfg/DFGInsertionSet.h b/dfg/DFGInsertionSet.h
index 82a6a6fa42f4286d9dcaf938e26c1c17ae87d5a8..c5ed4c207afb0b86843e037cb0b2c42fd47d15c6 100644 (file)
--- a/dfg/DFGInsertionSet.h
+++ b/dfg/DFGInsertionSet.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012 Apple Inc. All rights reserved.
+ * Copyright (C) 2012, 2013, 2014 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -24,70 +24,134 @@
  */
 
 #ifndef DFGInsertionSet_h
-#define DFGInsectionSet_h
-
-#include <wtf/Platform.h>
+#define DFGInsertionSet_h
 
 #if ENABLE(DFG_JIT)
 
+#include "DFGGraph.h"
+#include <wtf/Insertion.h>
 #include <wtf/Vector.h>
 
 namespace JSC { namespace DFG {
 
-template<typename ElementType>
-class Insertion {
+typedef WTF::Insertion<Node*> Insertion;
+
+class InsertionSet {
 public:
-    Insertion() { }
-    
-    Insertion(size_t index, const ElementType& element)
-        : m_index(index)
-        , m_element(element)
+    InsertionSet(Graph& graph)
+        : m_graph(graph)
     {
     }
     
-    size_t index() const { return m_index; }
-    const ElementType& element() const { return m_element; }
-private:
-    size_t m_index;
-    ElementType m_element;
-};
-
-template<typename ElementType>
-class InsertionSet {
-public:
-    InsertionSet() { }
+    Graph& graph() { return m_graph; }
     
-    void append(const Insertion<ElementType>& insertion)
+    Node* insert(const Insertion& insertion)
     {
         ASSERT(!m_insertions.size() || m_insertions.last().index() <= insertion.index());
         m_insertions.append(insertion);
+        return insertion.element();
     }
     
-    void append(size_t index, const ElementType& element)
+    Node* insert(size_t index, Node* element)
+    {
+        return insert(Insertion(index, element));
+    }
+
+    template<typename... Params>
+    Node* insertNode(size_t index, SpeculatedType type, Params... params)
     {
-        append(Insertion<ElementType>(index, element));
+        return insert(index, m_graph.addNode(type, params...));
     }
     
-    template<typename CollectionType>
-    void execute(CollectionType& collection)
-    {
-        if (!m_insertions.size())
-            return;
-        collection.grow(collection.size() + m_insertions.size());
-        size_t lastIndex = collection.size();
-        for (size_t indexInInsertions = m_insertions.size(); indexInInsertions--;) {
-            Insertion<ElementType>& insertion = m_insertions[indexInInsertions];
-            size_t firstIndex = insertion.index() + indexInInsertions;
-            size_t indexOffset = indexInInsertions + 1;
-            for (size_t i = lastIndex; i-- > firstIndex;)
-                collection[i] = collection[i - indexOffset];
-            collection[firstIndex] = insertion.element();
-            lastIndex = firstIndex;
-        }
-        m_insertions.resize(0);
+    Node* insertConstant(
+        size_t index, NodeOrigin origin, FrozenValue* value,
+        NodeType op = JSConstant)
+    {
+        return insertNode(
+            index, speculationFromValue(value->value()), op, origin, OpInfo(value));
+    }
+    
+    Node* insertConstant(
+        size_t index, CodeOrigin origin, FrozenValue* value, NodeType op = JSConstant)
+    {
+        return insertConstant(index, NodeOrigin(origin), value, op);
+    }
+    
+    Edge insertConstantForUse(
+        size_t index, NodeOrigin origin, FrozenValue* value, UseKind useKind)
+    {
+        NodeType op;
+        if (isDouble(useKind))
+            op = DoubleConstant;
+        else if (useKind == Int52RepUse)
+            op = Int52Constant;
+        else
+            op = JSConstant;
+        return Edge(insertConstant(index, origin, value, op), useKind);
+    }
+    
+    Edge insertConstantForUse(
+        size_t index, CodeOrigin origin, FrozenValue* value, UseKind useKind)
+    {
+        return insertConstantForUse(index, NodeOrigin(origin), value, useKind);
+    }
+
+    Node* insertConstant(size_t index, NodeOrigin origin, JSValue value, NodeType op = JSConstant)
+    {
+        return insertConstant(index, origin, m_graph.freeze(value), op);
+    }
+    
+    Node* insertConstant(size_t index, CodeOrigin origin, JSValue value, NodeType op = JSConstant)
+    {
+        return insertConstant(index, origin, m_graph.freeze(value), op);
+    }
+    
+    Edge insertConstantForUse(size_t index, NodeOrigin origin, JSValue value, UseKind useKind)
+    {
+        return insertConstantForUse(index, origin, m_graph.freeze(value), useKind);
+    }
+    
+    Edge insertConstantForUse(size_t index, CodeOrigin origin, JSValue value, UseKind useKind)
+    {
+        return insertConstantForUse(index, NodeOrigin(origin), value, useKind);
+    }
+    
+    Edge insertBottomConstantForUse(size_t index, NodeOrigin origin, UseKind useKind)
+    {
+        if (isDouble(useKind))
+            return insertConstantForUse(index, origin, jsNumber(PNaN), useKind);
+        if (useKind == Int52RepUse)
+            return insertConstantForUse(index, origin, jsNumber(0), useKind);
+        return insertConstantForUse(index, origin, jsUndefined(), useKind);
+    }
+    
+    Node* insertCheck(size_t index, NodeOrigin origin, AdjacencyList children)
+    {
+        children = children.justChecks();
+        if (children.isEmpty())
+            return nullptr;
+        return insertNode(index, SpecNone, Check, origin, children);
+    }
+    
+    Node* insertCheck(size_t index, Node* node)
+    {
+        return insertCheck(index, node->origin, node->children);
+    }
+    
+    Node* insertCheck(size_t index, NodeOrigin origin, Edge edge)
+    {
+        if (edge.willHaveCheck())
+            return insertNode(index, SpecNone, Check, origin, edge);
+        return nullptr;
+    }
+    
+    void execute(BasicBlock* block)
+    {
+        executeInsertions(*block, m_insertions);
     }
 private:
-    Vector<Insertion<ElementType>, 8> m_insertions;
+    Graph& m_graph;
+    Vector<Insertion, 8> m_insertions;
 };
 
 } } // namespace JSC::DFG