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
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
|
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>2. Building a JIT: Adding Optimizations – An introduction to ORC Layers — 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="3. Building a JIT: Per-function Lazy Compilation" href="BuildingAJIT3.html" />
<link rel="prev" title="1. Building a JIT: Starting out with KaleidoscopeJIT" href="BuildingAJIT1.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="BuildingAJIT3.html" title="3. Building a JIT: Per-function Lazy Compilation"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="BuildingAJIT1.html" title="1. Building a JIT: Starting out with KaleidoscopeJIT"
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">2. </span>Building a JIT: Adding Optimizations – An introduction to ORC Layers</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/BuildingAJIT2.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-adding-optimizations-an-introduction-to-orc-layers">
<h1><span class="section-number">2. </span>Building a JIT: Adding Optimizations – An introduction to ORC Layers<a class="headerlink" href="#building-a-jit-adding-optimizations-an-introduction-to-orc-layers" 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-2-introduction" id="id2">Chapter 2 Introduction</a></p></li>
<li><p><a class="reference internal" href="#optimizing-modules-using-the-irtransformlayer" id="id3">Optimizing Modules using the IRTransformLayer</a></p></li>
<li><p><a class="reference internal" href="#full-code-listing" id="id4">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-2-introduction">
<h2><a class="toc-backref" href="#id2"><span class="section-number">2.1. </span>Chapter 2 Introduction</a><a class="headerlink" href="#chapter-2-introduction" title="Permalink to this headline">¶</a></h2>
<p><strong>Warning: This tutorial is currently being updated to account for ORC API
changes. Only Chapters 1 and 2 are up-to-date.</strong></p>
<p><strong>Example code from Chapters 3 to 5 will compile and run, but has not been
updated</strong></p>
<p>Welcome to Chapter 2 of the “Building an ORC-based JIT in LLVM” tutorial. In
<a class="reference external" href="BuildingAJIT1.html">Chapter 1</a> of this series we examined a basic JIT
class, KaleidoscopeJIT, that could take LLVM IR modules as input and produce
executable code in memory. KaleidoscopeJIT was able to do this with relatively
little code by composing two off-the-shelf <em>ORC layers</em>: IRCompileLayer and
ObjectLinkingLayer, to do much of the heavy lifting.</p>
<p>In this layer we’ll learn more about the ORC layer concept by using a new layer,
IRTransformLayer, to add IR optimization support to KaleidoscopeJIT.</p>
</div>
<div class="section" id="optimizing-modules-using-the-irtransformlayer">
<h2><a class="toc-backref" href="#id3"><span class="section-number">2.2. </span>Optimizing Modules using the IRTransformLayer</a><a class="headerlink" href="#optimizing-modules-using-the-irtransformlayer" title="Permalink to this headline">¶</a></h2>
<p>In <a class="reference external" href="LangImpl04.html">Chapter 4</a> of the “Implementing a language with LLVM”
tutorial series the llvm <em>FunctionPassManager</em> is introduced as a means for
optimizing LLVM IR. Interested readers may read that chapter for details, but
in short: to optimize a Module we create an llvm::FunctionPassManager
instance, configure it with a set of optimizations, then run the PassManager on
a Module to mutate it into a (hopefully) more optimized but semantically
equivalent form. In the original tutorial series the FunctionPassManager was
created outside the KaleidoscopeJIT and modules were optimized before being
added to it. In this Chapter we will make optimization a phase of our JIT
instead. For now this will provide us a motivation to learn more about ORC
layers, but in the long term making optimization part of our JIT will yield an
important benefit: When we begin lazily compiling code (i.e. deferring
compilation of each function until the first time it’s run) having
optimization managed by our JIT will allow us to optimize lazily too, rather
than having to do all our optimization up-front.</p>
<p>To add optimization support to our JIT we will take the KaleidoscopeJIT from
Chapter 1 and compose an ORC <em>IRTransformLayer</em> on top. We will look at how the
IRTransformLayer works in more detail below, but the interface is simple: the
constructor for this layer takes a reference to the execution session and the
layer below (as all layers do) plus an <em>IR optimization function</em> that it will
apply to each Module that is added via addModule:</p>
<div class="highlight-c++ notranslate"><div class="highlight"><pre><span></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">ExecutionSession</span> <span class="n">ES</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">TransformLayer</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">ThreadSafeContext</span> <span class="n">Ctx</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">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">ObjectLayer</span><span class="p">(</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="n">ES</span><span class="p">,</span> <span class="n">ObjectLayer</span><span class="p">,</span> <span class="n">ConcurrentIRCompiler</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">TransformLayer</span><span class="p">(</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">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="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">Ctx</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">LLVMContext</span><span class="o">></span><span class="p">())</span> <span class="p">{</span>
<span class="n">ES</span><span class="p">.</span><span class="n">getMainJITDylib</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>
</pre></div>
</div>
<p>Our extended KaleidoscopeJIT class starts out the same as it did in Chapter 1,
but after the CompileLayer we introduce a new member, TransformLayer, which sits
on top of our CompileLayer. We initialize our OptimizeLayer with a reference to
the ExecutionSession and output layer (standard practice for layers), along with
a <em>transform function</em>. For our transform function we supply our classes
optimizeModule static method.</p>
<div class="highlight-c++ notranslate"><div class="highlight"><pre><span></span><span class="c1">// ...</span>
<span class="k">return</span> <span class="nf">cantFail</span><span class="p">(</span><span class="n">OptimizeLayer</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">M</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>
</pre></div>
</div>
<p>Next we need to update our addModule method to replace the call to
<code class="docutils literal notranslate"><span class="pre">CompileLayer::add</span></code> with a call to <code class="docutils literal notranslate"><span class="pre">OptimizeLayer::add</span></code> instead.</p>
<div class="highlight-c++ notranslate"><div class="highlight"><pre><span></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">M</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="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="n">M</span><span class="p">.</span><span class="n">get</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="o">*</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="k">return</span> <span class="n">M</span><span class="p">;</span>
<span class="p">}</span>
</pre></div>
</div>
<p>At the bottom of our JIT we add a private method to do the actual optimization:
<em>optimizeModule</em>. This function takes the module to be transformed as input (as
a ThreadSafeModule) along with a reference to a reference to a new class:
<code class="docutils literal notranslate"><span class="pre">MaterializationResponsibility</span></code>. The MaterializationResponsibility argument
can be used to query JIT state for the module being transformed, such as the set
of definitions in the module that JIT’d code is actively trying to call/access.
For now we will ignore this argument and use a standard optimization
pipeline. To do this we set up a FunctionPassManager, add some passes to it, run
it over every function in the module, and then return the mutated module. The
specific optimizations are the same ones used in <a class="reference external" href="LangImpl04.html">Chapter 4</a>
of the “Implementing a language with LLVM” tutorial series. Readers may visit
that chapter for a more in-depth discussion of these, and of IR optimization in
general.</p>
<p>And that’s it in terms of changes to KaleidoscopeJIT: When a module is added via
addModule the OptimizeLayer will call our optimizeModule function before passing
the transformed module on to the CompileLayer below. Of course, we could have
called optimizeModule directly in our addModule function and not gone to the
bother of using the IRTransformLayer, but doing so gives us another opportunity
to see how layers compose. It also provides a neat entry point to the <em>layer</em>
concept itself, because IRTransformLayer is one of the simplest layers that
can be implemented.</p>
<div class="highlight-c++ notranslate"><div class="highlight"><pre><span></span><span class="c1">// From IRTransformLayer.h:</span>
<span class="k">class</span> <span class="nc">IRTransformLayer</span> <span class="o">:</span> <span class="k">public</span> <span class="n">IRLayer</span> <span class="p">{</span>
<span class="k">public</span><span class="o">:</span>
<span class="k">using</span> <span class="n">TransformFunction</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">Expected</span><span class="o"><</span><span class="n">ThreadSafeModule</span><span class="o">></span><span class="p">(</span>
<span class="n">ThreadSafeModule</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="o">></span><span class="p">;</span>
<span class="n">IRTransformLayer</span><span class="p">(</span><span class="n">ExecutionSession</span> <span class="o">&</span><span class="n">ES</span><span class="p">,</span> <span class="n">IRLayer</span> <span class="o">&</span><span class="n">BaseLayer</span><span class="p">,</span>
<span class="n">TransformFunction</span> <span class="n">Transform</span> <span class="o">=</span> <span class="n">identityTransform</span><span class="p">);</span>
<span class="kt">void</span> <span class="nf">setTransform</span><span class="p">(</span><span class="n">TransformFunction</span> <span class="n">Transform</span><span class="p">)</span> <span class="p">{</span>
<span class="k">this</span><span class="o">-></span><span class="n">Transform</span> <span class="o">=</span> <span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">Transform</span><span class="p">);</span>
<span class="p">}</span>
<span class="k">static</span> <span class="n">ThreadSafeModule</span>
<span class="n">identityTransform</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="k">return</span> <span class="n">TSM</span><span class="p">;</span>
<span class="p">}</span>
<span class="kt">void</span> <span class="n">emit</span><span class="p">(</span><span class="n">MaterializationResponsibility</span> <span class="n">R</span><span class="p">,</span> <span class="n">ThreadSafeModule</span> <span class="n">TSM</span><span class="p">)</span> <span class="k">override</span><span class="p">;</span>
<span class="k">private</span><span class="o">:</span>
<span class="n">IRLayer</span> <span class="o">&</span><span class="n">BaseLayer</span><span class="p">;</span>
<span class="n">TransformFunction</span> <span class="n">Transform</span><span class="p">;</span>
<span class="p">};</span>
<span class="c1">// From IRTransformLayer.cpp:</span>
<span class="n">IRTransformLayer</span><span class="o">::</span><span class="n">IRTransformLayer</span><span class="p">(</span><span class="n">ExecutionSession</span> <span class="o">&</span><span class="n">ES</span><span class="p">,</span>
<span class="n">IRLayer</span> <span class="o">&</span><span class="n">BaseLayer</span><span class="p">,</span>
<span class="n">TransformFunction</span> <span class="n">Transform</span><span class="p">)</span>
<span class="o">:</span> <span class="n">IRLayer</span><span class="p">(</span><span class="n">ES</span><span class="p">),</span> <span class="n">BaseLayer</span><span class="p">(</span><span class="n">BaseLayer</span><span class="p">),</span> <span class="n">Transform</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">Transform</span><span class="p">))</span> <span class="p">{}</span>
<span class="kt">void</span> <span class="n">IRTransformLayer</span><span class="o">::</span><span class="n">emit</span><span class="p">(</span><span class="n">MaterializationResponsibility</span> <span class="n">R</span><span class="p">,</span>
<span class="n">ThreadSafeModule</span> <span class="n">TSM</span><span class="p">)</span> <span class="p">{</span>
<span class="n">assert</span><span class="p">(</span><span class="n">TSM</span><span class="p">.</span><span class="n">getModule</span><span class="p">()</span> <span class="o">&&</span> <span class="s">"Module must not be null"</span><span class="p">);</span>
<span class="k">if</span> <span class="p">(</span><span class="k">auto</span> <span class="n">TransformedTSM</span> <span class="o">=</span> <span class="n">Transform</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="n">R</span><span class="p">))</span>
<span class="n">BaseLayer</span><span class="p">.</span><span class="n">emit</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">R</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">TransformedTSM</span><span class="p">));</span>
<span class="k">else</span> <span class="p">{</span>
<span class="n">R</span><span class="p">.</span><span class="n">failMaterialization</span><span class="p">();</span>
<span class="n">getExecutionSession</span><span class="p">().</span><span class="n">reportError</span><span class="p">(</span><span class="n">TransformedTSM</span><span class="p">.</span><span class="n">takeError</span><span class="p">());</span>
<span class="p">}</span>
<span class="p">}</span>
</pre></div>
</div>
<p>This is the whole definition of IRTransformLayer, from
<code class="docutils literal notranslate"><span class="pre">llvm/include/llvm/ExecutionEngine/Orc/IRTransformLayer.h</span></code> and
<code class="docutils literal notranslate"><span class="pre">llvm/lib/ExecutionEngine/Orc/IRTransformLayer.cpp</span></code>. This class is concerned
with two very simple jobs: (1) Running every IR Module that is emitted via this
layer through the transform function object, and (2) implementing the ORC
<code class="docutils literal notranslate"><span class="pre">IRLayer</span></code> interface (which itself conforms to the general ORC Layer concept,
more on that below). Most of the class is straightforward: a typedef for the
transform function, a constructor to initialize the members, a setter for the
transform function value, and a default no-op transform. The most important
method is <code class="docutils literal notranslate"><span class="pre">emit</span></code> as this is half of our IRLayer interface. The emit method
applies our transform to each module that it is called on and, if the transform
succeeds, passes the transformed module to the base layer. If the transform
fails, our emit function calls
<code class="docutils literal notranslate"><span class="pre">MaterializationResponsibility::failMaterialization</span></code> (this JIT clients who
may be waiting on other threads know that the code they were waiting for has
failed to compile) and logs the error with the execution session before bailing
out.</p>
<p>The other half of the IRLayer interface we inherit unmodified from the IRLayer
class:</p>
<div class="highlight-c++ notranslate"><div class="highlight"><pre><span></span><span class="n">Error</span> <span class="n">IRLayer</span><span class="o">::</span><span class="n">add</span><span class="p">(</span><span class="n">JITDylib</span> <span class="o">&</span><span class="n">JD</span><span class="p">,</span> <span class="n">ThreadSafeModule</span> <span class="n">TSM</span><span class="p">,</span> <span class="n">VModuleKey</span> <span class="n">K</span><span class="p">)</span> <span class="p">{</span>
<span class="k">return</span> <span class="n">JD</span><span class="p">.</span><span class="n">define</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">BasicIRLayerMaterializationUnit</span><span class="o">></span><span class="p">(</span>
<span class="o">*</span><span class="k">this</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">K</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>
</pre></div>
</div>
<p>This code, from <code class="docutils literal notranslate"><span class="pre">llvm/lib/ExecutionEngine/Orc/Layer.cpp</span></code>, adds a
ThreadSafeModule to a given JITDylib by wrapping it up in a
<code class="docutils literal notranslate"><span class="pre">MaterializationUnit</span></code> (in this case a <code class="docutils literal notranslate"><span class="pre">BasicIRLayerMaterializationUnit</span></code>).
Most layers that derived from IRLayer can rely on this default implementation
of the <code class="docutils literal notranslate"><span class="pre">add</span></code> method.</p>
<p>These two operations, <code class="docutils literal notranslate"><span class="pre">add</span></code> and <code class="docutils literal notranslate"><span class="pre">emit</span></code>, together constitute the layer
concept: A layer is a way to wrap a part of a compiler pipeline (in this case
the “opt” phase of an LLVM compiler) whose API is opaque to ORC with an
interface that ORC can call as needed. The add method takes an
module in some input program representation (in this case an LLVM IR module)
and stores it in the target <code class="docutils literal notranslate"><span class="pre">JITDylib</span></code>, arranging for it to be passed back
to the layer’s emit method when any symbol defined by that module is requested.
Each layer can complete its own work by calling the <code class="docutils literal notranslate"><span class="pre">emit</span></code> method of its base
layer. For example, in this tutorial our IRTransformLayer calls through to
our IRCompileLayer to compile the transformed IR, and our IRCompileLayer in
turn calls our ObjectLayer to link the object file produced by our compiler.</p>
<p>So far we have learned how to optimize and compile our LLVM IR, but we have
not focused on when compilation happens. Our current REPL optimizes and
compiles each function as soon as it is referenced by any other code,
regardless of whether it is ever called at runtime. In the next chapter we
will introduce a fully lazy compilation, in which functions are not compiled
until they are first called at run-time. At this point the trade-offs get much
more interesting: the lazier we are, the quicker we can start executing the
first function, but the more often we will have to pause to compile newly
encountered functions. If we only code-gen lazily, but optimize eagerly, we
will have a longer startup time (as everything is optimized at that time) but
relatively short pauses as each function just passes through code-gen. If we
both optimize and code-gen lazily we can start executing the first function
more quickly, but we will have longer pauses as each function has to be both
optimized and code-gen’d when it is first executed. Things become even more
interesting if we consider interprocedural optimizations like inlining, which
must be performed eagerly. These are complex trade-offs, and there is no
one-size-fits all solution to them, but by providing composable layers we leave
the decisions to the person implementing the JIT, and make it easy for them to
experiment with different configurations.</p>
<p><a class="reference external" href="BuildingAJIT3.html">Next: Adding Per-function Lazy Compilation</a></p>
</div>
<div class="section" id="full-code-listing">
<h2><a class="toc-backref" href="#id4"><span class="section-number">2.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 an
IRTransformLayer added to enable optimization. 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/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/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">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">JITDylib</span> <span class="o">&</span><span class="n">MainJD</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">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">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">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="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="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="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>
</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="BuildingAJIT3.html" title="3. Building a JIT: Per-function Lazy Compilation"
>next</a> |</li>
<li class="right" >
<a href="BuildingAJIT1.html" title="1. Building a JIT: Starting out with KaleidoscopeJIT"
>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">2. </span>Building a JIT: Adding Optimizations – An introduction to ORC Layers</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>
|
