Adding test case for text-decoration property state change on applying different...
[WebKit-https.git] / Source / JavaScriptCore / assembler / LinkBuffer.h
1 /*
2  * Copyright (C) 2009, 2010, 2012 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 #define GLOBAL_THUNK_ID reinterpret_cast<void*>(static_cast<intptr_t>(-1))
35 #define REGEXP_CODE_ID reinterpret_cast<void*>(static_cast<intptr_t>(-2))
36
37 #include "JITCompilationEffort.h"
38 #include "MacroAssembler.h"
39 #include <wtf/DataLog.h>
40 #include <wtf/FastMalloc.h>
41 #include <wtf/Noncopyable.h>
42
43 namespace JSC {
44
45 class VM;
46
47 // LinkBuffer:
48 //
49 // This class assists in linking code generated by the macro assembler, once code generation
50 // has been completed, and the code has been copied to is final location in memory.  At this
51 // time pointers to labels within the code may be resolved, and relative offsets to external
52 // addresses may be fixed.
53 //
54 // Specifically:
55 //   * Jump objects may be linked to external targets,
56 //   * The address of Jump objects may taken, such that it can later be relinked.
57 //   * The return address of a Call may be acquired.
58 //   * The address of a Label pointing into the code may be resolved.
59 //   * The value referenced by a DataLabel may be set.
60 //
61 class LinkBuffer {
62     WTF_MAKE_NONCOPYABLE(LinkBuffer); WTF_MAKE_FAST_ALLOCATED;
63     
64     typedef MacroAssemblerCodeRef CodeRef;
65     typedef MacroAssemblerCodePtr CodePtr;
66     typedef MacroAssembler::Label Label;
67     typedef MacroAssembler::Jump Jump;
68     typedef MacroAssembler::PatchableJump PatchableJump;
69     typedef MacroAssembler::JumpList JumpList;
70     typedef MacroAssembler::Call Call;
71     typedef MacroAssembler::DataLabelCompact DataLabelCompact;
72     typedef MacroAssembler::DataLabel32 DataLabel32;
73     typedef MacroAssembler::DataLabelPtr DataLabelPtr;
74     typedef MacroAssembler::ConvertibleLoadLabel ConvertibleLoadLabel;
75 #if ENABLE(BRANCH_COMPACTION)
76     typedef MacroAssembler::LinkRecord LinkRecord;
77     typedef MacroAssembler::JumpLinkType JumpLinkType;
78 #endif
79
80 public:
81     LinkBuffer(VM& vm, MacroAssembler* masm, void* ownerUID, JITCompilationEffort effort = JITCompilationMustSucceed)
82         : m_size(0)
83 #if ENABLE(BRANCH_COMPACTION)
84         , m_initialSize(0)
85 #endif
86         , m_code(0)
87         , m_assembler(masm)
88         , m_vm(&vm)
89 #ifndef NDEBUG
90         , m_completed(false)
91 #endif
92     {
93         linkCode(ownerUID, effort);
94     }
95
96     ~LinkBuffer()
97     {
98     }
99     
100     bool didFailToAllocate() const
101     {
102         return !m_executableMemory;
103     }
104
105     bool isValid() const
106     {
107         return !didFailToAllocate();
108     }
109     
110     // These methods are used to link or set values at code generation time.
111
112     void link(Call call, FunctionPtr function)
113     {
114         ASSERT(call.isFlagSet(Call::Linkable));
115         call.m_label = applyOffset(call.m_label);
116         MacroAssembler::linkCall(code(), call, function);
117     }
118     
119     void link(Jump jump, CodeLocationLabel label)
120     {
121         jump.m_label = applyOffset(jump.m_label);
122         MacroAssembler::linkJump(code(), jump, label);
123     }
124
125     void link(JumpList list, CodeLocationLabel label)
126     {
127         for (unsigned i = 0; i < list.m_jumps.size(); ++i)
128             link(list.m_jumps[i], label);
129     }
130
131     void patch(DataLabelPtr label, void* value)
132     {
133         AssemblerLabel target = applyOffset(label.m_label);
134         MacroAssembler::linkPointer(code(), target, value);
135     }
136
137     void patch(DataLabelPtr label, CodeLocationLabel value)
138     {
139         AssemblerLabel target = applyOffset(label.m_label);
140         MacroAssembler::linkPointer(code(), target, value.executableAddress());
141     }
142
143     // These methods are used to obtain handles to allow the code to be relinked / repatched later.
144
145     CodeLocationCall locationOf(Call call)
146     {
147         ASSERT(call.isFlagSet(Call::Linkable));
148         ASSERT(!call.isFlagSet(Call::Near));
149         return CodeLocationCall(MacroAssembler::getLinkerAddress(code(), applyOffset(call.m_label)));
150     }
151
152     CodeLocationNearCall locationOfNearCall(Call call)
153     {
154         ASSERT(call.isFlagSet(Call::Linkable));
155         ASSERT(call.isFlagSet(Call::Near));
156         return CodeLocationNearCall(MacroAssembler::getLinkerAddress(code(), applyOffset(call.m_label)));
157     }
158
159     CodeLocationLabel locationOf(PatchableJump jump)
160     {
161         return CodeLocationLabel(MacroAssembler::getLinkerAddress(code(), applyOffset(jump.m_jump.m_label)));
162     }
163
164     CodeLocationLabel locationOf(Label label)
165     {
166         return CodeLocationLabel(MacroAssembler::getLinkerAddress(code(), applyOffset(label.m_label)));
167     }
168
169     CodeLocationDataLabelPtr locationOf(DataLabelPtr label)
170     {
171         return CodeLocationDataLabelPtr(MacroAssembler::getLinkerAddress(code(), applyOffset(label.m_label)));
172     }
173
174     CodeLocationDataLabel32 locationOf(DataLabel32 label)
175     {
176         return CodeLocationDataLabel32(MacroAssembler::getLinkerAddress(code(), applyOffset(label.m_label)));
177     }
178     
179     CodeLocationDataLabelCompact locationOf(DataLabelCompact label)
180     {
181         return CodeLocationDataLabelCompact(MacroAssembler::getLinkerAddress(code(), applyOffset(label.m_label)));
182     }
183
184     CodeLocationConvertibleLoad locationOf(ConvertibleLoadLabel label)
185     {
186         return CodeLocationConvertibleLoad(MacroAssembler::getLinkerAddress(code(), applyOffset(label.m_label)));
187     }
188
189     // This method obtains the return address of the call, given as an offset from
190     // the start of the code.
191     unsigned returnAddressOffset(Call call)
192     {
193         call.m_label = applyOffset(call.m_label);
194         return MacroAssembler::getLinkerCallReturnOffset(call);
195     }
196
197     uint32_t offsetOf(Label label)
198     {
199         return applyOffset(label.m_label).m_offset;
200     }
201
202     unsigned offsetOf(PatchableJump jump)
203     {
204         return applyOffset(jump.m_jump.m_label).m_offset;
205     }
206
207     // Upon completion of all patching 'FINALIZE_CODE()' should be called once to
208     // complete generation of the code. Alternatively, call
209     // finalizeCodeWithoutDisassembly() directly if you have your own way of
210     // displaying disassembly.
211     
212     CodeRef finalizeCodeWithoutDisassembly();
213     CodeRef finalizeCodeWithDisassembly(const char* format, ...) WTF_ATTRIBUTE_PRINTF(2, 3);
214
215     CodePtr trampolineAt(Label label)
216     {
217         return CodePtr(MacroAssembler::AssemblerType_T::getRelocatedAddress(code(), applyOffset(label.m_label)));
218     }
219
220     void* debugAddress()
221     {
222         return m_code;
223     }
224     
225     size_t debugSize()
226     {
227         return m_size;
228     }
229
230 private:
231     template <typename T> T applyOffset(T src)
232     {
233 #if ENABLE(BRANCH_COMPACTION)
234         src.m_offset -= m_assembler->executableOffsetFor(src.m_offset);
235 #endif
236         return src;
237     }
238     
239     // Keep this private! - the underlying code should only be obtained externally via finalizeCode().
240     void* code()
241     {
242         return m_code;
243     }
244
245     void linkCode(void* ownerUID, JITCompilationEffort);
246 #if ENABLE(BRANCH_COMPACTION)
247     template <typename InstructionType>
248     void copyCompactAndLinkCode(void* ownerUID, JITCompilationEffort);
249 #endif
250
251     void performFinalization();
252
253 #if DUMP_LINK_STATISTICS
254     static void dumpLinkStatistics(void* code, size_t initialSize, size_t finalSize);
255 #endif
256     
257 #if DUMP_CODE
258     static void dumpCode(void* code, size_t);
259 #endif
260     
261     RefPtr<ExecutableMemoryHandle> m_executableMemory;
262     size_t m_size;
263 #if ENABLE(BRANCH_COMPACTION)
264     size_t m_initialSize;
265 #endif
266     void* m_code;
267     MacroAssembler* m_assembler;
268     VM* m_vm;
269 #ifndef NDEBUG
270     bool m_completed;
271 #endif
272 };
273
274 #define FINALIZE_CODE_IF(condition, linkBufferReference, dataLogFArgumentsForHeading)  \
275     (UNLIKELY((condition))                                              \
276      ? ((linkBufferReference).finalizeCodeWithDisassembly dataLogFArgumentsForHeading) \
277      : (linkBufferReference).finalizeCodeWithoutDisassembly())
278
279 // Use this to finalize code, like so:
280 //
281 // CodeRef code = FINALIZE_CODE(linkBuffer, ("my super thingy number %d", number));
282 //
283 // Which, in disassembly mode, will print:
284 //
285 // Generated JIT code for my super thingy number 42:
286 //     Code at [0x123456, 0x234567]:
287 //         0x123456: mov $0, 0
288 //         0x12345a: ret
289 //
290 // ... and so on.
291 //
292 // Note that the dataLogFArgumentsForHeading are only evaluated when showDisassembly
293 // is true, so you can hide expensive disassembly-only computations inside there.
294
295 #define FINALIZE_CODE(linkBufferReference, dataLogFArgumentsForHeading)  \
296     FINALIZE_CODE_IF(Options::showDisassembly(), linkBufferReference, dataLogFArgumentsForHeading)
297
298 #define FINALIZE_DFG_CODE(linkBufferReference, dataLogFArgumentsForHeading)  \
299     FINALIZE_CODE_IF((Options::showDisassembly() || Options::showDFGDisassembly()), linkBufferReference, dataLogFArgumentsForHeading)
300
301 } // namespace JSC
302
303 #endif // ENABLE(ASSEMBLER)
304
305 #endif // LinkBuffer_h