Towards 8 Bit Strings: Templatize JSC::Parser class by Lexer type
[WebKit-https.git] / Source / JavaScriptCore / assembler / LinkBuffer.h
1 /*
2  * Copyright (C) 2009, 2010 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 LinkBuffer_h
27 #define LinkBuffer_h
28
29 #if ENABLE(ASSEMBLER)
30
31 #define DUMP_LINK_STATISTICS 0
32 #define DUMP_CODE 0
33
34 #include <MacroAssembler.h>
35 #include <wtf/Noncopyable.h>
36
37 namespace JSC {
38
39 class JSGlobalData;
40
41 // LinkBuffer:
42 //
43 // This class assists in linking code generated by the macro assembler, once code generation
44 // has been completed, and the code has been copied to is final location in memory.  At this
45 // time pointers to labels within the code may be resolved, and relative offsets to external
46 // addresses may be fixed.
47 //
48 // Specifically:
49 //   * Jump objects may be linked to external targets,
50 //   * The address of Jump objects may taken, such that it can later be relinked.
51 //   * The return address of a Call may be acquired.
52 //   * The address of a Label pointing into the code may be resolved.
53 //   * The value referenced by a DataLabel may be set.
54 //
55 class LinkBuffer {
56     WTF_MAKE_NONCOPYABLE(LinkBuffer);
57     typedef MacroAssemblerCodeRef CodeRef;
58     typedef MacroAssemblerCodePtr CodePtr;
59     typedef MacroAssembler::Label Label;
60     typedef MacroAssembler::Jump Jump;
61     typedef MacroAssembler::JumpList JumpList;
62     typedef MacroAssembler::Call Call;
63     typedef MacroAssembler::DataLabelCompact DataLabelCompact;
64     typedef MacroAssembler::DataLabel32 DataLabel32;
65     typedef MacroAssembler::DataLabelPtr DataLabelPtr;
66 #if ENABLE(BRANCH_COMPACTION)
67     typedef MacroAssembler::LinkRecord LinkRecord;
68     typedef MacroAssembler::JumpLinkType JumpLinkType;
69 #endif
70
71 public:
72     LinkBuffer(JSGlobalData& globalData, MacroAssembler* masm)
73         : m_size(0)
74         , m_code(0)
75         , m_assembler(masm)
76         , m_globalData(&globalData)
77 #ifndef NDEBUG
78         , m_completed(false)
79 #endif
80     {
81         linkCode();
82     }
83
84     ~LinkBuffer()
85     {
86         ASSERT(m_completed);
87     }
88
89     // These methods are used to link or set values at code generation time.
90
91     void link(Call call, FunctionPtr function)
92     {
93         ASSERT(call.isFlagSet(Call::Linkable));
94         call.m_label = applyOffset(call.m_label);
95         MacroAssembler::linkCall(code(), call, function);
96     }
97     
98     void link(Jump jump, CodeLocationLabel label)
99     {
100         jump.m_label = applyOffset(jump.m_label);
101         MacroAssembler::linkJump(code(), jump, label);
102     }
103
104     void link(JumpList list, CodeLocationLabel label)
105     {
106         for (unsigned i = 0; i < list.m_jumps.size(); ++i)
107             link(list.m_jumps[i], label);
108     }
109
110     void patch(DataLabelPtr label, void* value)
111     {
112         AssemblerLabel target = applyOffset(label.m_label);
113         MacroAssembler::linkPointer(code(), target, value);
114     }
115
116     void patch(DataLabelPtr label, CodeLocationLabel value)
117     {
118         AssemblerLabel target = applyOffset(label.m_label);
119         MacroAssembler::linkPointer(code(), target, value.executableAddress());
120     }
121
122     // These methods are used to obtain handles to allow the code to be relinked / repatched later.
123
124     CodeLocationCall locationOf(Call call)
125     {
126         ASSERT(call.isFlagSet(Call::Linkable));
127         ASSERT(!call.isFlagSet(Call::Near));
128         return CodeLocationCall(MacroAssembler::getLinkerAddress(code(), applyOffset(call.m_label)));
129     }
130
131     CodeLocationNearCall locationOfNearCall(Call call)
132     {
133         ASSERT(call.isFlagSet(Call::Linkable));
134         ASSERT(call.isFlagSet(Call::Near));
135         return CodeLocationNearCall(MacroAssembler::getLinkerAddress(code(), applyOffset(call.m_label)));
136     }
137
138     CodeLocationLabel locationOf(Jump jump)
139     {
140         return CodeLocationLabel(MacroAssembler::getLinkerAddress(code(), applyOffset(jump.m_label)));
141     }
142
143     CodeLocationLabel locationOf(Label label)
144     {
145         return CodeLocationLabel(MacroAssembler::getLinkerAddress(code(), applyOffset(label.m_label)));
146     }
147
148     CodeLocationDataLabelPtr locationOf(DataLabelPtr label)
149     {
150         return CodeLocationDataLabelPtr(MacroAssembler::getLinkerAddress(code(), applyOffset(label.m_label)));
151     }
152
153     CodeLocationDataLabel32 locationOf(DataLabel32 label)
154     {
155         return CodeLocationDataLabel32(MacroAssembler::getLinkerAddress(code(), applyOffset(label.m_label)));
156     }
157     
158     CodeLocationDataLabelCompact locationOf(DataLabelCompact label)
159     {
160         return CodeLocationDataLabelCompact(MacroAssembler::getLinkerAddress(code(), applyOffset(label.m_label)));
161     }
162
163     // This method obtains the return address of the call, given as an offset from
164     // the start of the code.
165     unsigned returnAddressOffset(Call call)
166     {
167         call.m_label = applyOffset(call.m_label);
168         return MacroAssembler::getLinkerCallReturnOffset(call);
169     }
170
171     // Upon completion of all patching either 'finalizeCode()' or 'finalizeCodeAddendum()' should be called
172     // once to complete generation of the code.  'finalizeCode()' is suited to situations
173     // where the executable pool must also be retained, the lighter-weight 'finalizeCodeAddendum()' is
174     // suited to adding to an existing allocation.
175     CodeRef finalizeCode()
176     {
177         performFinalization();
178
179         return CodeRef(m_executableMemory);
180     }
181
182     CodePtr trampolineAt(Label label)
183     {
184         return CodePtr(MacroAssembler::AssemblerType_T::getRelocatedAddress(code(), applyOffset(label.m_label)));
185     }
186
187 #ifndef NDEBUG
188     void* debugAddress()
189     {
190         return m_code;
191     }
192     
193     size_t debugSize()
194     {
195         return m_size;
196     }
197 #endif
198
199 private:
200     template <typename T> T applyOffset(T src)
201     {
202 #if ENABLE(BRANCH_COMPACTION)
203         src.m_offset -= m_assembler->executableOffsetFor(src.m_offset);
204 #endif
205         return src;
206     }
207     
208     // Keep this private! - the underlying code should only be obtained externally via 
209     // finalizeCode() or finalizeCodeAddendum().
210     void* code()
211     {
212         return m_code;
213     }
214
215     void linkCode()
216     {
217         ASSERT(!m_code);
218 #if !ENABLE(BRANCH_COMPACTION)
219         m_executableMemory = m_assembler->m_assembler.executableCopy(*m_globalData);
220         if (!m_executableMemory)
221             return;
222         m_code = m_executableMemory->start();
223         m_size = m_assembler->m_assembler.codeSize();
224         ASSERT(m_code);
225 #else
226         size_t initialSize = m_assembler->m_assembler.codeSize();
227         m_executableMemory = m_globalData->executableAllocator.allocate(*m_globalData, initialSize);
228         if (!m_executableMemory)
229             return;
230         m_code = (uint8_t*)m_executableMemory->start();
231         ASSERT(m_code);
232         ExecutableAllocator::makeWritable(m_code, initialSize);
233         uint8_t* inData = (uint8_t*)m_assembler->unlinkedCode();
234         uint8_t* outData = reinterpret_cast<uint8_t*>(m_code);
235         int readPtr = 0;
236         int writePtr = 0;
237         Vector<LinkRecord>& jumpsToLink = m_assembler->jumpsToLink();
238         unsigned jumpCount = jumpsToLink.size();
239         for (unsigned i = 0; i < jumpCount; ++i) {
240             int offset = readPtr - writePtr;
241             ASSERT(!(offset & 1));
242             
243             // Copy the instructions from the last jump to the current one.
244             size_t regionSize = jumpsToLink[i].from() - readPtr;
245             uint16_t* copySource = reinterpret_cast<uint16_t*>(inData + readPtr);
246             uint16_t* copyEnd = reinterpret_cast<uint16_t*>(inData + readPtr + regionSize);
247             uint16_t* copyDst = reinterpret_cast<uint16_t*>(outData + writePtr);
248             ASSERT(!(regionSize % 2));
249             ASSERT(!(readPtr % 2));
250             ASSERT(!(writePtr % 2));
251             while (copySource != copyEnd)
252                 *copyDst++ = *copySource++;
253             m_assembler->recordLinkOffsets(readPtr, jumpsToLink[i].from(), offset);
254             readPtr += regionSize;
255             writePtr += regionSize;
256             
257             // Calculate absolute address of the jump target, in the case of backwards
258             // branches we need to be precise, forward branches we are pessimistic
259             const uint8_t* target;
260             if (jumpsToLink[i].to() >= jumpsToLink[i].from())
261                 target = outData + jumpsToLink[i].to() - offset; // Compensate for what we have collapsed so far
262             else
263                 target = outData + jumpsToLink[i].to() - m_assembler->executableOffsetFor(jumpsToLink[i].to());
264             
265             JumpLinkType jumpLinkType = m_assembler->computeJumpType(jumpsToLink[i], outData + writePtr, target);
266             // Compact branch if we can...
267             if (m_assembler->canCompact(jumpsToLink[i].type())) {
268                 // Step back in the write stream
269                 int32_t delta = m_assembler->jumpSizeDelta(jumpsToLink[i].type(), jumpLinkType);
270                 if (delta) {
271                     writePtr -= delta;
272                     m_assembler->recordLinkOffsets(jumpsToLink[i].from() - delta, readPtr, readPtr - writePtr);
273                 }
274             }
275             jumpsToLink[i].setFrom(writePtr);
276         }
277         // Copy everything after the last jump
278         memcpy(outData + writePtr, inData + readPtr, initialSize - readPtr);
279         m_assembler->recordLinkOffsets(readPtr, initialSize, readPtr - writePtr);
280         
281         for (unsigned i = 0; i < jumpCount; ++i) {
282             uint8_t* location = outData + jumpsToLink[i].from();
283             uint8_t* target = outData + jumpsToLink[i].to() - m_assembler->executableOffsetFor(jumpsToLink[i].to());
284             m_assembler->link(jumpsToLink[i], location, target);
285         }
286
287         jumpsToLink.clear();
288         m_size = writePtr + initialSize - readPtr;
289         m_executableMemory->shrink(m_size);
290
291 #if DUMP_LINK_STATISTICS
292         dumpLinkStatistics(m_code, initialSize, m_size);
293 #endif
294 #if DUMP_CODE
295         dumpCode(m_code, m_size);
296 #endif
297 #endif
298     }
299
300     void performFinalization()
301     {
302 #ifndef NDEBUG
303         ASSERT(!m_completed);
304         m_completed = true;
305 #endif
306
307         ExecutableAllocator::makeExecutable(code(), m_size);
308         ExecutableAllocator::cacheFlush(code(), m_size);
309     }
310
311 #if DUMP_LINK_STATISTICS
312     static void dumpLinkStatistics(void* code, size_t initialSize, size_t finalSize)
313     {
314         static unsigned linkCount = 0;
315         static unsigned totalInitialSize = 0;
316         static unsigned totalFinalSize = 0;
317         linkCount++;
318         totalInitialSize += initialSize;
319         totalFinalSize += finalSize;
320         printf("link %p: orig %u, compact %u (delta %u, %.2f%%)\n", 
321                code, static_cast<unsigned>(initialSize), static_cast<unsigned>(finalSize),
322                static_cast<unsigned>(initialSize - finalSize),
323                100.0 * (initialSize - finalSize) / initialSize);
324         printf("\ttotal %u: orig %u, compact %u (delta %u, %.2f%%)\n", 
325                linkCount, totalInitialSize, totalFinalSize, totalInitialSize - totalFinalSize,
326                100.0 * (totalInitialSize - totalFinalSize) / totalInitialSize);
327     }
328 #endif
329     
330 #if DUMP_CODE
331     static void dumpCode(void* code, size_t size)
332     {
333 #if CPU(ARM_THUMB2)
334         // Dump the generated code in an asm file format that can be assembled and then disassembled
335         // for debugging purposes. For example, save this output as jit.s:
336         //   gcc -arch armv7 -c jit.s
337         //   otool -tv jit.o
338         static unsigned codeCount = 0;
339         unsigned short* tcode = static_cast<unsigned short*>(code);
340         size_t tsize = size / sizeof(short);
341         char nameBuf[128];
342         snprintf(nameBuf, sizeof(nameBuf), "_jsc_jit%u", codeCount++);
343         printf("\t.syntax unified\n"
344                "\t.section\t__TEXT,__text,regular,pure_instructions\n"
345                "\t.globl\t%s\n"
346                "\t.align 2\n"
347                "\t.code 16\n"
348                "\t.thumb_func\t%s\n"
349                "# %p\n"
350                "%s:\n", nameBuf, nameBuf, code, nameBuf);
351         
352         for (unsigned i = 0; i < tsize; i++)
353             printf("\t.short\t0x%x\n", tcode[i]);
354 #endif
355     }
356 #endif
357     
358     RefPtr<ExecutableMemoryHandle> m_executableMemory;
359     size_t m_size;
360     void* m_code;
361     MacroAssembler* m_assembler;
362     JSGlobalData* m_globalData;
363 #ifndef NDEBUG
364     bool m_completed;
365 #endif
366 };
367
368 } // namespace JSC
369
370 #endif // ENABLE(ASSEMBLER)
371
372 #endif // LinkBuffer_h