webkitgtk-2.16.5HEADwebkitgtk-2.16.5master

1 files changed, 92 insertions, 37 deletions

diff --git a/Source/JavaScriptCore/ftl/FTLExitValue.h b/Source/JavaScriptCore/ftl/FTLExitValue.h
index 7aaaedd8d..c9946b2e7 100644
--- a/Source/JavaScriptCore/ftl/FTLExitValue.h
+++ b/Source/JavaScriptCore/ftl/FTLExitValue.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Apple Inc. All rights reserved.
+ * Copyright (C) 2013-2015 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -23,19 +23,21 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
-#ifndef FTLExitValue_h
-#define FTLExitValue_h
-
-#include <wtf/Platform.h>
+#pragma once
 
 #if ENABLE(FTL_JIT)
 
 #include "FTLExitArgument.h"
+#include "FTLRecoveryOpcode.h"
 #include "JSCJSValue.h"
 #include "VirtualRegister.h"
 #include <wtf/PrintStream.h>
 
-namespace JSC { namespace FTL {
+namespace JSC {
+
+class TrackedReferences;
+
+namespace FTL {
 
 // This is like ValueRecovery, but respects the way that the FTL does OSR
 // exit: the live non-constant non-flushed values are passed as arguments
@@ -51,9 +53,13 @@ enum ExitValueKind {
     ExitValueInJSStack,
     ExitValueInJSStackAsInt32,
     ExitValueInJSStackAsInt52,
-    ExitValueInJSStackAsDouble
+    ExitValueInJSStackAsDouble,
+    ExitValueRecovery,
+    ExitValueMaterializeNewObject
 };
 
+class ExitTimeObjectMaterialization;
+
 class ExitValue {
 public:
     ExitValue()
@@ -118,6 +124,19 @@ public:
         return result;
     }
     
+    static ExitValue recovery(RecoveryOpcode opcode, unsigned leftArgument, unsigned rightArgument, DataFormat format)
+    {
+        ExitValue result;
+        result.m_kind = ExitValueRecovery;
+        result.u.recovery.opcode = opcode;
+        result.u.recovery.leftArgument = leftArgument;
+        result.u.recovery.rightArgument = rightArgument;
+        result.u.recovery.format = format;
+        return result;
+    }
+    
+    static ExitValue materializeNewObject(ExitTimeObjectMaterialization*);
+    
     ExitValueKind kind() const { return m_kind; }
     
     bool isDead() const { return kind() == ExitValueDead; }
@@ -135,6 +154,9 @@ public:
     }
     bool isConstant() const { return kind() == ExitValueConstant; }
     bool isArgument() const { return kind() == ExitValueArgument; }
+    bool isRecovery() const { return kind() == ExitValueRecovery; }
+    bool isObjectMaterialization() const { return kind() == ExitValueMaterializeNewObject; }
+    bool hasIndexInStackmapLocations() const { return isArgument() || isRecovery(); }
     
     ExitArgument exitArgument() const
     {
@@ -142,6 +164,42 @@ public:
         return ExitArgument(u.argument);
     }
     
+    unsigned leftRecoveryArgument() const
+    {
+        ASSERT(isRecovery());
+        return u.recovery.leftArgument;
+    }
+    
+    unsigned rightRecoveryArgument() const
+    {
+        ASSERT(isRecovery());
+        return u.recovery.rightArgument;
+    }
+
+    void adjustStackmapLocationsIndexByOffset(unsigned offset)
+    {
+        ASSERT(hasIndexInStackmapLocations());
+        if (isArgument())
+            u.argument.argument += offset;
+        else {
+            ASSERT(isRecovery());
+            u.recovery.rightArgument += offset;
+            u.recovery.leftArgument += offset;
+        }
+    }
+    
+    DataFormat recoveryFormat() const
+    {
+        ASSERT(isRecovery());
+        return static_cast<DataFormat>(u.recovery.format);
+    }
+    
+    RecoveryOpcode recoveryOpcode() const
+    {
+        ASSERT(isRecovery());
+        return static_cast<RecoveryOpcode>(u.recovery.opcode);
+    }
+    
     JSValue constant() const
     {
         ASSERT(isConstant());
@@ -153,54 +211,51 @@ public:
         ASSERT(isInJSStackSomehow());
         return VirtualRegister(u.virtualRegister);
     }
+    
+    ExitTimeObjectMaterialization* objectMaterialization() const
+    {
+        ASSERT(isObjectMaterialization());
+        return u.newObjectMaterializationData;
+    }
 
+    ExitValue withVirtualRegister(VirtualRegister virtualRegister) const
+    {
+        ASSERT(isInJSStackSomehow());
+        ExitValue result;
+        result.m_kind = m_kind;
+        result.u.virtualRegister = virtualRegister.offset();
+        return result;
+    }
+    
+    ExitValue withLocalsOffset(int offset) const;
+    
     // If it's in the JSStack somehow, this will tell you what format it's in, in a manner
     // that is compatible with exitArgument().format(). If it's a constant or it's dead, it
     // will claim to be a JSValue. If it's an argument then it will tell you the argument's
     // format.
-    ValueFormat valueFormat() const
-    {
-        switch (kind()) {
-        case InvalidExitValue:
-            RELEASE_ASSERT_NOT_REACHED();
-            return InvalidValueFormat;
-            
-        case ExitValueDead:
-        case ExitValueConstant:
-        case ExitValueInJSStack:
-            return ValueFormatJSValue;
-            
-        case ExitValueArgument:
-            return exitArgument().format();
-            
-        case ExitValueInJSStackAsInt32:
-            return ValueFormatInt32;
-            
-        case ExitValueInJSStackAsInt52:
-            return ValueFormatInt52;
-            
-        case ExitValueInJSStackAsDouble:
-            return ValueFormatDouble;
-        }
-        
-        RELEASE_ASSERT_NOT_REACHED();
-        return InvalidValueFormat;
-    }
+    DataFormat dataFormat() const;
 
     void dump(PrintStream&) const;
     void dumpInContext(PrintStream&, DumpContext*) const;
     
+    void validateReferences(const TrackedReferences&) const;
+    
 private:
     ExitValueKind m_kind;
     union {
         ExitArgumentRepresentation argument;
         EncodedJSValue constant;
         int virtualRegister;
+        struct {
+            uint16_t leftArgument;
+            uint16_t rightArgument;
+            uint16_t opcode;
+            uint16_t format;
+        } recovery;
+        ExitTimeObjectMaterialization* newObjectMaterializationData;
     } u;
 };
 
 } } // namespace JSC::FTL
 
 #endif // ENABLE(FTL_JIT)
-
-#endif // FTLExitValue_h