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
39namespace 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 ASSERT(!(m_size > m_capacity - 4));
99 *reinterpret_cast<int*>(&m_buffer[m_size]) = value;
100 m_size += 4;
101 }
102
103 void putInt64Unchecked(int64_t value)
104 {
105 ASSERT(!(m_size > m_capacity - 8));
106 *reinterpret_cast<int64_t*>(&m_buffer[m_size]) = value;
107 m_size += 8;
108 }
109
110 void putInt(int value)
111 {
112 if (m_size > m_capacity - 4)
113 grow();
114 putIntUnchecked(value);
115 }
116
117 void* data() const
118 {
119 return m_buffer;
120 }
121
122 int size() const
123 {
124 return m_size;
125 }
126
127 void* executableCopy(ExecutablePool* allocator)
128 {
129 if (!m_size)
130 return 0;
131
132 void* result = allocator->alloc(n: m_size);
133
134 if (!result)
135 return 0;
136
137 ExecutableAllocator::makeWritable(result, m_size);
138
139 return memcpy(dest: result, src: m_buffer, n: m_size);
140 }
141
142 protected:
143 void append(const char* data, int size)
144 {
145 if (m_size > m_capacity - size)
146 grow(extraCapacity: size);
147
148 memcpy(dest: m_buffer + m_size, src: data, n: size);
149 m_size += size;
150 }
151
152 void grow(int extraCapacity = 0)
153 {
154 m_capacity += m_capacity / 2 + extraCapacity;
155
156 if (m_buffer == m_inlineBuffer) {
157 char* newBuffer = static_cast<char*>(fastMalloc(m_capacity));
158 m_buffer = static_cast<char*>(memcpy(dest: newBuffer, src: m_buffer, n: m_size));
159 } else
160 m_buffer = static_cast<char*>(fastRealloc(m_buffer, m_capacity));
161 }
162
163 char m_inlineBuffer[inlineCapacity];
164 char* m_buffer;
165 int m_capacity;
166 int m_size;
167 };
168
169} // namespace JSC
170
171#endif // ENABLE(ASSEMBLER)
172
173#endif // AssemblerBuffer_h
174

source code of qtscript/src/3rdparty/javascriptcore/JavaScriptCore/assembler/AssemblerBuffer.h