runtime/JSArrayBufferView.h

   1 /*
   2  * Copyright (C) 2013 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef JSArrayBufferView_h
  27 #define JSArrayBufferView_h
  28
  29 #include "JSObject.h"
  30
  31 namespace JSC {
  32
  33 // This class serves two purposes:
  34 //
  35 // 1) It provides those parts of JSGenericTypedArrayView that don't depend
  36 //    on template parameters.
  37 //
  38 // 2) It represents the DOM/WebCore-visible "JSArrayBufferView" type, which
  39 //    C++ code uses when it wants to pass around a view of an array buffer
  40 //    without concern for the actual type of the view.
  41 //
  42 // These two roles are quite different. (1) is just a matter of optimizing
  43 // compile and link times by having as much code and data as possible not
  44 // be subject to template specialization. (2) is *almost* a matter of
  45 // semantics; indeed at the very least it is a matter of obeying a contract
  46 // that we have with WebCore right now.
  47 //
  48 // One convenient thing that saves us from too much crazy is that
  49 // ArrayBufferView is not instantiable.
  50
  51 // Typed array views have different modes depending on how big they are and
  52 // whether the user has done anything that requires a separate backing
  53 // buffer or the DOM-specified neutering capabilities.
  54 enum TypedArrayMode {
  55     // Small and fast typed array. B is unused, V points to a vector
  56     // allocated in copied space, and M = FastTypedArray. V's liveness is
  57     // determined entirely by the view's liveness.
  58     FastTypedArray,
  59
  60     // A large typed array that still attempts not to waste too much
  61     // memory. B is initialized to point to a slot that could hold a
  62     // buffer pointer, V points to a vector allocated using fastCalloc(),
  63     // and M = OversizeTypedArray. V's liveness is determined entirely by
  64     // the view's liveness, and the view will add a finalizer to delete V.
  65     OversizeTypedArray,
  66
  67     // A typed array that was used in some crazy way. B's IndexingHeader
  68     // is hijacked to contain a reference to the native array buffer. The
  69     // native typed array view points back to the JS view. V points to a
  70     // vector allocated using who-knows-what, and M = WastefulTypedArray.
  71     // The view does not own the vector.
  72     WastefulTypedArray,
  73
  74     // A data view. B is unused, V points to a vector allocated using who-
  75     // knows-what, and M = DataViewMode. The view does not own the vector.
  76     // There is an extra field (in JSDataView) that points to the
  77     // ArrayBuffer.
  78     DataViewMode
  79 };
  80
  81 inline bool hasArrayBuffer(TypedArrayMode mode)
  82 {
  83     return mode >= WastefulTypedArray;
  84 }
  85
  86 // When WebCore uses a JSArrayBufferView, it expects to be able to get the native
  87 // ArrayBuffer and little else. This requires slowing down and wasting memory,
  88 // and then accessing things via the Butterfly. When JS uses a JSArrayBufferView
  89 // it is always via the usual methods in the MethodTable, so this class's
  90 // implementation of those has no need to even exist - we could at any time sink
  91 // code into JSGenericTypedArrayView if it was convenient.
  92
  93 class JSArrayBufferView : public JSNonFinalObject {
  94 public:
  95     typedef JSNonFinalObject Base;
  96
  97     static const unsigned fastSizeLimit = 1000;
  98
  99     static size_t sizeOf(uint32_t length, uint32_t elementSize)
 100     {
 101         return (length * elementSize + sizeof(EncodedJSValue) - 1)
 102             & ~(sizeof(EncodedJSValue) - 1);
 103     }
 104
 105     static size_t allocationSize(size_t inlineCapacity)
 106     {
 107         ASSERT_UNUSED(inlineCapacity, !inlineCapacity);
 108         return sizeof(JSArrayBufferView);
 109     }
 110
 111 protected:
 112     class ConstructionContext {
 113         WTF_MAKE_NONCOPYABLE(ConstructionContext);
 114
 115     public:
 116         enum InitializationMode { ZeroFill, DontInitialize };
 117
 118         JS_EXPORT_PRIVATE ConstructionContext(VM&, Structure*, uint32_t length, uint32_t elementSize, InitializationMode = ZeroFill);
 119
 120         JS_EXPORT_PRIVATE ConstructionContext(
 121             VM&, Structure*, PassRefPtr<ArrayBuffer>,
 122             unsigned byteOffset, unsigned length);
 123
 124         enum DataViewTag { DataView };
 125         ConstructionContext(
 126             Structure*, PassRefPtr<ArrayBuffer>,
 127             unsigned byteOffset, unsigned length, DataViewTag);
 128
 129         bool operator!() const { return !m_structure; }
 130
 131         Structure* structure() const { return m_structure; }
 132         void* vector() const { return m_vector; }
 133         uint32_t length() const { return m_length; }
 134         TypedArrayMode mode() const { return m_mode; }
 135         Butterfly* butterfly() const { return m_butterfly; }
 136
 137     private:
 138         Structure* m_structure;
 139         void* m_vector;
 140         uint32_t m_length;
 141         TypedArrayMode m_mode;
 142         Butterfly* m_butterfly;
 143     };
 144
 145     JS_EXPORT_PRIVATE JSArrayBufferView(VM&, ConstructionContext&);
 146     JS_EXPORT_PRIVATE void finishCreation(VM&);
 147
 148     static bool getOwnPropertySlot(JSObject*, ExecState*, PropertyName, PropertySlot&);
 149     static void put(JSCell*, ExecState*, PropertyName, JSValue, PutPropertySlot&);
 150     static bool defineOwnProperty(JSObject*, ExecState*, PropertyName, const PropertyDescriptor&, bool shouldThrow);
 151     static bool deleteProperty(JSCell*, ExecState*, PropertyName);
 152
 153     static void getOwnNonIndexPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
 154
 155 public:
 156     TypedArrayMode mode() const { return m_mode; }
 157     bool hasArrayBuffer() const { return JSC::hasArrayBuffer(mode()); }
 158
 159     ArrayBuffer* buffer();
 160     PassRefPtr<ArrayBufferView> impl();
 161     void neuter();
 162
 163     void* vector() { return m_vector; }
 164     unsigned byteOffset();
 165     unsigned length() const { return m_length; }
 166
 167     DECLARE_EXPORT_INFO;
 168
 169     static ptrdiff_t offsetOfVector() { return OBJECT_OFFSETOF(JSArrayBufferView, m_vector); }
 170     static ptrdiff_t offsetOfLength() { return OBJECT_OFFSETOF(JSArrayBufferView, m_length); }
 171     static ptrdiff_t offsetOfMode() { return OBJECT_OFFSETOF(JSArrayBufferView, m_mode); }
 172
 173 private:
 174     static void finalize(JSCell*);
 175
 176 protected:
 177     static const unsigned StructureFlags = OverridesGetPropertyNames | OverridesGetOwnPropertySlot | Base::StructureFlags;
 178
 179     ArrayBuffer* existingBufferInButterfly();
 180
 181     void* m_vector;
 182     uint32_t m_length;
 183     TypedArrayMode m_mode;
 184 };
 185
 186 } // namespace JSC
 187
 188 #endif // JSArrayBufferView_h
 189