webkitgtk-2.4.11webkitgtk-2.4.11

1 files changed, 25 insertions, 108 deletions

diff --git a/Source/JavaScriptCore/dfg/DFGUseKind.h b/Source/JavaScriptCore/dfg/DFGUseKind.h
index 41527f647..7ad390524 100644
--- a/Source/JavaScriptCore/dfg/DFGUseKind.h
+++ b/Source/JavaScriptCore/dfg/DFGUseKind.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2016 Apple Inc. All rights reserved.
+ * Copyright (C) 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
@@ -26,64 +26,40 @@
 #ifndef DFGUseKind_h
 #define DFGUseKind_h
 
+#include <wtf/Platform.h>
+
 #if ENABLE(DFG_JIT)
 
-#include "DFGNodeFlags.h"
 #include "SpeculatedType.h"
 #include <wtf/PrintStream.h>
 
 namespace JSC { namespace DFG {
 
 enum UseKind {
-    // The DFG has 3 representations of values used:
-
-    // 1. The JSValue representation for a JSValue that must be stored in a GP
-    //    register (or a GP register pair), and follows rules for boxing and unboxing
-    //    that allow the JSValue to be stored as either fully boxed JSValues, or
-    //    unboxed Int32, Booleans, Cells, etc. in 32-bit as appropriate.
-    UntypedUse, // UntypedUse must come first (value 0).
+    UntypedUse,
     Int32Use,
     KnownInt32Use,
     MachineIntUse,
-    NumberUse,
     RealNumberUse,
+    NumberUse,
+    KnownNumberUse,
     BooleanUse,
-    KnownBooleanUse,
     CellUse,
     KnownCellUse,
-    CellOrOtherUse,
     ObjectUse,
-    FunctionUse,
     FinalObjectUse,
-    RegExpObjectUse,
     ObjectOrOtherUse,
     StringIdentUse,
     StringUse,
-    StringOrOtherUse,
     KnownStringUse,
-    KnownPrimitiveUse, // This bizarre type arises for op_strcat, which has a bytecode guarantee that it will only see primitives (i.e. not objects).
-    SymbolUse,
     StringObjectUse,
     StringOrStringObjectUse,
-    NotStringVarUse,
     NotCellUse,
     OtherUse,
-    MiscUse,
-
-    // 2. The Double representation for an unboxed double value that must be stored
-    //    in an FP register.
-    DoubleRepUse,
-    DoubleRepRealUse,
-    DoubleRepMachineIntUse,
-
-    // 3. The Int52 representation for an unboxed integer value that must be stored
-    //    in a GP register.
-    Int52RepUse,
-
     LastUseKind // Must always be the last entry in the enum, as it is used to denote the number of enum elements.
 };
 
-inline SpeculatedType typeFilterFor(UseKind useKind)
+ALWAYS_INLINE SpeculatedType typeFilterFor(UseKind useKind)
 {
     switch (useKind) {
     case UntypedUse:
@@ -91,36 +67,22 @@ inline SpeculatedType typeFilterFor(UseKind useKind)
     case Int32Use:
     case KnownInt32Use:
         return SpecInt32;
-    case Int52RepUse:
-        return SpecMachineInt;
     case MachineIntUse:
-        return SpecInt32 | SpecInt52AsDouble;
-    case NumberUse:
-        return SpecBytecodeNumber;
+        return SpecMachineInt;
     case RealNumberUse:
-        return SpecBytecodeRealNumber;
-    case DoubleRepUse:
-        return SpecFullDouble;
-    case DoubleRepRealUse:
-        return SpecDoubleReal;
-    case DoubleRepMachineIntUse:
-        return SpecInt52AsDouble;
+        return SpecFullRealNumber;
+    case NumberUse:
+    case KnownNumberUse:
+        return SpecFullNumber;
     case BooleanUse:
-    case KnownBooleanUse:
         return SpecBoolean;
     case CellUse:
     case KnownCellUse:
         return SpecCell;
-    case CellOrOtherUse:
-        return SpecCell | SpecOther;
     case ObjectUse:
         return SpecObject;
-    case FunctionUse:
-        return SpecFunction;
     case FinalObjectUse:
         return SpecFinalObject;
-    case RegExpObjectUse:
-        return SpecRegExpObject;
     case ObjectOrOtherUse:
         return SpecObject | SpecOther;
     case StringIdentUse:
@@ -128,97 +90,76 @@ inline SpeculatedType typeFilterFor(UseKind useKind)
     case StringUse:
     case KnownStringUse:
         return SpecString;
-    case StringOrOtherUse:
-        return SpecString | SpecOther;
-    case KnownPrimitiveUse:
-        return SpecHeapTop & ~SpecObject;
-    case SymbolUse:
-        return SpecSymbol;
     case StringObjectUse:
         return SpecStringObject;
     case StringOrStringObjectUse:
         return SpecString | SpecStringObject;
-    case NotStringVarUse:
-        return ~SpecStringVar;
     case NotCellUse:
         return ~SpecCell;
     case OtherUse:
         return SpecOther;
-    case MiscUse:
-        return SpecMisc;
     default:
         RELEASE_ASSERT_NOT_REACHED();
         return SpecFullTop;
     }
 }
 
-inline bool shouldNotHaveTypeCheck(UseKind kind)
+ALWAYS_INLINE bool shouldNotHaveTypeCheck(UseKind kind)
 {
     switch (kind) {
     case UntypedUse:
     case KnownInt32Use:
+    case KnownNumberUse:
     case KnownCellUse:
     case KnownStringUse:
-    case KnownPrimitiveUse:
-    case KnownBooleanUse:
-    case Int52RepUse:
-    case DoubleRepUse:
         return true;
     default:
         return false;
     }
 }
 
-inline bool mayHaveTypeCheck(UseKind kind)
+ALWAYS_INLINE bool mayHaveTypeCheck(UseKind kind)
 {
     return !shouldNotHaveTypeCheck(kind);
 }
 
-inline bool isNumerical(UseKind kind)
+ALWAYS_INLINE bool isNumerical(UseKind kind)
 {
     switch (kind) {
     case Int32Use:
     case KnownInt32Use:
-    case NumberUse:
-    case RealNumberUse:
-    case Int52RepUse:
-    case DoubleRepUse:
-    case DoubleRepRealUse:
     case MachineIntUse:
-    case DoubleRepMachineIntUse:
+    case RealNumberUse:
+    case NumberUse:
+    case KnownNumberUse:
         return true;
     default:
         return false;
     }
 }
 
-inline bool isDouble(UseKind kind)
+ALWAYS_INLINE bool isDouble(UseKind kind)
 {
     switch (kind) {
-    case DoubleRepUse:
-    case DoubleRepRealUse:
-    case DoubleRepMachineIntUse:
+    case RealNumberUse:
+    case NumberUse:
+    case KnownNumberUse:
         return true;
     default:
         return false;
     }
 }
 
-// Returns true if the use kind only admits cells, and is therefore appropriate for
-// SpeculateCellOperand in the DFG or lowCell() in the FTL.
-inline bool isCell(UseKind kind)
+ALWAYS_INLINE bool isCell(UseKind kind)
 {
     switch (kind) {
     case CellUse:
     case KnownCellUse:
     case ObjectUse:
-    case FunctionUse:
     case FinalObjectUse:
-    case RegExpObjectUse:
     case StringIdentUse:
     case StringUse:
     case KnownStringUse:
-    case SymbolUse:
     case StringObjectUse:
     case StringOrStringObjectUse:
         return true;
@@ -229,7 +170,7 @@ inline bool isCell(UseKind kind)
 
 // Returns true if it uses structure in a way that could be clobbered by
 // things that change the structure.
-inline bool usesStructure(UseKind kind)
+ALWAYS_INLINE bool usesStructure(UseKind kind)
 {
     switch (kind) {
     case StringObjectUse:
@@ -240,30 +181,6 @@ inline bool usesStructure(UseKind kind)
     }
 }
 
-// Returns true if we've already guaranteed the type 
-inline bool alreadyChecked(UseKind kind, SpeculatedType type)
-{
-    // If the check involves the structure then we need to know more than just the type to be sure
-    // that the check is done.
-    if (usesStructure(kind))
-        return false;
-    
-    return !(type & ~typeFilterFor(kind));
-}
-
-inline UseKind useKindForResult(NodeFlags result)
-{
-    ASSERT(!(result & ~NodeResultMask));
-    switch (result) {
-    case NodeResultInt52:
-        return Int52RepUse;
-    case NodeResultDouble:
-        return DoubleRepUse;
-    default:
-        return UntypedUse;
-    }
-}
-
 } } // namespace JSC::DFG
 
 namespace WTF {