webkitgtk-2.4.9webkitgtk-2.4.9

1 files changed, 16 insertions, 106 deletions

diff --git a/Source/JavaScriptCore/bytecode/CodeOrigin.h b/Source/JavaScriptCore/bytecode/CodeOrigin.h
index d1879a327..ed660c247 100644
--- a/Source/JavaScriptCore/bytecode/CodeOrigin.h
+++ b/Source/JavaScriptCore/bytecode/CodeOrigin.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2015 Apple Inc. All rights reserved.
+ * Copyright (C) 2011, 2012, 2013 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -28,6 +28,7 @@
 
 #include "CodeBlockHash.h"
 #include "CodeSpecializationKind.h"
+#include "JSFunction.h"
 #include "ValueRecovery.h"
 #include "WriteBarrier.h"
 #include <wtf/BitVector.h>
@@ -62,7 +63,7 @@ struct CodeOrigin {
     
     CodeOrigin(WTF::HashTableDeletedValueType)
         : bytecodeIndex(invalidBytecodeIndex)
-        , inlineCallFrame(deletedMarker())
+        , inlineCallFrame(bitwise_cast<InlineCallFrame*>(static_cast<uintptr_t>(1)))
     {
     }
     
@@ -74,7 +75,6 @@ struct CodeOrigin {
     }
     
     bool isSet() const { return bytecodeIndex != invalidBytecodeIndex; }
-    bool operator!() const { return !isSet(); }
     
     bool isHashTableDeletedValue() const
     {
@@ -97,133 +97,51 @@ struct CodeOrigin {
     bool operator==(const CodeOrigin& other) const;
     bool operator!=(const CodeOrigin& other) const { return !(*this == other); }
     
-    // This checks if the two code origins correspond to the same stack trace snippets,
-    // but ignore whether the InlineCallFrame's are identical.
-    bool isApproximatelyEqualTo(const CodeOrigin& other) const;
-    
-    unsigned approximateHash() const;
-    
     // Get the inline stack. This is slow, and is intended for debugging only.
     Vector<CodeOrigin> inlineStack() const;
     
     void dump(PrintStream&) const;
     void dumpInContext(PrintStream&, DumpContext*) const;
-
-private:
-    static InlineCallFrame* deletedMarker()
-    {
-        return bitwise_cast<InlineCallFrame*>(static_cast<uintptr_t>(1));
-    }
 };
 
 struct InlineCallFrame {
-    enum Kind {
-        Call,
-        Construct,
-        CallVarargs,
-        ConstructVarargs,
-        
-        // For these, the stackOffset incorporates the argument count plus the true return PC
-        // slot.
-        GetterCall,
-        SetterCall
-    };
-    
-    static Kind kindFor(CodeSpecializationKind kind)
-    {
-        switch (kind) {
-        case CodeForCall:
-            return Call;
-        case CodeForConstruct:
-            return Construct;
-        }
-        RELEASE_ASSERT_NOT_REACHED();
-        return Call;
-    }
-    
-    static Kind varargsKindFor(CodeSpecializationKind kind)
-    {
-        switch (kind) {
-        case CodeForCall:
-            return CallVarargs;
-        case CodeForConstruct:
-            return ConstructVarargs;
-        }
-        RELEASE_ASSERT_NOT_REACHED();
-        return Call;
-    }
-    
-    static CodeSpecializationKind specializationKindFor(Kind kind)
-    {
-        switch (kind) {
-        case Call:
-        case CallVarargs:
-        case GetterCall:
-        case SetterCall:
-            return CodeForCall;
-        case Construct:
-        case ConstructVarargs:
-            return CodeForConstruct;
-        }
-        RELEASE_ASSERT_NOT_REACHED();
-        return CodeForCall;
-    }
-    
-    static bool isVarargs(Kind kind)
-    {
-        switch (kind) {
-        case CallVarargs:
-        case ConstructVarargs:
-            return true;
-        default:
-            return false;
-        }
-    }
-    bool isVarargs() const
-    {
-        return isVarargs(static_cast<Kind>(kind));
-    }
-    
-    Vector<ValueRecovery> arguments; // Includes 'this'.
+    Vector<ValueRecovery> arguments;
     WriteBarrier<ScriptExecutable> executable;
     ValueRecovery calleeRecovery;
     CodeOrigin caller;
-
-    signed stackOffset : 28;
-    unsigned kind : 3; // real type is Kind
+    BitVector capturedVars; // Indexed by the machine call frame's variable numbering.
+    signed stackOffset : 30;
+    bool isCall : 1;
     bool isClosureCall : 1; // If false then we know that callee/scope are constants and the DFG won't treat them as variables, i.e. they have to be recovered manually.
-    VirtualRegister argumentCountRegister; // Only set when we inline a varargs call.
+    VirtualRegister argumentsRegister; // This is only set if the code uses arguments. The unmodified arguments register follows the unmodifiedArgumentsRegister() convention (see CodeBlock.h).
     
     // There is really no good notion of a "default" set of values for
     // InlineCallFrame's fields. This constructor is here just to reduce confusion if
     // we forgot to initialize explicitly.
     InlineCallFrame()
         : stackOffset(0)
-        , kind(Call)
+        , isCall(false)
         , isClosureCall(false)
     {
     }
     
-    CodeSpecializationKind specializationKind() const { return specializationKindFor(static_cast<Kind>(kind)); }
+    CodeSpecializationKind specializationKind() const { return specializationFromIsCall(isCall); }
 
-    JSFunction* calleeConstant() const;
-    void visitAggregate(SlotVisitor&);
+    JSFunction* calleeConstant() const
+    {
+        if (calleeRecovery.isConstant())
+            return jsCast<JSFunction*>(calleeRecovery.constant());
+        return 0;
+    }
     
     // Get the callee given a machine call frame to which this InlineCallFrame belongs.
     JSFunction* calleeForCallFrame(ExecState*) const;
     
     CString inferredName() const;
     CodeBlockHash hash() const;
-    CString hashAsStringIfPossible() const;
     
     CodeBlock* baselineCodeBlock() const;
     
-    void setStackOffset(signed offset)
-    {
-        stackOffset = offset;
-        RELEASE_ASSERT(static_cast<signed>(stackOffset) == offset);
-    }
-
     ptrdiff_t callerFrameOffset() const { return stackOffset * sizeof(Register) + CallFrame::callerFrameOffset(); }
     ptrdiff_t returnPCOffset() const { return stackOffset * sizeof(Register) + CallFrame::returnPCOffset(); }
 
@@ -267,18 +185,10 @@ struct CodeOriginHash {
     static const bool safeToCompareToEmptyOrDeleted = true;
 };
 
-struct CodeOriginApproximateHash {
-    static unsigned hash(const CodeOrigin& key) { return key.approximateHash(); }
-    static bool equal(const CodeOrigin& a, const CodeOrigin& b) { return a.isApproximatelyEqualTo(b); }
-    static const bool safeToCompareToEmptyOrDeleted = true;
-};
-
 } // namespace JSC
 
 namespace WTF {
 
-void printInternal(PrintStream&, JSC::InlineCallFrame::Kind);
-
 template<typename T> struct DefaultHash;
 template<> struct DefaultHash<JSC::CodeOrigin> {
     typedef JSC::CodeOriginHash Hash;