assembler/AssemblerBuffer.h

   1 /*
   2  * Copyright (C) 2008 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 #include <wtf/Platform.h>
  30
  31 #if ENABLE(ASSEMBLER)
  32
  33 #include "stdint.h"
  34 #include <string.h>
  35 #include <jit/ExecutableAllocator.h>
  36 #include <wtf/Assertions.h>
  37 #include <wtf/FastMalloc.h>
  38
  39 namespace JSC {
  40
  41     class AssemblerBuffer {
  42         static const int inlineCapacity = 256;
  43     public:
  44         AssemblerBuffer()
  45             : m_buffer(m_inlineBuffer)
  46             , m_capacity(inlineCapacity)
  47             , m_size(0)
  48         {
  49         }
  50
  51         ~AssemblerBuffer()
  52         {
  53             if (m_buffer != m_inlineBuffer)
  54                 fastFree(m_buffer);
  55         }
  56
  57         void ensureSpace(int space)
  58         {
  59             if (m_size > m_capacity - space)
  60                 grow();
  61         }
  62
  63         bool isAligned(int alignment) const
  64         {
  65             return !(m_size & (alignment - 1));
  66         }
  67
  68         void putByteUnchecked(int value)
  69         {
  70             ASSERT(!(m_size > m_capacity - 4));
  71             m_buffer[m_size] = value;
  72             m_size++;
  73         }
  74
  75         void putByte(int value)
  76         {
  77             if (m_size > m_capacity - 4)
  78                 grow();
  79             putByteUnchecked(value);
  80         }
  81
  82         void putShortUnchecked(int value)
  83         {
  84             ASSERT(!(m_size > m_capacity - 4));
  85             *reinterpret_cast<short*>(&m_buffer[m_size]) = value;
  86             m_size += 2;
  87         }
  88
  89         void putShort(int value)
  90         {
  91             if (m_size > m_capacity - 4)
  92                 grow();
  93             putShortUnchecked(value);
  94         }
  95
  96         void putIntUnchecked(int value)
  97         {
  98             *reinterpret_cast<int*>(&m_buffer[m_size]) = value;
  99             m_size += 4;
 100         }
 101
 102         void putInt64Unchecked(int64_t value)
 103         {
 104             *reinterpret_cast<int64_t*>(&m_buffer[m_size]) = value;
 105             m_size += 8;
 106         }
 107
 108         void putInt(int value)
 109         {
 110             if (m_size > m_capacity - 4)
 111                 grow();
 112             putIntUnchecked(value);
 113         }
 114
 115         void* data() const
 116         {
 117             return m_buffer;
 118         }
 119
 120         int size() const
 121         {
 122             return m_size;
 123         }
 124
 125         void* executableCopy(ExecutablePool* allocator)
 126         {
 127             if (!m_size)
 128                 return 0;
 129
 130             void* result = allocator->alloc(m_size);
 131
 132             if (!result)
 133                 return 0;
 134
 135             return memcpy(result, m_buffer, m_size);
 136         }
 137
 138     private:
 139         void grow()
 140         {
 141             m_capacity += m_capacity / 2;
 142
 143             if (m_buffer == m_inlineBuffer) {
 144                 char* newBuffer = static_cast<char*>(fastMalloc(m_capacity));
 145                 m_buffer = static_cast<char*>(memcpy(newBuffer, m_buffer, m_size));
 146             } else
 147                 m_buffer = static_cast<char*>(fastRealloc(m_buffer, m_capacity));
 148         }
 149
 150         char m_inlineBuffer[inlineCapacity];
 151         char* m_buffer;
 152         int m_capacity;
 153         int m_size;
 154     };
 155
 156 } // namespace JSC
 157
 158 #endif // ENABLE(ASSEMBLER)
 159
 160 #endif // AssemblerBuffer_h