assembler/AssemblerBuffer.h

   1 /*
   2  * Copyright (C) 2008, 2012, 2014 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 AssemblerBuffer_h
  27 #define AssemblerBuffer_h
  28
  29 #if ENABLE(ASSEMBLER)
  30
  31 #include "ExecutableAllocator.h"
  32 #include "JITCompilationEffort.h"
  33 #include "stdint.h"
  34 #include <string.h>
  35 #include <wtf/Assertions.h>
  36 #include <wtf/FastMalloc.h>
  37 #include <wtf/StdLibExtras.h>
  38
  39 namespace JSC {
  40
  41     struct AssemblerLabel {
  42         AssemblerLabel()
  43             : m_offset(std::numeric_limits<uint32_t>::max())
  44         {
  45         }
  46
  47         explicit AssemblerLabel(uint32_t offset)
  48             : m_offset(offset)
  49         {
  50         }
  51
  52         bool isSet() const { return (m_offset != std::numeric_limits<uint32_t>::max()); }
  53
  54         AssemblerLabel labelAtOffset(int offset) const
  55         {
  56             return AssemblerLabel(m_offset + offset);
  57         }
  58
  59         uint32_t m_offset;
  60     };
  61
  62     class AssemblerData {
  63     public:
  64         AssemblerData()
  65             : m_buffer(nullptr)
  66             , m_capacity(0)
  67         {
  68         }
  69
  70         AssemblerData(unsigned initialCapacity)
  71         {
  72             m_capacity = fastMallocGoodSize(initialCapacity);
  73             m_buffer = static_cast<char*>(fastMalloc(m_capacity));
  74         }
  75
  76         AssemblerData(AssemblerData&& other)
  77         {
  78             m_buffer = other.m_buffer;
  79             other.m_buffer = nullptr;
  80             m_capacity = other.m_capacity;
  81             other.m_capacity = 0;
  82         }
  83
  84         AssemblerData& operator=(AssemblerData&& other)
  85         {
  86             m_buffer = other.m_buffer;
  87             other.m_buffer = nullptr;
  88             m_capacity = other.m_capacity;
  89             other.m_capacity = 0;
  90             return *this;
  91         }
  92
  93         ~AssemblerData()
  94         {
  95             fastFree(m_buffer);
  96         }
  97
  98         char* buffer() const { return m_buffer; }
  99
 100         unsigned capacity() const { return m_capacity; }
 101
 102         void grow(unsigned extraCapacity = 0)
 103         {
 104             m_capacity = fastMallocGoodSize(m_capacity + m_capacity / 2 + extraCapacity);
 105             m_buffer = static_cast<char*>(fastRealloc(m_buffer, m_capacity));
 106         }
 107
 108     private:
 109         char* m_buffer;
 110         unsigned m_capacity;
 111     };
 112
 113     class AssemblerBuffer {
 114         static const int initialCapacity = 128;
 115     public:
 116         AssemblerBuffer()
 117             : m_storage(initialCapacity)
 118             , m_index(0)
 119         {
 120         }
 121
 122         bool isAvailable(int space)
 123         {
 124             return m_index + space <= m_storage.capacity();
 125         }
 126
 127         void ensureSpace(int space)
 128         {
 129             if (!isAvailable(space))
 130                 grow();
 131         }
 132
 133         bool isAligned(int alignment) const
 134         {
 135             return !(m_index & (alignment - 1));
 136         }
 137
 138         void putByteUnchecked(int8_t value) { putIntegralUnchecked(value); }
 139         void putByte(int8_t value) { putIntegral(value); }
 140         void putShortUnchecked(int16_t value) { putIntegralUnchecked(value); }
 141         void putShort(int16_t value) { putIntegral(value); }
 142         void putIntUnchecked(int32_t value) { putIntegralUnchecked(value); }
 143         void putInt(int32_t value) { putIntegral(value); }
 144         void putInt64Unchecked(int64_t value) { putIntegralUnchecked(value); }
 145         void putInt64(int64_t value) { putIntegral(value); }
 146
 147         void* data() const
 148         {
 149             return m_storage.buffer();
 150         }
 151
 152         size_t codeSize() const
 153         {
 154             return m_index;
 155         }
 156
 157         AssemblerLabel label() const
 158         {
 159             return AssemblerLabel(m_index);
 160         }
 161
 162         unsigned debugOffset() { return m_index; }
 163
 164         AssemblerData releaseAssemblerData() { return WTF::move(m_storage); }
 165
 166     protected:
 167         template<typename IntegralType>
 168         void putIntegral(IntegralType value)
 169         {
 170             unsigned nextIndex = m_index + sizeof(IntegralType);
 171             if (UNLIKELY(nextIndex > m_storage.capacity()))
 172                 grow();
 173             ASSERT(isAvailable(sizeof(IntegralType)));
 174             *reinterpret_cast_ptr<IntegralType*>(m_storage.buffer() + m_index) = value;
 175             m_index = nextIndex;
 176         }
 177
 178         template<typename IntegralType>
 179         void putIntegralUnchecked(IntegralType value)
 180         {
 181             ASSERT(isAvailable(sizeof(IntegralType)));
 182             *reinterpret_cast_ptr<IntegralType*>(m_storage.buffer() + m_index) = value;
 183             m_index += sizeof(IntegralType);
 184         }
 185
 186         void append(const char* data, int size)
 187         {
 188             if (!isAvailable(size))
 189                 grow(size);
 190
 191             memcpy(m_storage.buffer() + m_index, data, size);
 192             m_index += size;
 193         }
 194
 195         void grow(int extraCapacity = 0)
 196         {
 197             m_storage.grow(extraCapacity);
 198         }
 199
 200     private:
 201         AssemblerData m_storage;
 202         unsigned m_index;
 203     };
 204
 205 } // namespace JSC
 206
 207 #endif // ENABLE(ASSEMBLER)
 208
 209 #endif // AssemblerBuffer_h