1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
|
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>3. Building a JIT: Per-function Lazy Compilation — LLVM 13 documentation</title>
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<link rel="stylesheet" href="../_static/llvm-theme.css" type="text/css" />
<script id="documentation_options" data-url_root="../" src="../_static/documentation_options.js"></script>
<script src="../_static/jquery.js"></script>
<script src="../_static/underscore.js"></script>
<script src="../_static/doctools.js"></script>
<link rel="index" title="Index" href="../genindex.html" />
<link rel="search" title="Search" href="../search.html" />
<link rel="next" title="4. Building a JIT: Extreme Laziness - Using LazyReexports to JIT from ASTs" href="BuildingAJIT4.html" />
<link rel="prev" title="2. Building a JIT: Adding Optimizations – An introduction to ORC Layers" href="BuildingAJIT2.html" />
<style type="text/css">
table.right { float: right; margin-left: 20px; }
table.right td { border: 1px solid #ccc; }
</style>
</head><body>
<div class="logo">
<a href="../index.html">
<img src="../_static/logo.png"
alt="LLVM Logo" width="250" height="88"/></a>
</div>
<div class="related" role="navigation" aria-label="related navigation">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="BuildingAJIT4.html" title="4. Building a JIT: Extreme Laziness - Using LazyReexports to JIT from ASTs"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="BuildingAJIT2.html" title="2. Building a JIT: Adding Optimizations – An introduction to ORC Layers"
accesskey="P">previous</a> |</li>
<li><a href="https://llvm.org/">LLVM Home</a> | </li>
<li><a href="../index.html">Documentation</a>»</li>
<li class="nav-item nav-item-1"><a href="../GettingStartedTutorials.html" >Getting Started/Tutorials</a> »</li>
<li class="nav-item nav-item-2"><a href="index.html" accesskey="U">LLVM Tutorial: Table of Contents</a> »</li>
<li class="nav-item nav-item-this"><a href=""><span class="section-number">3. </span>Building a JIT: Per-function Lazy Compilation</a></li>
</ul>
</div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper">
<h3>Documentation</h3>
<ul class="want-points">
<li><a href="https://llvm.org/docs/GettingStartedTutorials.html">Getting Started/Tutorials</a></li>
<li><a href="https://llvm.org/docs/UserGuides.html">User Guides</a></li>
<li><a href="https://llvm.org/docs/Reference.html">Reference</a></li>
</ul>
<h3>Getting Involved</h3>
<ul class="want-points">
<li><a href="https://llvm.org/docs/Contributing.html">Contributing to LLVM</a></li>
<li><a href="https://llvm.org/docs/HowToSubmitABug.html">Submitting Bug Reports</a></li>
<li><a href="https://llvm.org/docs/GettingInvolved.html#mailing-lists">Mailing Lists</a></li>
<li><a href="https://llvm.org/docs/GettingInvolved.html#irc">IRC</a></li>
<li><a href="https://llvm.org/docs/GettingInvolved.html#meetups-and-social-events">Meetups and Social Events</a></li>
</ul>
<h3>Additional Links</h3>
<ul class="want-points">
<li><a href="https://llvm.org/docs/FAQ.html">FAQ</a></li>
<li><a href="https://llvm.org/docs/Lexicon.html">Glossary</a></li>
<li><a href="https://llvm.org/pubs">Publications</a></li>
<li><a href="https://github.com/llvm/llvm-project//">Github Repository</a></li>
</ul>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="../_sources/tutorial/BuildingAJIT3.rst.txt"
rel="nofollow">Show Source</a></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search">
<h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper">
<form class="search" action="../search.html" method="get">
<input type="text" name="q" aria-labelledby="searchlabel" />
<input type="submit" value="Go" />
</form>
</div>
</div>
<script>$('#searchbox').show(0);</script>
</div>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body" role="main">
<div class="section" id="building-a-jit-per-function-lazy-compilation">
<h1><span class="section-number">3. </span>Building a JIT: Per-function Lazy Compilation<a class="headerlink" href="#building-a-jit-per-function-lazy-compilation" title="Permalink to this headline">¶</a></h1>
<div class="contents local topic" id="contents">
<ul class="simple">
<li><p><a class="reference internal" href="#chapter-3-introduction" id="id1">Chapter 3 Introduction</a></p></li>
<li><p><a class="reference internal" href="#lazy-compilation" id="id2">Lazy Compilation</a></p></li>
<li><p><a class="reference internal" href="#full-code-listing" id="id3">Full Code Listing</a></p></li>
</ul>
</div>
<p><strong>This tutorial is under active development. It is incomplete and details may
change frequently.</strong> Nonetheless we invite you to try it out as it stands, and
we welcome any feedback.</p>
<div class="section" id="chapter-3-introduction">
<h2><a class="toc-backref" href="#id1"><span class="section-number">3.1. </span>Chapter 3 Introduction</a><a class="headerlink" href="#chapter-3-introduction" title="Permalink to this headline">¶</a></h2>
<p><strong>Warning: This text is currently out of date due to ORC API updates.</strong></p>
<p><strong>The example code has been updated and can be used. The text will be updated
once the API churn dies down.</strong></p>
<p>Welcome to Chapter 3 of the “Building an ORC-based JIT in LLVM” tutorial. This
chapter discusses lazy JITing and shows you how to enable it by adding an ORC
CompileOnDemand layer the JIT from <a class="reference external" href="BuildingAJIT2.html">Chapter 2</a>.</p>
</div>
<div class="section" id="lazy-compilation">
<h2><a class="toc-backref" href="#id2"><span class="section-number">3.2. </span>Lazy Compilation</a><a class="headerlink" href="#lazy-compilation" title="Permalink to this headline">¶</a></h2>
<p>When we add a module to the KaleidoscopeJIT class from Chapter 2 it is
immediately optimized, compiled and linked for us by the IRTransformLayer,
IRCompileLayer and RTDyldObjectLinkingLayer respectively. This scheme, where all the
work to make a Module executable is done up front, is simple to understand and
its performance characteristics are easy to reason about. However, it will lead
to very high startup times if the amount of code to be compiled is large, and
may also do a lot of unnecessary compilation if only a few compiled functions
are ever called at runtime. A truly “just-in-time” compiler should allow us to
defer the compilation of any given function until the moment that function is
first called, improving launch times and eliminating redundant work. In fact,
the ORC APIs provide us with a layer to lazily compile LLVM IR:
<em>CompileOnDemandLayer</em>.</p>
<p>The CompileOnDemandLayer class conforms to the layer interface described in
Chapter 2, but its addModule method behaves quite differently from the layers
we have seen so far: rather than doing any work up front, it just scans the
Modules being added and arranges for each function in them to be compiled the
first time it is called. To do this, the CompileOnDemandLayer creates two small
utilities for each function that it scans: a <em>stub</em> and a <em>compile
callback</em>. The stub is a pair of a function pointer (which will be pointed at
the function’s implementation once the function has been compiled) and an
indirect jump through the pointer. By fixing the address of the indirect jump
for the lifetime of the program we can give the function a permanent “effective
address”, one that can be safely used for indirection and function pointer
comparison even if the function’s implementation is never compiled, or if it is
compiled more than once (due to, for example, recompiling the function at a
higher optimization level) and changes address. The second utility, the compile
callback, represents a re-entry point from the program into the compiler that
will trigger compilation and then execution of a function. By initializing the
function’s stub to point at the function’s compile callback, we enable lazy
compilation: The first attempted call to the function will follow the function
pointer and trigger the compile callback instead. The compile callback will
compile the function, update the function pointer for the stub, then execute
the function. On all subsequent calls to the function, the function pointer
will point at the already-compiled function, so there is no further overhead
from the compiler. We will look at this process in more detail in the next
chapter of this tutorial, but for now we’ll trust the CompileOnDemandLayer to
set all the stubs and callbacks up for us. All we need to do is to add the
CompileOnDemandLayer to the top of our stack and we’ll get the benefits of
lazy compilation. We just need a few changes to the source:</p>
<div class="highlight-c++ notranslate"><div class="highlight"><pre><span></span><span class="p">...</span>
<span class="cp">#include</span> <span class="cpf">"llvm/ExecutionEngine/SectionMemoryManager.h"</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">"llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h"</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">"llvm/ExecutionEngine/Orc/CompileUtils.h"</span><span class="cp"></span>
<span class="p">...</span>
<span class="p">...</span>
<span class="k">class</span> <span class="nc">KaleidoscopeJIT</span> <span class="p">{</span>
<span class="k">private</span><span class="o">:</span>
<span class="n">std</span><span class="o">::</span><span class="n">unique_ptr</span><span class="o"><</span><span class="n">TargetMachine</span><span class="o">></span> <span class="n">TM</span><span class="p">;</span>
<span class="k">const</span> <span class="n">DataLayout</span> <span class="n">DL</span><span class="p">;</span>
<span class="n">RTDyldObjectLinkingLayer</span> <span class="n">ObjectLayer</span><span class="p">;</span>
<span class="n">IRCompileLayer</span><span class="o"><</span><span class="k">decltype</span><span class="p">(</span><span class="n">ObjectLayer</span><span class="p">),</span> <span class="n">SimpleCompiler</span><span class="o">></span> <span class="n">CompileLayer</span><span class="p">;</span>
<span class="k">using</span> <span class="n">OptimizeFunction</span> <span class="o">=</span>
<span class="n">std</span><span class="o">::</span><span class="n">function</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">shared_ptr</span><span class="o"><</span><span class="n">Module</span><span class="o">></span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">shared_ptr</span><span class="o"><</span><span class="n">Module</span><span class="o">></span><span class="p">)</span><span class="o">></span><span class="p">;</span>
<span class="n">IRTransformLayer</span><span class="o"><</span><span class="k">decltype</span><span class="p">(</span><span class="n">CompileLayer</span><span class="p">),</span> <span class="n">OptimizeFunction</span><span class="o">></span> <span class="n">OptimizeLayer</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">unique_ptr</span><span class="o"><</span><span class="n">JITCompileCallbackManager</span><span class="o">></span> <span class="n">CompileCallbackManager</span><span class="p">;</span>
<span class="n">CompileOnDemandLayer</span><span class="o"><</span><span class="k">decltype</span><span class="p">(</span><span class="n">OptimizeLayer</span><span class="p">)</span><span class="o">></span> <span class="n">CODLayer</span><span class="p">;</span>
<span class="k">public</span><span class="o">:</span>
<span class="k">using</span> <span class="n">ModuleHandle</span> <span class="o">=</span> <span class="k">decltype</span><span class="p">(</span><span class="n">CODLayer</span><span class="p">)</span><span class="o">::</span><span class="n">ModuleHandleT</span><span class="p">;</span>
</pre></div>
</div>
<p>First we need to include the CompileOnDemandLayer.h header, then add two new
members: a std::unique_ptr<JITCompileCallbackManager> and a CompileOnDemandLayer,
to our class. The CompileCallbackManager member is used by the CompileOnDemandLayer
to create the compile callback needed for each function.</p>
<div class="highlight-c++ notranslate"><div class="highlight"><pre><span></span><span class="n">KaleidoscopeJIT</span><span class="p">()</span>
<span class="o">:</span> <span class="n">TM</span><span class="p">(</span><span class="n">EngineBuilder</span><span class="p">().</span><span class="n">selectTarget</span><span class="p">()),</span> <span class="n">DL</span><span class="p">(</span><span class="n">TM</span><span class="o">-></span><span class="n">createDataLayout</span><span class="p">()),</span>
<span class="n">ObjectLayer</span><span class="p">([]()</span> <span class="p">{</span> <span class="k">return</span> <span class="n">std</span><span class="o">::</span><span class="n">make_shared</span><span class="o"><</span><span class="n">SectionMemoryManager</span><span class="o">></span><span class="p">();</span> <span class="p">}),</span>
<span class="n">CompileLayer</span><span class="p">(</span><span class="n">ObjectLayer</span><span class="p">,</span> <span class="n">SimpleCompiler</span><span class="p">(</span><span class="o">*</span><span class="n">TM</span><span class="p">)),</span>
<span class="n">OptimizeLayer</span><span class="p">(</span><span class="n">CompileLayer</span><span class="p">,</span>
<span class="p">[</span><span class="k">this</span><span class="p">](</span><span class="n">std</span><span class="o">::</span><span class="n">shared_ptr</span><span class="o"><</span><span class="n">Module</span><span class="o">></span> <span class="n">M</span><span class="p">)</span> <span class="p">{</span>
<span class="k">return</span> <span class="nf">optimizeModule</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">M</span><span class="p">));</span>
<span class="p">}),</span>
<span class="n">CompileCallbackManager</span><span class="p">(</span>
<span class="n">orc</span><span class="o">::</span><span class="n">createLocalCompileCallbackManager</span><span class="p">(</span><span class="n">TM</span><span class="o">-></span><span class="n">getTargetTriple</span><span class="p">(),</span> <span class="mi">0</span><span class="p">)),</span>
<span class="n">CODLayer</span><span class="p">(</span><span class="n">OptimizeLayer</span><span class="p">,</span>
<span class="p">[</span><span class="k">this</span><span class="p">](</span><span class="n">Function</span> <span class="o">&</span><span class="n">F</span><span class="p">)</span> <span class="p">{</span> <span class="k">return</span> <span class="n">std</span><span class="o">::</span><span class="n">set</span><span class="o"><</span><span class="n">Function</span><span class="o">*></span><span class="p">({</span><span class="o">&</span><span class="n">F</span><span class="p">});</span> <span class="p">},</span>
<span class="o">*</span><span class="n">CompileCallbackManager</span><span class="p">,</span>
<span class="n">orc</span><span class="o">::</span><span class="n">createLocalIndirectStubsManagerBuilder</span><span class="p">(</span>
<span class="n">TM</span><span class="o">-></span><span class="n">getTargetTriple</span><span class="p">()))</span> <span class="p">{</span>
<span class="n">llvm</span><span class="o">::</span><span class="n">sys</span><span class="o">::</span><span class="n">DynamicLibrary</span><span class="o">::</span><span class="n">LoadLibraryPermanently</span><span class="p">(</span><span class="k">nullptr</span><span class="p">);</span>
<span class="p">}</span>
</pre></div>
</div>
<p>Next we have to update our constructor to initialize the new members. To create
an appropriate compile callback manager we use the
createLocalCompileCallbackManager function, which takes a TargetMachine and a
JITTargetAddress to call if it receives a request to compile an unknown
function. In our simple JIT this situation is unlikely to come up, so we’ll
cheat and just pass ‘0’ here. In a production quality JIT you could give the
address of a function that throws an exception in order to unwind the JIT’d
code’s stack.</p>
<p>Now we can construct our CompileOnDemandLayer. Following the pattern from
previous layers we start by passing a reference to the next layer down in our
stack – the OptimizeLayer. Next we need to supply a ‘partitioning function’:
when a not-yet-compiled function is called, the CompileOnDemandLayer will call
this function to ask us what we would like to compile. At a minimum we need to
compile the function being called (given by the argument to the partitioning
function), but we could also request that the CompileOnDemandLayer compile other
functions that are unconditionally called (or highly likely to be called) from
the function being called. For KaleidoscopeJIT we’ll keep it simple and just
request compilation of the function that was called. Next we pass a reference to
our CompileCallbackManager. Finally, we need to supply an “indirect stubs
manager builder”: a utility function that constructs IndirectStubManagers, which
are in turn used to build the stubs for the functions in each module. The
CompileOnDemandLayer will call the indirect stub manager builder once for each
call to addModule, and use the resulting indirect stubs manager to create
stubs for all functions in all modules in the set. If/when the module set is
removed from the JIT the indirect stubs manager will be deleted, freeing any
memory allocated to the stubs. We supply this function by using the
createLocalIndirectStubsManagerBuilder utility.</p>
<div class="highlight-c++ notranslate"><div class="highlight"><pre><span></span><span class="c1">// ...</span>
<span class="k">if</span> <span class="p">(</span><span class="k">auto</span> <span class="n">Sym</span> <span class="o">=</span> <span class="n">CODLayer</span><span class="p">.</span><span class="n">findSymbol</span><span class="p">(</span><span class="n">Name</span><span class="p">,</span> <span class="nb">false</span><span class="p">))</span>
<span class="c1">// ...</span>
<span class="k">return</span> <span class="n">cantFail</span><span class="p">(</span><span class="n">CODLayer</span><span class="p">.</span><span class="n">addModule</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">Ms</span><span class="p">),</span>
<span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">Resolver</span><span class="p">)));</span>
<span class="c1">// ...</span>
<span class="c1">// ...</span>
<span class="k">return</span> <span class="n">CODLayer</span><span class="p">.</span><span class="n">findSymbol</span><span class="p">(</span><span class="n">MangledNameStream</span><span class="p">.</span><span class="n">str</span><span class="p">(),</span> <span class="nb">true</span><span class="p">);</span>
<span class="c1">// ...</span>
<span class="c1">// ...</span>
<span class="n">CODLayer</span><span class="p">.</span><span class="n">removeModule</span><span class="p">(</span><span class="n">H</span><span class="p">);</span>
<span class="c1">// ...</span>
</pre></div>
</div>
<p>Finally, we need to replace the references to OptimizeLayer in our addModule,
findSymbol, and removeModule methods. With that, we’re up and running.</p>
<p><strong>To be done:</strong></p>
<p>** Chapter conclusion.**</p>
</div>
<div class="section" id="full-code-listing">
<h2><a class="toc-backref" href="#id3"><span class="section-number">3.3. </span>Full Code Listing</a><a class="headerlink" href="#full-code-listing" title="Permalink to this headline">¶</a></h2>
<p>Here is the complete code listing for our running example with a CompileOnDemand
layer added to enable lazy function-at-a-time compilation. To build this example, use:</p>
<div class="highlight-bash notranslate"><div class="highlight"><pre><span></span><span class="c1"># Compile</span>
clang++ -g toy.cpp <span class="sb">`</span>llvm-config --cxxflags --ldflags --system-libs --libs core orcjit native<span class="sb">`</span> -O3 -o toy
<span class="c1"># Run</span>
./toy
</pre></div>
</div>
<p>Here is the code:</p>
<div class="highlight-c++ notranslate"><div class="highlight"><pre><span></span><span class="c1">//===- KaleidoscopeJIT.h - A simple JIT for Kaleidoscope --------*- C++ -*-===//</span>
<span class="c1">//</span>
<span class="c1">// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.</span>
<span class="c1">// See https://llvm.org/LICENSE.txt for license information.</span>
<span class="c1">// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception</span>
<span class="c1">//</span>
<span class="c1">//===----------------------------------------------------------------------===//</span>
<span class="c1">//</span>
<span class="c1">// Contains a simple JIT definition for use in the kaleidoscope tutorials.</span>
<span class="c1">//</span>
<span class="c1">//===----------------------------------------------------------------------===//</span>
<span class="cp">#ifndef LLVM_EXECUTIONENGINE_ORC_KALEIDOSCOPEJIT_H</span>
<span class="cp">#define LLVM_EXECUTIONENGINE_ORC_KALEIDOSCOPEJIT_H</span>
<span class="cp">#include</span> <span class="cpf">"llvm/ADT/StringRef.h"</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">"llvm/ExecutionEngine/JITSymbol.h"</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">"llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h"</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">"llvm/ExecutionEngine/Orc/CompileUtils.h"</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">"llvm/ExecutionEngine/Orc/Core.h"</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">"llvm/ExecutionEngine/Orc/EPCIndirectionUtils.h"</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">"llvm/ExecutionEngine/Orc/ExecutionUtils.h"</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">"llvm/ExecutionEngine/Orc/ExecutorProcessControl.h"</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">"llvm/ExecutionEngine/Orc/IRCompileLayer.h"</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">"llvm/ExecutionEngine/Orc/IRTransformLayer.h"</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">"llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h"</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">"llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">"llvm/ExecutionEngine/SectionMemoryManager.h"</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">"llvm/IR/DataLayout.h"</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">"llvm/IR/LLVMContext.h"</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">"llvm/IR/LegacyPassManager.h"</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">"llvm/Transforms/InstCombine/InstCombine.h"</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">"llvm/Transforms/Scalar.h"</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">"llvm/Transforms/Scalar/GVN.h"</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><memory></span><span class="cp"></span>
<span class="k">namespace</span> <span class="n">llvm</span> <span class="p">{</span>
<span class="k">namespace</span> <span class="n">orc</span> <span class="p">{</span>
<span class="k">class</span> <span class="nc">KaleidoscopeJIT</span> <span class="p">{</span>
<span class="k">private</span><span class="o">:</span>
<span class="n">std</span><span class="o">::</span><span class="n">unique_ptr</span><span class="o"><</span><span class="n">ExecutionSession</span><span class="o">></span> <span class="n">ES</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">unique_ptr</span><span class="o"><</span><span class="n">EPCIndirectionUtils</span><span class="o">></span> <span class="n">EPCIU</span><span class="p">;</span>
<span class="n">DataLayout</span> <span class="n">DL</span><span class="p">;</span>
<span class="n">MangleAndInterner</span> <span class="n">Mangle</span><span class="p">;</span>
<span class="n">RTDyldObjectLinkingLayer</span> <span class="n">ObjectLayer</span><span class="p">;</span>
<span class="n">IRCompileLayer</span> <span class="n">CompileLayer</span><span class="p">;</span>
<span class="n">IRTransformLayer</span> <span class="n">OptimizeLayer</span><span class="p">;</span>
<span class="n">CompileOnDemandLayer</span> <span class="n">CODLayer</span><span class="p">;</span>
<span class="n">JITDylib</span> <span class="o">&</span><span class="n">MainJD</span><span class="p">;</span>
<span class="k">static</span> <span class="kt">void</span> <span class="n">handleLazyCallThroughError</span><span class="p">()</span> <span class="p">{</span>
<span class="n">errs</span><span class="p">()</span> <span class="o"><<</span> <span class="s">"LazyCallThrough error: Could not find function body"</span><span class="p">;</span>
<span class="n">exit</span><span class="p">(</span><span class="mi">1</span><span class="p">);</span>
<span class="p">}</span>
<span class="k">public</span><span class="o">:</span>
<span class="n">KaleidoscopeJIT</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">unique_ptr</span><span class="o"><</span><span class="n">ExecutionSession</span><span class="o">></span> <span class="n">ES</span><span class="p">,</span>
<span class="n">std</span><span class="o">::</span><span class="n">unique_ptr</span><span class="o"><</span><span class="n">EPCIndirectionUtils</span><span class="o">></span> <span class="n">EPCIU</span><span class="p">,</span>
<span class="n">JITTargetMachineBuilder</span> <span class="n">JTMB</span><span class="p">,</span> <span class="n">DataLayout</span> <span class="n">DL</span><span class="p">)</span>
<span class="o">:</span> <span class="n">ES</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">ES</span><span class="p">)),</span> <span class="n">EPCIU</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">EPCIU</span><span class="p">)),</span> <span class="n">DL</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">DL</span><span class="p">)),</span>
<span class="n">Mangle</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="o">-></span><span class="n">ES</span><span class="p">,</span> <span class="k">this</span><span class="o">-></span><span class="n">DL</span><span class="p">),</span>
<span class="n">ObjectLayer</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="o">-></span><span class="n">ES</span><span class="p">,</span>
<span class="p">[]()</span> <span class="p">{</span> <span class="k">return</span> <span class="n">std</span><span class="o">::</span><span class="n">make_unique</span><span class="o"><</span><span class="n">SectionMemoryManager</span><span class="o">></span><span class="p">();</span> <span class="p">}),</span>
<span class="n">CompileLayer</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="o">-></span><span class="n">ES</span><span class="p">,</span> <span class="n">ObjectLayer</span><span class="p">,</span>
<span class="n">std</span><span class="o">::</span><span class="n">make_unique</span><span class="o"><</span><span class="n">ConcurrentIRCompiler</span><span class="o">></span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">JTMB</span><span class="p">))),</span>
<span class="n">OptimizeLayer</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="o">-></span><span class="n">ES</span><span class="p">,</span> <span class="n">CompileLayer</span><span class="p">,</span> <span class="n">optimizeModule</span><span class="p">),</span>
<span class="n">CODLayer</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="o">-></span><span class="n">ES</span><span class="p">,</span> <span class="n">OptimizeLayer</span><span class="p">,</span>
<span class="k">this</span><span class="o">-></span><span class="n">EPCIU</span><span class="o">-></span><span class="n">getLazyCallThroughManager</span><span class="p">(),</span>
<span class="p">[</span><span class="k">this</span><span class="p">]</span> <span class="p">{</span> <span class="k">return</span> <span class="k">this</span><span class="o">-></span><span class="n">EPCIU</span><span class="o">-></span><span class="n">createIndirectStubsManager</span><span class="p">();</span> <span class="p">}),</span>
<span class="n">MainJD</span><span class="p">(</span><span class="k">this</span><span class="o">-></span><span class="n">ES</span><span class="o">-></span><span class="n">createBareJITDylib</span><span class="p">(</span><span class="s">"<main>"</span><span class="p">))</span> <span class="p">{</span>
<span class="n">MainJD</span><span class="p">.</span><span class="n">addGenerator</span><span class="p">(</span>
<span class="n">cantFail</span><span class="p">(</span><span class="n">DynamicLibrarySearchGenerator</span><span class="o">::</span><span class="n">GetForCurrentProcess</span><span class="p">(</span>
<span class="n">DL</span><span class="p">.</span><span class="n">getGlobalPrefix</span><span class="p">())));</span>
<span class="p">}</span>
<span class="o">~</span><span class="n">KaleidoscopeJIT</span><span class="p">()</span> <span class="p">{</span>
<span class="k">if</span> <span class="p">(</span><span class="k">auto</span> <span class="n">Err</span> <span class="o">=</span> <span class="n">ES</span><span class="o">-></span><span class="n">endSession</span><span class="p">())</span>
<span class="n">ES</span><span class="o">-></span><span class="n">reportError</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">Err</span><span class="p">));</span>
<span class="k">if</span> <span class="p">(</span><span class="k">auto</span> <span class="n">Err</span> <span class="o">=</span> <span class="n">EPCIU</span><span class="o">-></span><span class="n">cleanup</span><span class="p">())</span>
<span class="n">ES</span><span class="o">-></span><span class="n">reportError</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">Err</span><span class="p">));</span>
<span class="p">}</span>
<span class="k">static</span> <span class="n">Expected</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">unique_ptr</span><span class="o"><</span><span class="n">KaleidoscopeJIT</span><span class="o">>></span> <span class="n">Create</span><span class="p">()</span> <span class="p">{</span>
<span class="k">auto</span> <span class="n">EPC</span> <span class="o">=</span> <span class="n">SelfExecutorProcessControl</span><span class="o">::</span><span class="n">Create</span><span class="p">();</span>
<span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">EPC</span><span class="p">)</span>
<span class="k">return</span> <span class="n">EPC</span><span class="p">.</span><span class="n">takeError</span><span class="p">();</span>
<span class="k">auto</span> <span class="n">ES</span> <span class="o">=</span> <span class="n">std</span><span class="o">::</span><span class="n">make_unique</span><span class="o"><</span><span class="n">ExecutionSession</span><span class="o">></span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="o">*</span><span class="n">EPC</span><span class="p">));</span>
<span class="k">auto</span> <span class="n">EPCIU</span> <span class="o">=</span> <span class="n">EPCIndirectionUtils</span><span class="o">::</span><span class="n">Create</span><span class="p">(</span><span class="n">ES</span><span class="o">-></span><span class="n">getExecutorProcessControl</span><span class="p">());</span>
<span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">EPCIU</span><span class="p">)</span>
<span class="k">return</span> <span class="n">EPCIU</span><span class="p">.</span><span class="n">takeError</span><span class="p">();</span>
<span class="p">(</span><span class="o">*</span><span class="n">EPCIU</span><span class="p">)</span><span class="o">-></span><span class="n">createLazyCallThroughManager</span><span class="p">(</span>
<span class="o">*</span><span class="n">ES</span><span class="p">,</span> <span class="n">pointerToJITTargetAddress</span><span class="p">(</span><span class="o">&</span><span class="n">handleLazyCallThroughError</span><span class="p">));</span>
<span class="k">if</span> <span class="p">(</span><span class="k">auto</span> <span class="n">Err</span> <span class="o">=</span> <span class="n">setUpInProcessLCTMReentryViaEPCIU</span><span class="p">(</span><span class="o">**</span><span class="n">EPCIU</span><span class="p">))</span>
<span class="k">return</span> <span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">Err</span><span class="p">);</span>
<span class="n">JITTargetMachineBuilder</span> <span class="nf">JTMB</span><span class="p">(</span>
<span class="n">ES</span><span class="o">-></span><span class="n">getExecutorProcessControl</span><span class="p">().</span><span class="n">getTargetTriple</span><span class="p">());</span>
<span class="k">auto</span> <span class="n">DL</span> <span class="o">=</span> <span class="n">JTMB</span><span class="p">.</span><span class="n">getDefaultDataLayoutForTarget</span><span class="p">();</span>
<span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">DL</span><span class="p">)</span>
<span class="k">return</span> <span class="n">DL</span><span class="p">.</span><span class="n">takeError</span><span class="p">();</span>
<span class="k">return</span> <span class="n">std</span><span class="o">::</span><span class="n">make_unique</span><span class="o"><</span><span class="n">KaleidoscopeJIT</span><span class="o">></span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">ES</span><span class="p">),</span> <span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="o">*</span><span class="n">EPCIU</span><span class="p">),</span>
<span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">JTMB</span><span class="p">),</span> <span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="o">*</span><span class="n">DL</span><span class="p">));</span>
<span class="p">}</span>
<span class="k">const</span> <span class="n">DataLayout</span> <span class="o">&</span><span class="n">getDataLayout</span><span class="p">()</span> <span class="k">const</span> <span class="p">{</span> <span class="k">return</span> <span class="n">DL</span><span class="p">;</span> <span class="p">}</span>
<span class="n">JITDylib</span> <span class="o">&</span><span class="n">getMainJITDylib</span><span class="p">()</span> <span class="p">{</span> <span class="k">return</span> <span class="n">MainJD</span><span class="p">;</span> <span class="p">}</span>
<span class="n">Error</span> <span class="n">addModule</span><span class="p">(</span><span class="n">ThreadSafeModule</span> <span class="n">TSM</span><span class="p">,</span> <span class="n">ResourceTrackerSP</span> <span class="n">RT</span> <span class="o">=</span> <span class="k">nullptr</span><span class="p">)</span> <span class="p">{</span>
<span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">RT</span><span class="p">)</span>
<span class="n">RT</span> <span class="o">=</span> <span class="n">MainJD</span><span class="p">.</span><span class="n">getDefaultResourceTracker</span><span class="p">();</span>
<span class="k">return</span> <span class="n">OptimizeLayer</span><span class="p">.</span><span class="n">add</span><span class="p">(</span><span class="n">RT</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">TSM</span><span class="p">));</span>
<span class="p">}</span>
<span class="n">Expected</span><span class="o"><</span><span class="n">JITEvaluatedSymbol</span><span class="o">></span> <span class="n">lookup</span><span class="p">(</span><span class="n">StringRef</span> <span class="n">Name</span><span class="p">)</span> <span class="p">{</span>
<span class="k">return</span> <span class="n">ES</span><span class="o">-></span><span class="n">lookup</span><span class="p">({</span><span class="o">&</span><span class="n">MainJD</span><span class="p">},</span> <span class="n">Mangle</span><span class="p">(</span><span class="n">Name</span><span class="p">.</span><span class="n">str</span><span class="p">()));</span>
<span class="p">}</span>
<span class="k">private</span><span class="o">:</span>
<span class="k">static</span> <span class="n">Expected</span><span class="o"><</span><span class="n">ThreadSafeModule</span><span class="o">></span>
<span class="n">optimizeModule</span><span class="p">(</span><span class="n">ThreadSafeModule</span> <span class="n">TSM</span><span class="p">,</span> <span class="k">const</span> <span class="n">MaterializationResponsibility</span> <span class="o">&</span><span class="n">R</span><span class="p">)</span> <span class="p">{</span>
<span class="n">TSM</span><span class="p">.</span><span class="n">withModuleDo</span><span class="p">([](</span><span class="n">Module</span> <span class="o">&</span><span class="n">M</span><span class="p">)</span> <span class="p">{</span>
<span class="c1">// Create a function pass manager.</span>
<span class="k">auto</span> <span class="n">FPM</span> <span class="o">=</span> <span class="n">std</span><span class="o">::</span><span class="n">make_unique</span><span class="o"><</span><span class="n">legacy</span><span class="o">::</span><span class="n">FunctionPassManager</span><span class="o">></span><span class="p">(</span><span class="o">&</span><span class="n">M</span><span class="p">);</span>
<span class="c1">// Add some optimizations.</span>
<span class="n">FPM</span><span class="o">-></span><span class="n">add</span><span class="p">(</span><span class="n">createInstructionCombiningPass</span><span class="p">());</span>
<span class="n">FPM</span><span class="o">-></span><span class="n">add</span><span class="p">(</span><span class="n">createReassociatePass</span><span class="p">());</span>
<span class="n">FPM</span><span class="o">-></span><span class="n">add</span><span class="p">(</span><span class="n">createGVNPass</span><span class="p">());</span>
<span class="n">FPM</span><span class="o">-></span><span class="n">add</span><span class="p">(</span><span class="n">createCFGSimplificationPass</span><span class="p">());</span>
<span class="n">FPM</span><span class="o">-></span><span class="n">doInitialization</span><span class="p">();</span>
<span class="c1">// Run the optimizations over all functions in the module being added to</span>
<span class="c1">// the JIT.</span>
<span class="k">for</span> <span class="p">(</span><span class="k">auto</span> <span class="o">&</span><span class="nl">F</span> <span class="p">:</span> <span class="n">M</span><span class="p">)</span>
<span class="n">FPM</span><span class="o">-></span><span class="n">run</span><span class="p">(</span><span class="n">F</span><span class="p">);</span>
<span class="p">});</span>
<span class="k">return</span> <span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">TSM</span><span class="p">);</span>
<span class="p">}</span>
<span class="p">};</span>
<span class="p">}</span> <span class="c1">// end namespace orc</span>
<span class="p">}</span> <span class="c1">// end namespace llvm</span>
<span class="cp">#endif </span><span class="c1">// LLVM_EXECUTIONENGINE_ORC_KALEIDOSCOPEJIT_H</span>
</pre></div>
</div>
<p><a class="reference external" href="BuildingAJIT4.html">Next: Extreme Laziness – Using Compile Callbacks to JIT directly from ASTs</a></p>
</div>
</div>
<div class="clearer"></div>
</div>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related" role="navigation" aria-label="related navigation">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="BuildingAJIT4.html" title="4. Building a JIT: Extreme Laziness - Using LazyReexports to JIT from ASTs"
>next</a> |</li>
<li class="right" >
<a href="BuildingAJIT2.html" title="2. Building a JIT: Adding Optimizations – An introduction to ORC Layers"
>previous</a> |</li>
<li><a href="https://llvm.org/">LLVM Home</a> | </li>
<li><a href="../index.html">Documentation</a>»</li>
<li class="nav-item nav-item-1"><a href="../GettingStartedTutorials.html" >Getting Started/Tutorials</a> »</li>
<li class="nav-item nav-item-2"><a href="index.html" >LLVM Tutorial: Table of Contents</a> »</li>
<li class="nav-item nav-item-this"><a href=""><span class="section-number">3. </span>Building a JIT: Per-function Lazy Compilation</a></li>
</ul>
</div>
<div class="footer" role="contentinfo">
© Copyright 2003-2021, LLVM Project.
Last updated on 2021-09-18.
Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 3.5.4.
</div>
</body>
</html>
|
