Enhance the MacroAssembler and LinkBuffer to support pointer profiling.
[WebKit-https.git] / Source / JavaScriptCore / assembler / LinkBuffer.h
1 /*
2  * Copyright (C) 2009-2018 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 #pragma once
27
28 #if ENABLE(ASSEMBLER)
29
30 #define DUMP_LINK_STATISTICS 0
31 #define DUMP_CODE 0
32
33 #define GLOBAL_THUNK_ID reinterpret_cast<void*>(static_cast<intptr_t>(-1))
34 #define REGEXP_CODE_ID reinterpret_cast<void*>(static_cast<intptr_t>(-2))
35 #define CSS_CODE_ID reinterpret_cast<void*>(static_cast<intptr_t>(-3))
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 CodeBlock;
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(MacroAssembler& macroAssembler, void* ownerUID, JITCompilationEffort effort = JITCompilationMustSucceed)
82         : m_size(0)
83         , m_didAllocate(false)
84         , m_code(0)
85 #ifndef NDEBUG
86         , m_completed(false)
87 #endif
88     {
89         linkCode(macroAssembler, ownerUID, effort);
90     }
91
92     LinkBuffer(MacroAssembler& macroAssembler, void* code, size_t size, JITCompilationEffort effort = JITCompilationMustSucceed, bool shouldPerformBranchCompaction = true)
93         : m_size(size)
94         , m_didAllocate(false)
95         , m_code(code)
96 #ifndef NDEBUG
97         , m_completed(false)
98 #endif
99     {
100 #if ENABLE(BRANCH_COMPACTION)
101         m_shouldPerformBranchCompaction = shouldPerformBranchCompaction;
102 #else
103         UNUSED_PARAM(shouldPerformBranchCompaction);
104 #endif
105         linkCode(macroAssembler, 0, effort);
106     }
107
108     ~LinkBuffer()
109     {
110     }
111     
112     bool didFailToAllocate() const
113     {
114         return !m_didAllocate;
115     }
116
117     bool isValid() const
118     {
119         return !didFailToAllocate();
120     }
121     
122     // These methods are used to link or set values at code generation time.
123
124     template<typename Func, typename = std::enable_if_t<std::is_function<typename std::remove_pointer<Func>::type>::value>>
125     void link(Call call, Func funcName, PtrTag tag)
126     {
127         FunctionPtr function(funcName, tag);
128         link(call, function);
129     }
130
131     void link(Call call, FunctionPtr function)
132     {
133         ASSERT(call.isFlagSet(Call::Linkable));
134         call.m_label = applyOffset(call.m_label);
135         MacroAssembler::linkCall(code(), call, function);
136     }
137     
138     void link(Call call, CodeLocationLabel label)
139     {
140         link(call, FunctionPtr(label));
141     }
142     
143     void link(Jump jump, CodeLocationLabel label)
144     {
145         jump.m_label = applyOffset(jump.m_label);
146         MacroAssembler::linkJump(code(), jump, label);
147     }
148
149     void link(const JumpList& list, CodeLocationLabel label)
150     {
151         for (const Jump& jump : list.jumps())
152             link(jump, label);
153     }
154
155     void patch(DataLabelPtr label, void* value)
156     {
157         AssemblerLabel target = applyOffset(label.m_label);
158         MacroAssembler::linkPointer(code(), target, value);
159     }
160
161     void patch(DataLabelPtr label, CodeLocationLabel value)
162     {
163         AssemblerLabel target = applyOffset(label.m_label);
164         MacroAssembler::linkPointer(code(), target, value);
165     }
166
167     // These methods are used to obtain handles to allow the code to be relinked / repatched later.
168     
169     CodeLocationLabel entrypoint()
170     {
171         return CodeLocationLabel(code());
172     }
173
174     CodeLocationCall locationOf(Call call)
175     {
176         ASSERT(call.isFlagSet(Call::Linkable));
177         ASSERT(!call.isFlagSet(Call::Near));
178         return CodeLocationCall(MacroAssembler::getLinkerAddress(code(), applyOffset(call.m_label)));
179     }
180
181     CodeLocationNearCall locationOfNearCall(Call call)
182     {
183         ASSERT(call.isFlagSet(Call::Linkable));
184         ASSERT(call.isFlagSet(Call::Near));
185         return CodeLocationNearCall(MacroAssembler::getLinkerAddress(code(), applyOffset(call.m_label), NearCallPtrTag),
186             call.isFlagSet(Call::Tail) ? NearCallMode::Tail : NearCallMode::Regular);
187     }
188
189     CodeLocationLabel locationOf(PatchableJump jump)
190     {
191         return CodeLocationLabel(MacroAssembler::getLinkerAddress(code(), applyOffset(jump.m_jump.m_label)));
192     }
193
194     // FIXME: remove the default PtrTag value once we've tagged all the clients.
195     CodeLocationLabel locationOf(Label label, PtrTag tag = NoPtrTag)
196     {
197         return CodeLocationLabel(MacroAssembler::getLinkerAddress(code(), applyOffset(label.m_label), tag));
198     }
199
200     CodeLocationDataLabelPtr locationOf(DataLabelPtr label)
201     {
202         return CodeLocationDataLabelPtr(MacroAssembler::getLinkerAddress(code(), applyOffset(label.m_label)));
203     }
204
205     CodeLocationDataLabel32 locationOf(DataLabel32 label)
206     {
207         return CodeLocationDataLabel32(MacroAssembler::getLinkerAddress(code(), applyOffset(label.m_label)));
208     }
209     
210     CodeLocationDataLabelCompact locationOf(DataLabelCompact label)
211     {
212         return CodeLocationDataLabelCompact(MacroAssembler::getLinkerAddress(code(), applyOffset(label.m_label)));
213     }
214
215     CodeLocationConvertibleLoad locationOf(ConvertibleLoadLabel label)
216     {
217         return CodeLocationConvertibleLoad(MacroAssembler::getLinkerAddress(code(), applyOffset(label.m_label)));
218     }
219
220     // This method obtains the return address of the call, given as an offset from
221     // the start of the code.
222     unsigned returnAddressOffset(Call call)
223     {
224         call.m_label = applyOffset(call.m_label);
225         return MacroAssembler::getLinkerCallReturnOffset(call);
226     }
227
228     uint32_t offsetOf(Label label)
229     {
230         return applyOffset(label.m_label).m_offset;
231     }
232
233     unsigned offsetOf(PatchableJump jump)
234     {
235         return applyOffset(jump.m_jump.m_label).m_offset;
236     }
237
238     // Upon completion of all patching 'FINALIZE_CODE()' should be called once to
239     // complete generation of the code. Alternatively, call
240     // finalizeCodeWithoutDisassembly() directly if you have your own way of
241     // displaying disassembly.
242     
243     JS_EXPORT_PRIVATE CodeRef finalizeCodeWithoutDisassembly(PtrTag);
244     JS_EXPORT_PRIVATE CodeRef finalizeCodeWithDisassembly(PtrTag, const char* format, ...) WTF_ATTRIBUTE_PRINTF(3, 4);
245
246     CodePtr trampolineAt(Label label)
247     {
248         return CodePtr(MacroAssembler::AssemblerType_T::getRelocatedAddress(code(), applyOffset(label.m_label)));
249     }
250
251     void* debugAddress()
252     {
253         return m_code;
254     }
255
256     size_t size() const { return m_size; }
257     
258     bool wasAlreadyDisassembled() const { return m_alreadyDisassembled; }
259     void didAlreadyDisassemble() { m_alreadyDisassembled = true; }
260
261 private:
262 #if ENABLE(BRANCH_COMPACTION)
263     int executableOffsetFor(int location)
264     {
265         if (!location)
266             return 0;
267         return bitwise_cast<int32_t*>(m_assemblerStorage.buffer())[location / sizeof(int32_t) - 1];
268     }
269 #endif
270     
271     template <typename T> T applyOffset(T src)
272     {
273 #if ENABLE(BRANCH_COMPACTION)
274         src.m_offset -= executableOffsetFor(src.m_offset);
275 #endif
276         return src;
277     }
278
279     // Keep this private! - the underlying code should only be obtained externally via finalizeCode().
280     void* code()
281     {
282         return m_code;
283     }
284     
285     void allocate(MacroAssembler&, void* ownerUID, JITCompilationEffort);
286
287     JS_EXPORT_PRIVATE void linkCode(MacroAssembler&, void* ownerUID, JITCompilationEffort);
288 #if ENABLE(BRANCH_COMPACTION)
289     template <typename InstructionType>
290     void copyCompactAndLinkCode(MacroAssembler&, void* ownerUID, JITCompilationEffort);
291 #endif
292
293     void performFinalization();
294
295 #if DUMP_LINK_STATISTICS
296     static void dumpLinkStatistics(void* code, size_t initialSize, size_t finalSize);
297 #endif
298     
299 #if DUMP_CODE
300     static void dumpCode(void* code, size_t);
301 #endif
302     
303     RefPtr<ExecutableMemoryHandle> m_executableMemory;
304     size_t m_size;
305 #if ENABLE(BRANCH_COMPACTION)
306     AssemblerData m_assemblerStorage;
307     bool m_shouldPerformBranchCompaction { true };
308 #endif
309     bool m_didAllocate;
310     void* m_code;
311 #ifndef NDEBUG
312     bool m_completed;
313 #endif
314     bool m_alreadyDisassembled { false };
315     Vector<RefPtr<SharedTask<void(LinkBuffer&)>>> m_linkTasks;
316 };
317
318 #define FINALIZE_CODE_IF(condition, linkBufferReference, resultPtrTag, ...)  \
319     (UNLIKELY((condition))                                              \
320         ? (linkBufferReference).finalizeCodeWithDisassembly(resultPtrTag, __VA_ARGS__) \
321         : (linkBufferReference).finalizeCodeWithoutDisassembly(resultPtrTag))
322
323 bool shouldDumpDisassemblyFor(CodeBlock*);
324
325 #define FINALIZE_CODE_FOR(codeBlock, linkBufferReference, resultPtrTag, ...)  \
326     FINALIZE_CODE_IF((shouldDumpDisassemblyFor(codeBlock) || Options::asyncDisassembly()), linkBufferReference, resultPtrTag, __VA_ARGS__)
327
328 // Use this to finalize code, like so:
329 //
330 // CodeRef code = FINALIZE_CODE(linkBuffer, tag, "my super thingy number %d", number);
331 //
332 // Which, in disassembly mode, will print:
333 //
334 // Generated JIT code for my super thingy number 42:
335 //     Code at [0x123456, 0x234567]:
336 //         0x123456: mov $0, 0
337 //         0x12345a: ret
338 //
339 // ... and so on.
340 //
341 // Note that the format string and print arguments are only evaluated when dumpDisassembly
342 // is true, so you can hide expensive disassembly-only computations inside there.
343
344 #define FINALIZE_CODE(linkBufferReference, resultPtrTag, ...)  \
345     FINALIZE_CODE_IF((JSC::Options::asyncDisassembly() || JSC::Options::dumpDisassembly()), linkBufferReference, resultPtrTag, __VA_ARGS__)
346
347 #define FINALIZE_DFG_CODE(linkBufferReference, resultPtrTag, ...)  \
348     FINALIZE_CODE_IF((JSC::Options::asyncDisassembly() || JSC::Options::dumpDisassembly() || Options::dumpDFGDisassembly()), linkBufferReference, resultPtrTag, __VA_ARGS__)
349
350 } // namespace JSC
351
352 #endif // ENABLE(ASSEMBLER)