Rename AtomicString to AtomString
[WebKit-https.git] / Source / JavaScriptCore / b3 / B3MemoryValue.h
index 5c813e8..b998aed 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2015-2016 Apple Inc. All rights reserved.
+ * Copyright (C) 2015-2017 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef B3MemoryValue_h
-#define B3MemoryValue_h
+#pragma once
 
 #if ENABLE(B3_JIT)
 
+#include "AirArg.h"
+#include "B3Bank.h"
 #include "B3HeapRange.h"
 #include "B3Value.h"
+#include <type_traits>
 
 namespace JSC { namespace B3 {
 
 class JS_EXPORT_PRIVATE MemoryValue : public Value {
 public:
-    static bool accepts(Opcode opcode)
+    static bool accepts(Kind kind)
     {
-        switch (opcode) {
-        case Load8Z:
-        case Load8S:
-        case Load16Z:
-        case Load16S:
-        case Load:
-        case Store8:
-        case Store16:
-        case Store:
-            return true;
-        default:
-            return false;
-        }
+        return isMemoryAccess(kind.opcode());
     }
 
     ~MemoryValue();
 
-    int32_t offset() const { return m_offset; }
-    void setOffset(int32_t offset) { m_offset = offset; }
+    OffsetType offset() const { return m_offset; }
+    template<typename Int, typename = IsLegalOffset<Int>>
+    void setOffset(Int offset) { m_offset = offset; }
 
-    const HeapRange& range() const { return m_range; }
-    void setRange(const HeapRange& range) { m_range = range; }
+    // You don't have to worry about using legal offsets unless you've entered quirks mode.
+    template<typename Int,
+        typename = typename std::enable_if<std::is_integral<Int>::value>::type,
+        typename = typename std::enable_if<std::is_signed<Int>::value>::type
+    >
+    bool isLegalOffset(Int offset) const { return isLegalOffsetImpl(offset); }
 
-    bool isStore() const { return type() == Void; }
-    bool isLoad() const { return type() != Void; }
+    // A necessary consequence of MemoryValue having an offset is that it participates in instruction
+    // selection. This tells you if this will get lowered to something that requires an offsetless
+    // address.
+    bool requiresSimpleAddr() const;
 
+    const HeapRange& range() const { return m_range; }
+    void setRange(const HeapRange& range) { m_range = range; }
+    
+    // This is an alias for range.
+    const HeapRange& accessRange() const { return range(); }
+    void setAccessRange(const HeapRange& range) { setRange(range); }
+    
+    const HeapRange& fenceRange() const { return m_fenceRange; }
+    void setFenceRange(const HeapRange& range) { m_fenceRange = range; }
+
+    bool isStore() const { return B3::isStore(opcode()); }
+    bool isLoad() const { return B3::isLoad(opcode()); }
+
+    bool hasFence() const { return !!fenceRange(); }
+    bool isExotic() const { return hasFence() || isAtom(opcode()); }
+
+    Type accessType() const;
+    Bank accessBank() const;
     size_t accessByteSize() const;
+    
+    Width accessWidth() const;
 
-protected:
-    void dumpMeta(CommaPrinter& comma, PrintStream&) const override;
+    bool isCanonicalWidth() const { return B3::isCanonicalWidth(accessWidth()); }
 
-    Value* cloneImpl() const override;
+    B3_SPECIALIZE_VALUE_FOR_NON_VARARGS_CHILDREN
 
+protected:
+    void dumpMeta(CommaPrinter&, PrintStream&) const override;
+    
+    template<typename Int, typename = IsLegalOffset<Int>, typename... Arguments>
+    MemoryValue(CheckedOpcodeTag, Kind kind, Type type, NumChildren numChildren, Origin origin, Int offset, HeapRange range, HeapRange fenceRange, Arguments... arguments)
+        : Value(CheckedOpcode, kind, type, numChildren, origin, static_cast<Value*>(arguments)...)
+        , m_offset(offset)
+        , m_range(range)
+        , m_fenceRange(fenceRange)
+    {
+    }
+    
 private:
     friend class Procedure;
+    friend class Value;
+
+    bool isLegalOffsetImpl(int32_t offset) const;
+    bool isLegalOffsetImpl(int64_t offset) const;
+
+    enum MemoryValueLoad { MemoryValueLoadTag };
+    enum MemoryValueLoadImplied { MemoryValueLoadImpliedTag };
+    enum MemoryValueStore { MemoryValueStoreTag };
 
     // Use this form for Load (but not Load8Z, Load8S, or any of the Loads that have a suffix that
     // describes the returned type).
-    MemoryValue(Opcode opcode, Type type, Origin origin, Value* pointer, int32_t offset = 0)
-        : Value(CheckedOpcode, opcode, type, origin, pointer)
-        , m_offset(offset)
-        , m_range(HeapRange::top())
+    MemoryValue(Kind kind, Type type, Origin origin, Value* pointer)
+        : MemoryValue(MemoryValueLoadTag, kind, type, origin, pointer)
+    {
+    }
+    template<typename Int, typename = IsLegalOffset<Int>>
+    MemoryValue(Kind kind, Type type, Origin origin, Value* pointer, Int offset, HeapRange range = HeapRange::top(), HeapRange fenceRange = HeapRange())
+        : MemoryValue(MemoryValueLoadTag, kind, type, origin, pointer, offset, range, fenceRange)
     {
-        if (!ASSERT_DISABLED) {
-            switch (opcode) {
-            case Load:
-                break;
-            case Load8Z:
-            case Load8S:
-            case Load16Z:
-            case Load16S:
-                ASSERT(type == Int32);
-                break;
-            case Store8:
-            case Store16:
-            case Store:
-                ASSERT(type == Void);
-                break;
-            default:
-                ASSERT_NOT_REACHED();
-            }
-        }
     }
 
     // Use this form for loads where the return type is implied.
-    MemoryValue(Opcode opcode, Origin origin, Value* pointer, int32_t offset = 0)
-        : MemoryValue(opcode, Int32, origin, pointer, offset)
+    MemoryValue(Kind kind, Origin origin, Value* pointer)
+        : MemoryValue(MemoryValueLoadImpliedTag, kind, origin, pointer)
+    {
+    }
+    template<typename Int, typename = IsLegalOffset<Int>>
+    MemoryValue(Kind kind, Origin origin, Value* pointer, Int offset, HeapRange range = HeapRange::top(), HeapRange fenceRange = HeapRange())
+        : MemoryValue(MemoryValueLoadImpliedTag, kind, origin, pointer, offset, range, fenceRange)
     {
     }
 
     // Use this form for stores.
-    MemoryValue(Opcode opcode, Origin origin, Value* value, Value* pointer, int32_t offset = 0)
-        : Value(CheckedOpcode, opcode, Void, origin, value, pointer)
-        , m_offset(offset)
-        , m_range(HeapRange::top())
+    MemoryValue(Kind kind, Origin origin, Value* value, Value* pointer)
+        : MemoryValue(MemoryValueStoreTag, kind, origin, value, pointer)
     {
-        if (!ASSERT_DISABLED) {
-            switch (opcode) {
-            case Store8:
-            case Store16:
-            case Store:
-                break;
-            default:
-                ASSERT_NOT_REACHED();
-                break;
-            }
-        }
     }
+    template<typename Int, typename = IsLegalOffset<Int>>
+    MemoryValue(Kind kind, Origin origin, Value* value, Value* pointer, Int offset, HeapRange range = HeapRange::top(), HeapRange fenceRange = HeapRange())
+        : MemoryValue(MemoryValueStoreTag, kind, origin, value, pointer, offset, range, fenceRange)
+    {
+    }
+
+    // The above templates forward to these implementations.
+    MemoryValue(MemoryValueLoad, Kind, Type, Origin, Value* pointer, OffsetType = 0, HeapRange = HeapRange::top(), HeapRange fenceRange = HeapRange());
+    MemoryValue(MemoryValueLoadImplied, Kind, Origin, Value* pointer, OffsetType = 0, HeapRange = HeapRange::top(), HeapRange fenceRange = HeapRange());
+    MemoryValue(MemoryValueStore, Kind, Origin, Value*, Value* pointer, OffsetType = 0, HeapRange = HeapRange::top(), HeapRange fenceRange = HeapRange());
 
-    int32_t m_offset { 0 };
-    HeapRange m_range;
+    OffsetType m_offset { 0 };
+    HeapRange m_range { HeapRange::top() };
+    HeapRange m_fenceRange { HeapRange() };
 };
 
 } } // namespace JSC::B3
 
 #endif // ENABLE(B3_JIT)
-
-#endif // B3MemoryValue_h
-