[www-releases] r257950 - Add 3.7.1 docs
Tom Stellard via llvm-commits
llvm-commits at lists.llvm.org
Fri Jan 15 15:13:20 PST 2016
Added: www-releases/trunk/3.7.1/docs/genindex.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/3.7.1/docs/genindex.html?rev=257950&view=auto
==============================================================================
--- www-releases/trunk/3.7.1/docs/genindex.html (added)
+++ www-releases/trunk/3.7.1/docs/genindex.html Fri Jan 15 17:13:16 2016
@@ -0,0 +1,2582 @@
+
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+ <title>Index — LLVM 3.7 documentation</title>
+
+ <link rel="stylesheet" href="_static/llvm-theme.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: './',
+ VERSION: '3.7',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true
+ };
+ </script>
+ <script type="text/javascript" src="_static/jquery.js"></script>
+ <script type="text/javascript" src="_static/underscore.js"></script>
+ <script type="text/javascript" src="_static/doctools.js"></script>
+ <link rel="top" title="LLVM 3.7 documentation" href="index.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">
+ <h3>Navigation</h3>
+ <ul>
+ <li class="right" style="margin-right: 10px">
+ <a href="#" title="General Index"
+ accesskey="I">index</a></li>
+ <li><a href="http://llvm.org/">LLVM Home</a> | </li>
+ <li><a href="index.html">Documentation</a>»</li>
+
+ </ul>
+ </div>
+
+
+ <div class="document">
+ <div class="documentwrapper">
+ <div class="body">
+
+
+<h1 id="index">Index</h1>
+
+<div class="genindex-jumpbox">
+ <a href="#Symbols"><strong>Symbols</strong></a>
+ | <a href="#C"><strong>C</strong></a>
+ | <a href="#L"><strong>L</strong></a>
+ | <a href="#T"><strong>T</strong></a>
+
+</div>
+<h2 id="Symbols">Symbols</h2>
+<table style="width: 100%" class="indextable genindextable"><tr>
+ <td style="width: 33%" valign="top"><dl>
+
+ <dt>
+ --check-prefix prefix
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/FileCheck.html#cmdoption--check-prefix">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --config-prefix=NAME
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--config-prefix">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --debug
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--debug">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --debug-syms, -a
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm--debug-syms">llvm-nm command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --defined-only
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm--defined-only">llvm-nm command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --disable-excess-fp-precision
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llc.html#cmdoption--disable-excess-fp-precision">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --disable-fp-elim
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llc.html#cmdoption--disable-fp-elim">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --dynamic, -D
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm--dynamic">llvm-nm command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --enable-no-infs-fp-math
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llc.html#cmdoption--enable-no-infs-fp-math">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --enable-no-nans-fp-math
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llc.html#cmdoption--enable-no-nans-fp-math">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --enable-unsafe-fp-math
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llc.html#cmdoption--enable-unsafe-fp-math">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --extern-only, -g
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm--extern-only">llvm-nm command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --format=format, -f format
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm--format">llvm-nm command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --help
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-gcov--help">llvm-cov-gcov command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --implicit-check-not check-pattern
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/FileCheck.html#cmdoption--implicit-check-not">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --input-file filename
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/FileCheck.html#cmdoption--input-file">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --load=<dso_path>
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llc.html#cmdoption--load">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --max-tests=N
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--max-tests">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --max-time=N
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--max-time">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --no-progress-bar
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--no-progress-bar">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --no-sort, -p
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm--no-sort">llvm-nm command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --numeric-sort, -n, -v
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm--numeric-sort">llvm-nm command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --path=PATH
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--path">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --print-file-name, -A, -o
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm--print-file-name">llvm-nm command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --print-machineinstrs
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llc.html#cmdoption--print-machineinstrs">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --print-size, -S
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm--print-size">llvm-nm command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --regalloc=<allocator>
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llc.html#cmdoption--regalloc">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --show-suites
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--show-suites">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --show-tests
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--show-tests">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --show-unsupported
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--show-unsupported">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --show-xfail
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--show-xfail">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --shuffle
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--shuffle">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --size-sort
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm--size-sort">llvm-nm command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --spiller=<spiller>
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llc.html#cmdoption--spiller">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --stats
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llc.html#cmdoption--stats">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --strict-whitespace
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/FileCheck.html#cmdoption--strict-whitespace">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --time-passes
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llc.html#cmdoption--time-passes">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --time-tests
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--time-tests">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --undefined-only, -u
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm--undefined-only">llvm-nm command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --vg
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--vg">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --vg-arg=ARG
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--vg-arg">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --vg-leak
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--vg-leak">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ --x86-asm-syntax=[att|intel]
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llc.html#cmdoption--x86-asm-syntax">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -a, --all-blocks
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-gcov-a">llvm-cov-gcov command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -all-functions
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-show-all-functions">llvm-profdata-show command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -arch=<name>
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-report-arch">llvm-cov-report command line option</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-arch">llvm-cov-show command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -asmparsernum N
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-asmparsernum">tblgen command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -asmwriternum N
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-asmwriternum">tblgen command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -B (default)
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm-B">llvm-nm command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -b, --branch-probabilities
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-gcov-b">llvm-cov-gcov command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -binary (default)
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-merge-binary">llvm-profdata-merge command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -c, --branch-counts
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-gcov-c">llvm-cov-gcov command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -class className
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-class">tblgen command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -counts
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-show-counts">llvm-profdata-show command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -d
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-link.html#cmdoption-d">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -D NAME, -D NAME=VALUE, --param NAME, --param NAME=VALUE
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/lit.html#cmdoption-D">command line option</a>, <a href="CommandGuide/lit.html#cmdoption-D">[1]</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -debug
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/opt.html#cmdoption-debug">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -debug-dump=section
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-dwarfdump.html#cmdoption-debug-dump">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -default-arch
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-symbolizer.html#cmdoption-default-arch">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -demangle
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-symbolizer.html#cmdoption-demangle">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -disable-inlining
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/opt.html#cmdoption-disable-inlining">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -disable-opt
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/opt.html#cmdoption-disable-opt">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -dsym-hint=<path/to/file.dSYM>
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-symbolizer.html#cmdoption-dsym-hint">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -dump
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-bcanalyzer.html#cmdoption-llvm-bcanalyzer-dump">llvm-bcanalyzer command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -dyn-symbols
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-readobj.html#cmdoption-dyn-symbols">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -dynamic-table
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-readobj.html#cmdoption-dynamic-table">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -expand-relocs
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-readobj.html#cmdoption-expand-relocs">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -f
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/opt.html#cmdoption-f">command line option</a>, <a href="CommandGuide/llvm-link.html#cmdoption-f">[1]</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -f, --function-summaries
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-gcov-f">llvm-cov-gcov command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -file-headers, -h
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-readobj.html#cmdoption-file-headers">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -filetype=<output file type>
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llc.html#cmdoption-filetype">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -function=string
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-show-function">llvm-profdata-show command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -functions=[none|short|linkage]
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-symbolizer.html#cmdoption-functions">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -gcc
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-merge-gcc">llvm-profdata-merge command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -gen-asm-matcher
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-asm-matcher">tblgen command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -gen-asm-writer
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-asm-writer">tblgen command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -gen-dag-isel
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-dag-isel">tblgen command line option</a>
+ </dt>
+
+ </dl></dd>
+ </dl></td>
+ <td style="width: 33%" valign="top"><dl>
+
+ <dt>
+ -gen-dfa-packetizer
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-dfa-packetizer">tblgen command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -gen-disassembler
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-disassembler">tblgen command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -gen-emitter
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-emitter">tblgen command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -gen-enhanced-disassembly-info
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-enhanced-disassembly-info">tblgen command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -gen-fast-isel
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-fast-isel">tblgen command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -gen-instr-info
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-instr-info">tblgen command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -gen-intrinsic
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-intrinsic">tblgen command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -gen-pseudo-lowering
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-pseudo-lowering">tblgen command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -gen-register-info
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-register-info">tblgen command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -gen-subtarget
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-subtarget">tblgen command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -gen-tgt-intrinsic
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-tgt-intrinsic">tblgen command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -h, --help
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/lit.html#cmdoption-h">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -help
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/FileCheck.html#cmdoption-help">command line option</a>, <a href="CommandGuide/llvm-readobj.html#cmdoption-help">[1]</a>, <a href="CommandGuide/opt.html#cmdoption-help">[2]</a>, <a href="CommandGuide/llc.html#cmdoption-help">[3]</a>, <a href="CommandGuide/llvm-link.html#cmdoption-help">[4]</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-bcanalyzer.html#cmdoption-llvm-bcanalyzer-help">llvm-bcanalyzer command line option</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm-help">llvm-nm command line option</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-merge-help">llvm-profdata-merge command line option</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-show-help">llvm-profdata-show command line option</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-help">tblgen command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -I directory
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-I">tblgen command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -inlining
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-symbolizer.html#cmdoption-inlining">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -instr (default)
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-merge-instr">llvm-profdata-merge command line option</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-show-instr">llvm-profdata-show command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -j N, --threads=N
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/lit.html#cmdoption-j">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -l, --long-file-names
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-gcov-l">llvm-cov-gcov command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -line-coverage-gt=<N>
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-line-coverage-gt">llvm-cov-show command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -line-coverage-lt=<N>
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-line-coverage-lt">llvm-cov-show command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -load=<plugin>
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/opt.html#cmdoption-load">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -march=<arch>
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llc.html#cmdoption-march">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -mattr=a1,+a2,-a3,...
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llc.html#cmdoption-mattr">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -mcpu=<cpuname>
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llc.html#cmdoption-mcpu">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -mtriple=<target triple>
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llc.html#cmdoption-mtriple">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -n, --no-output
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-gcov-n">llvm-cov-gcov command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -name-regex=<PATTERN>
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-name-regex">llvm-cov-show command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -name=<NAME>
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-name">llvm-cov-show command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -needed-libs
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-readobj.html#cmdoption-needed-libs">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -nodetails
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-bcanalyzer.html#cmdoption-llvm-bcanalyzer-nodetails">llvm-bcanalyzer command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -o <filename>
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/opt.html#cmdoption-o">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -o filename
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-stress.html#cmdoption-o">command line option</a>, <a href="CommandGuide/llvm-link.html#cmdoption-o">[1]</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-o">tblgen command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -o=<DIR|FILE>, --object-directory=<DIR>, --object-file=<FILE>
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-gcov-o">llvm-cov-gcov command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -O=uint
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llc.html#cmdoption-O">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -obj
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-symbolizer.html#cmdoption-obj">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -output=output, -o=output
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-merge-output">llvm-profdata-merge command line option</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-show-output">llvm-profdata-show command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -P
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm-P">llvm-nm command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -p
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/opt.html#cmdoption-p">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -p, --preserve-paths
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-gcov-p">llvm-cov-gcov command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -print-enums
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-print-enums">tblgen command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -print-records
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-print-records">tblgen command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -print-sets
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-print-sets">tblgen command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -program-headers
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-readobj.html#cmdoption-program-headers">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -q, --quiet
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/lit.html#cmdoption-q">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -region-coverage-gt=<N>
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-region-coverage-gt">llvm-cov-show command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -region-coverage-lt=<N>
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-region-coverage-lt">llvm-cov-show command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -relocations, -r
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-readobj.html#cmdoption-relocations">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -S
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/opt.html#cmdoption-S">command line option</a>, <a href="CommandGuide/llvm-link.html#cmdoption-S">[1]</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -s, --succinct
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/lit.html#cmdoption-s">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -sample
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-merge-sample">llvm-profdata-merge command line option</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-show-sample">llvm-profdata-show command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -section-data, -sd
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-readobj.html#cmdoption-section-data">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -section-relocations, -sr
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-readobj.html#cmdoption-section-relocations">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -section-symbols, -st
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-readobj.html#cmdoption-section-symbols">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -sections, -s
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-readobj.html#cmdoption-sections">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -seed seed
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-stress.html#cmdoption-seed">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -show-expansions
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-show-expansions">llvm-cov-show command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -show-instantiations
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-show-instantiations">llvm-cov-show command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -show-line-counts
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-show-line-counts">llvm-cov-show command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -show-line-counts-or-regions
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-show-line-counts-or-regions">llvm-cov-show command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -show-regions
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-show-regions">llvm-cov-show command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -size size
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-stress.html#cmdoption-size">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -stats
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/opt.html#cmdoption-stats">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -strip-debug
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/opt.html#cmdoption-strip-debug">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -symbols, -t
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-readobj.html#cmdoption-symbols">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -text
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-merge-text">llvm-profdata-merge command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -time-passes
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/opt.html#cmdoption-time-passes">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -u, --unconditional-branches
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-gcov-u">llvm-cov-gcov command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -unwind, -u
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-readobj.html#cmdoption-unwind">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -use-color[=VALUE]
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-report-use-color">llvm-cov-report command line option</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-use-color">llvm-cov-show command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -use-symbol-table
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-symbolizer.html#cmdoption-use-symbol-table">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -v
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-link.html#cmdoption-v">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -v, --verbose
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/lit.html#cmdoption-v">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -verify
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-bcanalyzer.html#cmdoption-llvm-bcanalyzer-verify">llvm-bcanalyzer command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -verify-each
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/opt.html#cmdoption-verify-each">command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -version
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/FileCheck.html#cmdoption-version">command line option</a>, <a href="CommandGuide/llvm-readobj.html#cmdoption-version">[1]</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-gcov-version">llvm-cov-gcov command line option</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-version">tblgen command line option</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ -{passname}
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/opt.html#cmdoption-">command line option</a>
+ </dt>
+
+ </dl></dd>
+ </dl></td>
+</tr></table>
+
+<h2 id="C">C</h2>
+<table style="width: 100%" class="indextable genindextable"><tr>
+ <td style="width: 33%" valign="top"><dl>
+
+ <dt>
+ command line option
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/FileCheck.html#cmdoption--check-prefix">--check-prefix prefix</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--config-prefix">--config-prefix=NAME</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--debug">--debug</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llc.html#cmdoption--disable-excess-fp-precision">--disable-excess-fp-precision</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llc.html#cmdoption--disable-fp-elim">--disable-fp-elim</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llc.html#cmdoption--enable-no-infs-fp-math">--enable-no-infs-fp-math</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llc.html#cmdoption--enable-no-nans-fp-math">--enable-no-nans-fp-math</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llc.html#cmdoption--enable-unsafe-fp-math">--enable-unsafe-fp-math</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/FileCheck.html#cmdoption--implicit-check-not">--implicit-check-not check-pattern</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/FileCheck.html#cmdoption--input-file">--input-file filename</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llc.html#cmdoption--load">--load=<dso_path></a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--max-tests">--max-tests=N</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--max-time">--max-time=N</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--no-progress-bar">--no-progress-bar</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--path">--path=PATH</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llc.html#cmdoption--print-machineinstrs">--print-machineinstrs</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llc.html#cmdoption--regalloc">--regalloc=<allocator></a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--show-suites">--show-suites</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--show-tests">--show-tests</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--show-unsupported">--show-unsupported</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--show-xfail">--show-xfail</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--shuffle">--shuffle</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llc.html#cmdoption--spiller">--spiller=<spiller></a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llc.html#cmdoption--stats">--stats</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/FileCheck.html#cmdoption--strict-whitespace">--strict-whitespace</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llc.html#cmdoption--time-passes">--time-passes</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--time-tests">--time-tests</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--vg">--vg</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--vg-arg">--vg-arg=ARG</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/lit.html#cmdoption--vg-leak">--vg-leak</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llc.html#cmdoption--x86-asm-syntax">--x86-asm-syntax=[att|intel]</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/lit.html#cmdoption-D">-D NAME, -D NAME=VALUE, --param NAME, --param NAME=VALUE</a>, <a href="CommandGuide/lit.html#cmdoption-D">[1]</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llc.html#cmdoption-O">-O=uint</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/opt.html#cmdoption-S">-S</a>, <a href="CommandGuide/llvm-link.html#cmdoption-S">[1]</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-link.html#cmdoption-d">-d</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/opt.html#cmdoption-debug">-debug</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-dwarfdump.html#cmdoption-debug-dump">-debug-dump=section</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-symbolizer.html#cmdoption-default-arch">-default-arch</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-symbolizer.html#cmdoption-demangle">-demangle</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/opt.html#cmdoption-disable-inlining">-disable-inlining</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/opt.html#cmdoption-disable-opt">-disable-opt</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-symbolizer.html#cmdoption-dsym-hint">-dsym-hint=<path/to/file.dSYM></a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-readobj.html#cmdoption-dyn-symbols">-dyn-symbols</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-readobj.html#cmdoption-dynamic-table">-dynamic-table</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-readobj.html#cmdoption-expand-relocs">-expand-relocs</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/opt.html#cmdoption-f">-f</a>, <a href="CommandGuide/llvm-link.html#cmdoption-f">[1]</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-readobj.html#cmdoption-file-headers">-file-headers, -h</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llc.html#cmdoption-filetype">-filetype=<output file type></a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-symbolizer.html#cmdoption-functions">-functions=[none|short|linkage]</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/lit.html#cmdoption-h">-h, --help</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/FileCheck.html#cmdoption-help">-help</a>, <a href="CommandGuide/llvm-readobj.html#cmdoption-help">[1]</a>, <a href="CommandGuide/opt.html#cmdoption-help">[2]</a>, <a href="CommandGuide/llc.html#cmdoption-help">[3]</a>, <a href="CommandGuide/llvm-link.html#cmdoption-help">[4]</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-symbolizer.html#cmdoption-inlining">-inlining</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/lit.html#cmdoption-j">-j N, --threads=N</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/opt.html#cmdoption-load">-load=<plugin></a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llc.html#cmdoption-march">-march=<arch></a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llc.html#cmdoption-mattr">-mattr=a1,+a2,-a3,...</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llc.html#cmdoption-mcpu">-mcpu=<cpuname></a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llc.html#cmdoption-mtriple">-mtriple=<target triple></a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-readobj.html#cmdoption-needed-libs">-needed-libs</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/opt.html#cmdoption-o">-o <filename></a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-stress.html#cmdoption-o">-o filename</a>, <a href="CommandGuide/llvm-link.html#cmdoption-o">[1]</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-symbolizer.html#cmdoption-obj">-obj</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/opt.html#cmdoption-p">-p</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-readobj.html#cmdoption-program-headers">-program-headers</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/lit.html#cmdoption-q">-q, --quiet</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-readobj.html#cmdoption-relocations">-relocations, -r</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/lit.html#cmdoption-s">-s, --succinct</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-readobj.html#cmdoption-section-data">-section-data, -sd</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-readobj.html#cmdoption-section-relocations">-section-relocations, -sr</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-readobj.html#cmdoption-section-symbols">-section-symbols, -st</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-readobj.html#cmdoption-sections">-sections, -s</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-stress.html#cmdoption-seed">-seed seed</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-stress.html#cmdoption-size">-size size</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/opt.html#cmdoption-stats">-stats</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/opt.html#cmdoption-strip-debug">-strip-debug</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-readobj.html#cmdoption-symbols">-symbols, -t</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/opt.html#cmdoption-time-passes">-time-passes</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-readobj.html#cmdoption-unwind">-unwind, -u</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-symbolizer.html#cmdoption-use-symbol-table">-use-symbol-table</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-link.html#cmdoption-v">-v</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/lit.html#cmdoption-v">-v, --verbose</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/opt.html#cmdoption-verify-each">-verify-each</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/FileCheck.html#cmdoption-version">-version</a>, <a href="CommandGuide/llvm-readobj.html#cmdoption-version">[1]</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/opt.html#cmdoption-">-{passname}</a>
+ </dt>
+
+ </dl></dd>
+ </dl></td>
+</tr></table>
+
+<h2 id="L">L</h2>
+<table style="width: 100%" class="indextable genindextable"><tr>
+ <td style="width: 33%" valign="top"><dl>
+
+ <dt>
+ llvm-bcanalyzer command line option
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-bcanalyzer.html#cmdoption-llvm-bcanalyzer-dump">-dump</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-bcanalyzer.html#cmdoption-llvm-bcanalyzer-help">-help</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-bcanalyzer.html#cmdoption-llvm-bcanalyzer-nodetails">-nodetails</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-bcanalyzer.html#cmdoption-llvm-bcanalyzer-verify">-verify</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ llvm-cov-gcov command line option
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-gcov--help">--help</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-gcov-a">-a, --all-blocks</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-gcov-b">-b, --branch-probabilities</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-gcov-c">-c, --branch-counts</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-gcov-f">-f, --function-summaries</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-gcov-l">-l, --long-file-names</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-gcov-n">-n, --no-output</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-gcov-o">-o=<DIR|FILE>, --object-directory=<DIR>, --object-file=<FILE></a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-gcov-p">-p, --preserve-paths</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-gcov-u">-u, --unconditional-branches</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-gcov-version">-version</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ llvm-cov-report command line option
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-report-arch">-arch=<name></a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-report-use-color">-use-color[=VALUE]</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ llvm-cov-show command line option
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-arch">-arch=<name></a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-line-coverage-gt">-line-coverage-gt=<N></a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-line-coverage-lt">-line-coverage-lt=<N></a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-name-regex">-name-regex=<PATTERN></a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-name">-name=<NAME></a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-region-coverage-gt">-region-coverage-gt=<N></a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-region-coverage-lt">-region-coverage-lt=<N></a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-show-expansions">-show-expansions</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-show-instantiations">-show-instantiations</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-show-line-counts">-show-line-counts</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-show-line-counts-or-regions">-show-line-counts-or-regions</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-show-regions">-show-regions</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-use-color">-use-color[=VALUE]</a>
+ </dt>
+
+ </dl></dd>
+ </dl></td>
+ <td style="width: 33%" valign="top"><dl>
+
+ <dt>
+ llvm-nm command line option
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm--debug-syms">--debug-syms, -a</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm--defined-only">--defined-only</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm--dynamic">--dynamic, -D</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm--extern-only">--extern-only, -g</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm--format">--format=format, -f format</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm--no-sort">--no-sort, -p</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm--numeric-sort">--numeric-sort, -n, -v</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm--print-file-name">--print-file-name, -A, -o</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm--print-size">--print-size, -S</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm--size-sort">--size-sort</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm--undefined-only">--undefined-only, -u</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm-B">-B (default)</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm-P">-P</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-nm.html#cmdoption-llvm-nm-help">-help</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ llvm-profdata-merge command line option
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-merge-binary">-binary (default)</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-merge-gcc">-gcc</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-merge-help">-help</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-merge-instr">-instr (default)</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-merge-output">-output=output, -o=output</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-merge-sample">-sample</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-merge-text">-text</a>
+ </dt>
+
+ </dl></dd>
+
+ <dt>
+ llvm-profdata-show command line option
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-show-all-functions">-all-functions</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-show-counts">-counts</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-show-function">-function=string</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-show-help">-help</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-show-instr">-instr (default)</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-show-output">-output=output, -o=output</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-show-sample">-sample</a>
+ </dt>
+
+ </dl></dd>
+ </dl></td>
+</tr></table>
+
+<h2 id="T">T</h2>
+<table style="width: 100%" class="indextable genindextable"><tr>
+ <td style="width: 33%" valign="top"><dl>
+
+ <dt>
+ tblgen command line option
+ </dt>
+
+ <dd><dl>
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-I">-I directory</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-asmparsernum">-asmparsernum N</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-asmwriternum">-asmwriternum N</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-class">-class className</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-asm-matcher">-gen-asm-matcher</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-asm-writer">-gen-asm-writer</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-dag-isel">-gen-dag-isel</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-dfa-packetizer">-gen-dfa-packetizer</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-disassembler">-gen-disassembler</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-emitter">-gen-emitter</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-enhanced-disassembly-info">-gen-enhanced-disassembly-info</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-fast-isel">-gen-fast-isel</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-instr-info">-gen-instr-info</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-intrinsic">-gen-intrinsic</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-pseudo-lowering">-gen-pseudo-lowering</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-register-info">-gen-register-info</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-subtarget">-gen-subtarget</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-gen-tgt-intrinsic">-gen-tgt-intrinsic</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-help">-help</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-o">-o filename</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-print-enums">-print-enums</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-print-records">-print-records</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-print-sets">-print-sets</a>
+ </dt>
+
+
+ <dt><a href="CommandGuide/tblgen.html#cmdoption-tblgen-version">-version</a>
+ </dt>
+
+ </dl></dd>
+ </dl></td>
+</tr></table>
+
+
+
+ </div>
+ </div>
+ <div class="clearer"></div>
+ </div>
+ <div class="related">
+ <h3>Navigation</h3>
+ <ul>
+ <li class="right" style="margin-right: 10px">
+ <a href="#" title="General Index"
+ >index</a></li>
+ <li><a href="http://llvm.org/">LLVM Home</a> | </li>
+ <li><a href="index.html">Documentation</a>»</li>
+
+ </ul>
+ </div>
+ <div class="footer">
+ © Copyright 2003-2016, LLVM Project.
+ Last updated on 2016-01-04.
+ Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.2.3.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/3.7.1/docs/index.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/3.7.1/docs/index.html?rev=257950&view=auto
==============================================================================
--- www-releases/trunk/3.7.1/docs/index.html (added)
+++ www-releases/trunk/3.7.1/docs/index.html Fri Jan 15 17:13:16 2016
@@ -0,0 +1,389 @@
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+ <title>Overview — LLVM 3.7 documentation</title>
+
+ <link rel="stylesheet" href="_static/llvm-theme.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: './',
+ VERSION: '3.7',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true
+ };
+ </script>
+ <script type="text/javascript" src="_static/jquery.js"></script>
+ <script type="text/javascript" src="_static/underscore.js"></script>
+ <script type="text/javascript" src="_static/doctools.js"></script>
+ <link rel="top" title="LLVM 3.7 documentation" href="#" />
+ <link rel="next" title="LLVM Language Reference Manual" href="LangRef.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="#">
+ <img src="_static/logo.png"
+ alt="LLVM Logo" width="250" height="88"/></a>
+</div>
+
+ <div class="related">
+ <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="LangRef.html" title="LLVM Language Reference Manual"
+ accesskey="N">next</a> |</li>
+ <li><a href="http://llvm.org/">LLVM Home</a> | </li>
+ <li><a href="#">Documentation</a>»</li>
+
+ </ul>
+ </div>
+
+
+ <div class="document">
+ <div class="documentwrapper">
+ <div class="body">
+
+ <div class="section" id="overview">
+<h1>Overview<a class="headerlink" href="#overview" title="Permalink to this headline">¶</a></h1>
+<p>The LLVM compiler infrastructure supports a wide range of projects, from
+industrial strength compilers to specialized JIT applications to small
+research projects.</p>
+<p>Similarly, documentation is broken down into several high-level groupings
+targeted at different audiences:</p>
+</div>
+<div class="section" id="llvm-design-overview">
+<h1>LLVM Design & Overview<a class="headerlink" href="#llvm-design-overview" title="Permalink to this headline">¶</a></h1>
+<p>Several introductory papers and presentations.</p>
+<div class="toctree-wrapper compound">
+</div>
+<dl class="docutils">
+<dt><a class="reference internal" href="LangRef.html"><em>LLVM Language Reference Manual</em></a></dt>
+<dd>Defines the LLVM intermediate representation.</dd>
+<dt><a class="reference external" href="http://llvm.org/pubs/2008-10-04-ACAT-LLVM-Intro.html">Introduction to the LLVM Compiler</a></dt>
+<dd>Presentation providing a users introduction to LLVM.</dd>
+<dt><a class="reference external" href="http://www.aosabook.org/en/llvm.html">Intro to LLVM</a></dt>
+<dd>Book chapter providing a compiler hacker’s introduction to LLVM.</dd>
+<dt><a class="reference external" href="http://llvm.org/pubs/2004-01-30-CGO-LLVM.html">LLVM: A Compilation Framework for Lifelong Program Analysis & Transformation</a></dt>
+<dd>Design overview.</dd>
+<dt><a class="reference external" href="http://llvm.org/pubs/2002-12-LattnerMSThesis.html">LLVM: An Infrastructure for Multi-Stage Optimization</a></dt>
+<dd>More details (quite old now).</dd>
+<dt><a class="reference external" href="http://llvm.org/pubs">Publications mentioning LLVM</a></dt>
+<dd></dd>
+</dl>
+</div>
+<div class="section" id="user-guides">
+<h1>User Guides<a class="headerlink" href="#user-guides" title="Permalink to this headline">¶</a></h1>
+<p>For those new to the LLVM system.</p>
+<p>NOTE: If you are a user who is only interested in using LLVM-based
+compilers, you should look into <a class="reference external" href="http://clang.llvm.org">Clang</a> or
+<a class="reference external" href="http://dragonegg.llvm.org">DragonEgg</a> instead. The documentation here is
+intended for users who have a need to work with the intermediate LLVM
+representation.</p>
+<div class="toctree-wrapper compound">
+</div>
+<dl class="docutils">
+<dt><a class="reference internal" href="GettingStarted.html"><em>Getting Started with the LLVM System</em></a></dt>
+<dd>Discusses how to get up and running quickly with the LLVM infrastructure.
+Everything from unpacking and compilation of the distribution to execution
+of some tools.</dd>
+<dt><a class="reference internal" href="CMake.html"><em>Building LLVM with CMake</em></a></dt>
+<dd>An addendum to the main Getting Started guide for those using the <a class="reference external" href="http://www.cmake.org">CMake
+build system</a>.</dd>
+<dt><a class="reference internal" href="HowToBuildOnARM.html"><em>How To Build On ARM</em></a></dt>
+<dd>Notes on building and testing LLVM/Clang on ARM.</dd>
+<dt><a class="reference internal" href="HowToCrossCompileLLVM.html"><em>How To Cross-Compile Clang/LLVM using Clang/LLVM</em></a></dt>
+<dd>Notes on cross-building and testing LLVM/Clang.</dd>
+<dt><a class="reference internal" href="GettingStartedVS.html"><em>Getting Started with the LLVM System using Microsoft Visual Studio</em></a></dt>
+<dd>An addendum to the main Getting Started guide for those using Visual Studio
+on Windows.</dd>
+<dt><a class="reference internal" href="BuildingLLVMWithAutotools.html"><em>Building LLVM With Autotools</em></a></dt>
+<dd>An addendum to the Getting Started guide with instructions for building LLVM
+with the Autotools build system.</dd>
+<dt><a class="reference internal" href="tutorial/index.html"><em>LLVM Tutorial: Table of Contents</em></a></dt>
+<dd>Tutorials about using LLVM. Includes a tutorial about making a custom
+language with LLVM.</dd>
+<dt><a class="reference internal" href="CommandGuide/index.html"><em>LLVM Command Guide</em></a></dt>
+<dd>A reference manual for the LLVM command line utilities (“man” pages for LLVM
+tools).</dd>
+<dt><a class="reference internal" href="Passes.html"><em>LLVM’s Analysis and Transform Passes</em></a></dt>
+<dd>A list of optimizations and analyses implemented in LLVM.</dd>
+<dt><a class="reference internal" href="FAQ.html"><em>Frequently Asked Questions (FAQ)</em></a></dt>
+<dd>A list of common questions and problems and their solutions.</dd>
+<dt><a class="reference internal" href="ReleaseNotes.html"><em>Release notes for the current release</em></a></dt>
+<dd>This describes new features, known bugs, and other limitations.</dd>
+<dt><a class="reference internal" href="HowToSubmitABug.html"><em>How to submit an LLVM bug report</em></a></dt>
+<dd>Instructions for properly submitting information about any bugs you run into
+in the LLVM system.</dd>
+<dt><a class="reference internal" href="SphinxQuickstartTemplate.html"><em>Sphinx Quickstart Template</em></a></dt>
+<dd>A template + tutorial for writing new Sphinx documentation. It is meant
+to be read in source form.</dd>
+<dt><a class="reference internal" href="TestingGuide.html"><em>LLVM Testing Infrastructure Guide</em></a></dt>
+<dd>A reference manual for using the LLVM testing infrastructure.</dd>
+<dt><a class="reference external" href="http://clang.llvm.org/get_started.html">How to build the C, C++, ObjC, and ObjC++ front end</a></dt>
+<dd>Instructions for building the clang front-end from source.</dd>
+<dt><a class="reference internal" href="Lexicon.html"><em>The LLVM Lexicon</em></a></dt>
+<dd>Definition of acronyms, terms and concepts used in LLVM.</dd>
+<dt><a class="reference internal" href="HowToAddABuilder.html"><em>How To Add Your Build Configuration To LLVM Buildbot Infrastructure</em></a></dt>
+<dd>Instructions for adding new builder to LLVM buildbot master.</dd>
+<dt><a class="reference internal" href="YamlIO.html"><em>YAML I/O</em></a></dt>
+<dd>A reference guide for using LLVM’s YAML I/O library.</dd>
+<dt><a class="reference internal" href="GetElementPtr.html"><em>The Often Misunderstood GEP Instruction</em></a></dt>
+<dd>Answers to some very frequent questions about LLVM’s most frequently
+misunderstood instruction.</dd>
+<dt><a class="reference internal" href="Frontend/PerformanceTips.html"><em>Performance Tips for Frontend Authors</em></a></dt>
+<dd>A collection of tips for frontend authors on how to generate IR
+which LLVM is able to effectively optimize.</dd>
+</dl>
+</div>
+<div class="section" id="programming-documentation">
+<h1>Programming Documentation<a class="headerlink" href="#programming-documentation" title="Permalink to this headline">¶</a></h1>
+<p>For developers of applications which use LLVM as a library.</p>
+<div class="toctree-wrapper compound">
+</div>
+<dl class="docutils">
+<dt><a class="reference internal" href="LangRef.html"><em>LLVM Language Reference Manual</em></a></dt>
+<dd>Defines the LLVM intermediate representation and the assembly form of the
+different nodes.</dd>
+<dt><a class="reference internal" href="Atomics.html"><em>LLVM Atomic Instructions and Concurrency Guide</em></a></dt>
+<dd>Information about LLVM’s concurrency model.</dd>
+<dt><a class="reference internal" href="ProgrammersManual.html"><em>LLVM Programmer’s Manual</em></a></dt>
+<dd>Introduction to the general layout of the LLVM sourcebase, important classes
+and APIs, and some tips & tricks.</dd>
+<dt><a class="reference internal" href="Extensions.html"><em>LLVM Extensions</em></a></dt>
+<dd>LLVM-specific extensions to tools and formats LLVM seeks compatibility with.</dd>
+<dt><a class="reference internal" href="CommandLine.html"><em>CommandLine 2.0 Library Manual</em></a></dt>
+<dd>Provides information on using the command line parsing library.</dd>
+<dt><a class="reference internal" href="CodingStandards.html"><em>LLVM Coding Standards</em></a></dt>
+<dd>Details the LLVM coding standards and provides useful information on writing
+efficient C++ code.</dd>
+<dt><a class="reference internal" href="HowToSetUpLLVMStyleRTTI.html"><em>How to set up LLVM-style RTTI for your class hierarchy</em></a></dt>
+<dd>How to make <tt class="docutils literal"><span class="pre">isa<></span></tt>, <tt class="docutils literal"><span class="pre">dyn_cast<></span></tt>, etc. available for clients of your
+class hierarchy.</dd>
+<dt><a class="reference internal" href="ExtendingLLVM.html"><em>Extending LLVM: Adding instructions, intrinsics, types, etc.</em></a></dt>
+<dd>Look here to see how to add instructions and intrinsics to LLVM.</dd>
+<dt><a class="reference external" href="http://llvm.org/doxygen/">Doxygen generated documentation</a></dt>
+<dd>(<a class="reference external" href="http://llvm.org/doxygen/inherits.html">classes</a>)
+(<a class="reference external" href="http://llvm.org/doxygen/doxygen.tar.gz">tarball</a>)</dd>
+</dl>
+<p><a class="reference external" href="http://godoc.org/llvm.org/llvm/bindings/go/llvm">Documentation for Go bindings</a></p>
+<dl class="docutils">
+<dt><a class="reference external" href="http://llvm.org/viewvc/">ViewVC Repository Browser</a></dt>
+<dd></dd>
+<dt><a class="reference internal" href="CompilerWriterInfo.html"><em>Architecture & Platform Information for Compiler Writers</em></a></dt>
+<dd>A list of helpful links for compiler writers.</dd>
+<dt><a class="reference internal" href="LibFuzzer.html"><em>LibFuzzer – a library for coverage-guided fuzz testing.</em></a></dt>
+<dd>A library for writing in-process guided fuzzers.</dd>
+</dl>
+</div>
+<div class="section" id="subsystem-documentation">
+<h1>Subsystem Documentation<a class="headerlink" href="#subsystem-documentation" title="Permalink to this headline">¶</a></h1>
+<p>For API clients and LLVM developers.</p>
+<div class="toctree-wrapper compound">
+</div>
+<dl class="docutils">
+<dt><a class="reference internal" href="WritingAnLLVMPass.html"><em>Writing an LLVM Pass</em></a></dt>
+<dd>Information on how to write LLVM transformations and analyses.</dd>
+<dt><a class="reference internal" href="WritingAnLLVMBackend.html"><em>Writing an LLVM Backend</em></a></dt>
+<dd>Information on how to write LLVM backends for machine targets.</dd>
+<dt><a class="reference internal" href="CodeGenerator.html"><em>The LLVM Target-Independent Code Generator</em></a></dt>
+<dd>The design and implementation of the LLVM code generator. Useful if you are
+working on retargetting LLVM to a new architecture, designing a new codegen
+pass, or enhancing existing components.</dd>
+<dt><a class="reference internal" href="TableGen/index.html"><em>TableGen</em></a></dt>
+<dd>Describes the TableGen tool, which is used heavily by the LLVM code
+generator.</dd>
+<dt><a class="reference internal" href="AliasAnalysis.html"><em>LLVM Alias Analysis Infrastructure</em></a></dt>
+<dd>Information on how to write a new alias analysis implementation or how to
+use existing analyses.</dd>
+<dt><a class="reference internal" href="GarbageCollection.html"><em>Garbage Collection with LLVM</em></a></dt>
+<dd>The interfaces source-language compilers should use for compiling GC’d
+programs.</dd>
+<dt><a class="reference internal" href="SourceLevelDebugging.html"><em>Source Level Debugging with LLVM</em></a></dt>
+<dd>This document describes the design and philosophy behind the LLVM
+source-level debugger.</dd>
+<dt><a class="reference internal" href="Vectorizers.html"><em>Auto-Vectorization in LLVM</em></a></dt>
+<dd>This document describes the current status of vectorization in LLVM.</dd>
+<dt><a class="reference internal" href="ExceptionHandling.html"><em>Exception Handling in LLVM</em></a></dt>
+<dd>This document describes the design and implementation of exception handling
+in LLVM.</dd>
+<dt><a class="reference internal" href="Bugpoint.html"><em>LLVM bugpoint tool: design and usage</em></a></dt>
+<dd>Automatic bug finder and test-case reducer description and usage
+information.</dd>
+<dt><a class="reference internal" href="BitCodeFormat.html"><em>LLVM Bitcode File Format</em></a></dt>
+<dd>This describes the file format and encoding used for LLVM “bc” files.</dd>
+<dt><a class="reference internal" href="SystemLibrary.html"><em>System Library</em></a></dt>
+<dd>This document describes the LLVM System Library (<tt class="docutils literal"><span class="pre">lib/System</span></tt>) and
+how to keep LLVM source code portable</dd>
+<dt><a class="reference internal" href="LinkTimeOptimization.html"><em>LLVM Link Time Optimization: Design and Implementation</em></a></dt>
+<dd>This document describes the interface between LLVM intermodular optimizer
+and the linker and its design</dd>
+<dt><a class="reference internal" href="GoldPlugin.html"><em>The LLVM gold plugin</em></a></dt>
+<dd>How to build your programs with link-time optimization on Linux.</dd>
+<dt><a class="reference internal" href="DebuggingJITedCode.html"><em>Debugging JIT-ed Code With GDB</em></a></dt>
+<dd>How to debug JITed code with GDB.</dd>
+<dt><a class="reference internal" href="MCJITDesignAndImplementation.html"><em>MCJIT Design and Implementation</em></a></dt>
+<dd>Describes the inner workings of MCJIT execution engine.</dd>
+<dt><a class="reference internal" href="BranchWeightMetadata.html"><em>LLVM Branch Weight Metadata</em></a></dt>
+<dd>Provides information about Branch Prediction Information.</dd>
+<dt><a class="reference internal" href="BlockFrequencyTerminology.html"><em>LLVM Block Frequency Terminology</em></a></dt>
+<dd>Provides information about terminology used in the <tt class="docutils literal"><span class="pre">BlockFrequencyInfo</span></tt>
+analysis pass.</dd>
+<dt><a class="reference internal" href="SegmentedStacks.html"><em>Segmented Stacks in LLVM</em></a></dt>
+<dd>This document describes segmented stacks and how they are used in LLVM.</dd>
+<dt><a class="reference internal" href="MarkedUpDisassembly.html"><em>LLVM’s Optional Rich Disassembly Output</em></a></dt>
+<dd>This document describes the optional rich disassembly output syntax.</dd>
+<dt><a class="reference internal" href="HowToUseAttributes.html"><em>How To Use Attributes</em></a></dt>
+<dd>Answers some questions about the new Attributes infrastructure.</dd>
+<dt><a class="reference internal" href="NVPTXUsage.html"><em>User Guide for NVPTX Back-end</em></a></dt>
+<dd>This document describes using the NVPTX back-end to compile GPU kernels.</dd>
+<dt><a class="reference internal" href="AMDGPUUsage.html"><em>User Guide for AMDGPU Back-end</em></a></dt>
+<dd>This document describes how to use the AMDGPU back-end.</dd>
+<dt><a class="reference internal" href="StackMaps.html"><em>Stack maps and patch points in LLVM</em></a></dt>
+<dd>LLVM support for mapping instruction addresses to the location of
+values and allowing code to be patched.</dd>
+<dt><a class="reference internal" href="BigEndianNEON.html"><em>Using ARM NEON instructions in big endian mode</em></a></dt>
+<dd>LLVM’s support for generating NEON instructions on big endian ARM targets is
+somewhat nonintuitive. This document explains the implementation and rationale.</dd>
+<dt><a class="reference internal" href="CoverageMappingFormat.html"><em>LLVM Code Coverage Mapping Format</em></a></dt>
+<dd>This describes the format and encoding used for LLVM’s code coverage mapping.</dd>
+<dt><a class="reference internal" href="Statepoints.html"><em>Garbage Collection Safepoints in LLVM</em></a></dt>
+<dd>This describes a set of experimental extensions for garbage
+collection support.</dd>
+<dt><a class="reference internal" href="MergeFunctions.html"><em>MergeFunctions pass, how it works</em></a></dt>
+<dd>Describes functions merging optimization.</dd>
+<dt><a class="reference internal" href="InAlloca.html"><em>Design and Usage of the InAlloca Attribute</em></a></dt>
+<dd>Description of the <tt class="docutils literal"><span class="pre">inalloca</span></tt> argument attribute.</dd>
+<dt><a class="reference internal" href="FaultMaps.html"><em>FaultMaps and implicit checks</em></a></dt>
+<dd>LLVM support for folding control flow into faulting machine instructions.</dd>
+</dl>
+</div>
+<div class="section" id="development-process-documentation">
+<h1>Development Process Documentation<a class="headerlink" href="#development-process-documentation" title="Permalink to this headline">¶</a></h1>
+<p>Information about LLVM’s development process.</p>
+<div class="toctree-wrapper compound">
+</div>
+<dl class="docutils">
+<dt><a class="reference internal" href="DeveloperPolicy.html"><em>LLVM Developer Policy</em></a></dt>
+<dd>The LLVM project’s policy towards developers and their contributions.</dd>
+<dt><a class="reference internal" href="Projects.html"><em>Creating an LLVM Project</em></a></dt>
+<dd>How-to guide and templates for new projects that <em>use</em> the LLVM
+infrastructure. The templates (directory organization, Makefiles, and test
+tree) allow the project code to be located outside (or inside) the <tt class="docutils literal"><span class="pre">llvm/</span></tt>
+tree, while using LLVM header files and libraries.</dd>
+<dt><a class="reference internal" href="LLVMBuild.html"><em>LLVMBuild Guide</em></a></dt>
+<dd>Describes the LLVMBuild organization and files used by LLVM to specify
+component descriptions.</dd>
+<dt><a class="reference internal" href="MakefileGuide.html"><em>LLVM Makefile Guide</em></a></dt>
+<dd>Describes how the LLVM makefiles work and how to use them.</dd>
+<dt><a class="reference internal" href="HowToReleaseLLVM.html"><em>How To Release LLVM To The Public</em></a></dt>
+<dd>This is a guide to preparing LLVM releases. Most developers can ignore it.</dd>
+<dt><a class="reference internal" href="ReleaseProcess.html"><em>How To Validate a New Release</em></a></dt>
+<dd>This is a guide to validate a new release, during the release process. Most developers can ignore it.</dd>
+<dt><a class="reference internal" href="Packaging.html"><em>Advice on Packaging LLVM</em></a></dt>
+<dd>Advice on packaging LLVM into a distribution.</dd>
+<dt><a class="reference internal" href="Phabricator.html"><em>Code Reviews with Phabricator</em></a></dt>
+<dd>Describes how to use the Phabricator code review tool hosted on
+<a class="reference external" href="http://reviews.llvm.org/">http://reviews.llvm.org/</a> and its command line interface, Arcanist.</dd>
+</dl>
+</div>
+<div class="section" id="community">
+<h1>Community<a class="headerlink" href="#community" title="Permalink to this headline">¶</a></h1>
+<p>LLVM has a thriving community of friendly and helpful developers.
+The two primary communication mechanisms in the LLVM community are mailing
+lists and IRC.</p>
+<div class="section" id="mailing-lists">
+<h2>Mailing Lists<a class="headerlink" href="#mailing-lists" title="Permalink to this headline">¶</a></h2>
+<p>If you can’t find what you need in these docs, try consulting the mailing
+lists.</p>
+<dl class="docutils">
+<dt><a class="reference external" href="http://lists.llvm.org/mailman/listinfo/llvm-dev">Developer’s List (llvm-dev)</a></dt>
+<dd>This list is for people who want to be included in technical discussions of
+LLVM. People post to this list when they have questions about writing code
+for or using the LLVM tools. It is relatively low volume.</dd>
+<dt><a class="reference external" href="http://lists.llvm.org/pipermail/llvm-commits/">Commits Archive (llvm-commits)</a></dt>
+<dd>This list contains all commit messages that are made when LLVM developers
+commit code changes to the repository. It also serves as a forum for
+patch review (i.e. send patches here). It is useful for those who want to
+stay on the bleeding edge of LLVM development. This list is very high
+volume.</dd>
+<dt><a class="reference external" href="http://lists.llvm.org/pipermail/llvm-bugs/">Bugs & Patches Archive (llvm-bugs)</a></dt>
+<dd>This list gets emailed every time a bug is opened and closed. It is
+higher volume than the LLVM-dev list.</dd>
+<dt><a class="reference external" href="http://lists.llvm.org/pipermail/llvm-testresults/">Test Results Archive (llvm-testresults)</a></dt>
+<dd>A message is automatically sent to this list by every active nightly tester
+when it completes. As such, this list gets email several times each day,
+making it a high volume list.</dd>
+<dt><a class="reference external" href="http://lists.llvm.org/mailman/listinfo/llvm-announce">LLVM Announcements List (llvm-announce)</a></dt>
+<dd>This is a low volume list that provides important announcements regarding
+LLVM. It gets email about once a month.</dd>
+</dl>
+</div>
+<div class="section" id="irc">
+<h2>IRC<a class="headerlink" href="#irc" title="Permalink to this headline">¶</a></h2>
+<p>Users and developers of the LLVM project (including subprojects such as Clang)
+can be found in #llvm on <a class="reference external" href="irc://irc.oftc.net/llvm">irc.oftc.net</a>.</p>
+<p>This channel has several bots.</p>
+<ul class="simple">
+<li>Buildbot reporters<ul>
+<li>llvmbb - Bot for the main LLVM buildbot master.
+<a class="reference external" href="http://lab.llvm.org:8011/console">http://lab.llvm.org:8011/console</a></li>
+<li>bb-chapuni - An individually run buildbot master. <a class="reference external" href="http://bb.pgr.jp/console">http://bb.pgr.jp/console</a></li>
+<li>smooshlab - Apple’s internal buildbot master.</li>
+</ul>
+</li>
+<li>robot - Bugzilla linker. %bug <number></li>
+<li>clang-bot - A <a class="reference external" href="http://www.eelis.net/geordi/">geordi</a> instance running
+near-trunk clang instead of gcc.</li>
+</ul>
+</div>
+</div>
+<div class="section" id="indices-and-tables">
+<h1>Indices and tables<a class="headerlink" href="#indices-and-tables" title="Permalink to this headline">¶</a></h1>
+<ul class="simple">
+<li><a class="reference internal" href="genindex.html"><em>Index</em></a></li>
+<li><a class="reference internal" href="search.html"><em>Search Page</em></a></li>
+</ul>
+</div>
+
+
+ </div>
+ </div>
+ <div class="clearer"></div>
+ </div>
+ <div class="related">
+ <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="LangRef.html" title="LLVM Language Reference Manual"
+ >next</a> |</li>
+ <li><a href="http://llvm.org/">LLVM Home</a> | </li>
+ <li><a href="#">Documentation</a>»</li>
+
+ </ul>
+ </div>
+ <div class="footer">
+ © Copyright 2003-2016, LLVM Project.
+ Last updated on 2016-01-04.
+ Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.2.3.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/3.7.1/docs/objects.inv
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/3.7.1/docs/objects.inv?rev=257950&view=auto
==============================================================================
Binary file - no diff available.
Propchange: www-releases/trunk/3.7.1/docs/objects.inv
------------------------------------------------------------------------------
svn:mime-type = application/octet-stream
Added: www-releases/trunk/3.7.1/docs/search.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/3.7.1/docs/search.html?rev=257950&view=auto
==============================================================================
--- www-releases/trunk/3.7.1/docs/search.html (added)
+++ www-releases/trunk/3.7.1/docs/search.html Fri Jan 15 17:13:16 2016
@@ -0,0 +1,111 @@
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+ <title>Search — LLVM 3.7 documentation</title>
+
+ <link rel="stylesheet" href="_static/llvm-theme.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: './',
+ VERSION: '3.7',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true
+ };
+ </script>
+ <script type="text/javascript" src="_static/jquery.js"></script>
+ <script type="text/javascript" src="_static/underscore.js"></script>
+ <script type="text/javascript" src="_static/doctools.js"></script>
+ <script type="text/javascript" src="_static/searchtools.js"></script>
+ <link rel="top" title="LLVM 3.7 documentation" href="index.html" />
+ <script type="text/javascript">
+ jQuery(function() { Search.loadIndex("searchindex.js"); });
+ </script>
+
+ <script type="text/javascript" id="searchindexloader"></script>
+
+<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">
+ <h3>Navigation</h3>
+ <ul>
+ <li class="right" style="margin-right: 10px">
+ <a href="genindex.html" title="General Index"
+ accesskey="I">index</a></li>
+ <li><a href="http://llvm.org/">LLVM Home</a> | </li>
+ <li><a href="index.html">Documentation</a>»</li>
+
+ </ul>
+ </div>
+
+
+ <div class="document">
+ <div class="documentwrapper">
+ <div class="body">
+
+ <h1 id="search-documentation">Search</h1>
+ <div id="fallback" class="admonition warning">
+ <script type="text/javascript">$('#fallback').hide();</script>
+ <p>
+ Please activate JavaScript to enable the search
+ functionality.
+ </p>
+ </div>
+ <p>
+ From here you can search these documents. Enter your search
+ words into the box below and click "search". Note that the search
+ function will automatically search for all of the words. Pages
+ containing fewer words won't appear in the result list.
+ </p>
+ <form action="" method="get">
+ <input type="text" name="q" value="" />
+ <input type="submit" value="search" />
+ <span id="search-progress" style="padding-left: 10px"></span>
+ </form>
+
+ <div id="search-results">
+
+ </div>
+
+ </div>
+ </div>
+ <div class="clearer"></div>
+ </div>
+ <div class="related">
+ <h3>Navigation</h3>
+ <ul>
+ <li class="right" style="margin-right: 10px">
+ <a href="genindex.html" title="General Index"
+ >index</a></li>
+ <li><a href="http://llvm.org/">LLVM Home</a> | </li>
+ <li><a href="index.html">Documentation</a>»</li>
+
+ </ul>
+ </div>
+ <div class="footer">
+ © Copyright 2003-2016, LLVM Project.
+ Last updated on 2016-01-04.
+ Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.2.3.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/3.7.1/docs/searchindex.js
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/3.7.1/docs/searchindex.js?rev=257950&view=auto
==============================================================================
--- www-releases/trunk/3.7.1/docs/searchindex.js (added)
+++ www-releases/trunk/3.7.1/docs/searchindex.js Fri Jan 15 17:13:16 2016
@@ -0,0 +1 @@
+Search.setIndex({envversion:42,terms:{orthogon:[31,86],interchang:[66,92,84],four:[92,112,54,42,43,20,1,73,78,8,103,84,23,19],prefix:[],configstatusscript:66,is_open:8,francesco:32,repetit:84,add32ri8:6,uint64_max:59,identityprop:16,foldingsetnodeid:16,curr:17,build_fcmp:[12,13,14,15,19],dbx:56,digit:[23,20,111,16],intregsregclass:54,emitconst:54,basic_:116,n2118:92,delv:[12,27,50],f110:8,suffic:78,grokabl:92,distcheckdir:66,fpmad:56,mli:12,seper:23,second:[32,92,0,34,35,1,94,69,4,23,71,40,41,97,43,5,98,47,49,11,72,13,16,19,54,103,73,20,104,56,76,24,108,26,84,85,67,88,112,115],x86ii:54,r15d:6,functionfaultinfo:91,r15b:6,alignstack:[23,112],thefpm:[41,47,2,49,50],constrast:42,r15w:6,errorf:[41,43,113,47,2,49,50],xchg:[23,86],cull:92,ongo:[72,27],noreturn:[23,51,112],visitxor:83,here:[92,67,34,35,36,94,37,69,4,99,5,6,71,39,40,41,84,8,43,23,45,98,47,2,49,50,10,11,51,72,12,13,14,15,16,18,19,75,54,102,73,90,20,100,56,76,103,97,24,61,25,83,31,42,85,86,87,109,88,113,114,66,30,26,116],gnu_h
ash:56,image_file_machine_r4000:109,dllvm_build_runtim:24,iseldagtodag:21,sorri:[40,11],golden:92,unic:20,bou_tru:20,unif:42,brought:34,substr:71,unix:[24,61,97,16,20,98,10,23,66,4,5],machinecodeemitt:54,content_disposition_typ:27,globalvari:[],unit:[],ldri:54,fstream:8,subpath:[28,1],destarglist:23,get_ptr:91,inner:[39,92,44,67,48,23,16],until:[32,92,33,1,23,75,41,43,44,45,47,2,49,50,10,51,12,13,14,15,16,17,18,19,54,113,20,76,21,78,57,111,24,107,25,83,31,84,27,112,108],new_else_bb:[13,14,15],emitlabelplusoffset:73,jmp:23,relat:[],notic:[98,61,102,8,43,34,84,47,27,51,103,15,16,19],hurt:92,exce:[31,92,23,56],hole:[20,23],herebi:92,image_scn_align_128byt:109,generalis:[14,2],talli:35,dagtodag:65,conceptu:[92,103,5,20,84,108,78,23,16],forexpr:[41,47,2,49,13,14,15],oftc:39,rework:[20,27],get_matcher_implement:21,al_superregsset:54,phabric:[],dtor:[98,23],createfunct:41,replaceusesofwith:[60,16],doubletyp:16,caution:[66,86,72],fibonacci:[66,37,17,45],want:[],umin:23,hasfp:54,codegen:[],m
casmstream:84,fucompi:84,hoc:[32,84,16],classifi:42,i686:[10,84,5],how:[],hot:[23,51,59],actionscript:[40,11],macosx10:23,perspect:[102,42,72,76,108,23],lhse:[41,47],bpf_stx:84,tls1_process_heartbeat:26,wrong:[],beauti:[43,45,2,14,17,19],adc32rm:6,outoperandlist:[6,54],weakanylinkag:16,index2virtreg:84,passopt:76,isvalid:41,apint:16,alias:[],"18th":103,prototypeast:[41,43,113,47,2,49,50],tok_for:[41,47,2,49],"0x3f":22,feedback:[76,114,26,27,94],assing:34,appar:[15,47],vari:[40,98,23,84,86,11,112,4,83,16],z196:31,exported_symbol_list:66,redhat:63,fit:[32,92,107,103,23,20,84,56,49,27,78,13,16,31],fix:[],fib:[32,41,45,47,49,13,15,17],xxxinstrdescriptor:54,hidden:[92,16,20,84,48,68,56,76,95,112,57,23],easier:[32,62,33,84,92,23,6,65,41,8,43,113,98,47,99,10,15,16,18,19,101,73,21,107,31,42,86,27,28],aliasesset:42,proce:[60,61,33,34,73,108],imagstart:[14,2],interrupt:[91,92,26,1,4,23],sellect:21,kernelparam:8,loopinfo:76,sparclite86x:54,dcmake_install_prefix:[24,9,61],exprast:[41,43,113,47,
2,49,50,18],accommod:[84,22,112,8],timeout:[26,31],"0x7ffff7ed404c":99,build_fadd:19,openfileforwrit:4,resum:[],llvmfuzzertestoneinput:26,pinsrd_1:5,numentri:112,whip:[14,2],intregssuperclass:54,dst:[69,84,6,54,116],astcontext:92,dsl:[6,100],llvm_lit_arg:61,adapt:[4,98,16,32],aliasdebugg:42,dsa:60,navig:[28,20,107],selectionkind:23,omiss:[27,23],targetloweringobjectfil:84,adc64ri32:6,f3_1:54,f3_2:54,f3_3:54,proj_src_root:[66,52],reformul:42,realstart:[14,2],att:[80,77,23],unabl:[60,23,18,116],disablelazycompil:16,confus:[92,97,54,103,34,27,23,16],s3_pkt:26,configurescriptflag:66,clariti:[13,23,49],wast:[75,115,47,56,88,15,16],psubusw:10,mingw:[37,84,61,94],mklib:66,wasn:[41,42,34,47,2,14,15],cpu_x86:67,isalnum:[41,43,113,45,47,2,49,50],llvmmemorymanagerallocatedatasectioncallback:88,signext:[23,112],setargstr:20,nobuiltin:23,master:[10,24,114,52,39],image_scn_mem_discard:109,similarli:[39,41,102,54,42,23,20,62,92,83,27,78,66,94,16,35],getnod:[65,54],image_sym_class_stat:109,linpack:
0,addrrr:54,arrayidx1:23,arrayidx3:23,arrayidx2:23,arrayidx4:23,"0x3500000001652748":99,ntid:8,crawl:73,technic:[39,26,27],lvalu:16,tree:[],wchar_t:23,image_rel_i386_secrel:22,sdnode:[83,84,16,6,54],recheck:[32,66,34],uniniti:[73,92,23,116,103],libllvmcor:16,aforement:24,increment:[],infring:27,dcmake_toolchain_fil:24,incompat:[63,31,23],dozen:[36,51],sig_atomic_t:23,implicitus:84,musttail:23,lfoo:84,multimap:16,get_instrinfo_operand_types_enum:54,simplifi:[],shall:[23,20,61,11,40],cpu2:67,object:[],numloc:88,dblty:41,letter:[41,54,20,47,2,92,112,66,14,15,23],breakpoint:[],alwaysinlin:[23,112],errorv:[41,43,47,2,49,50],getelementtyp:16,expr0rh:71,purgev:112,dummi:[32,98,54,26,84,10,116],lpm:76,mayreadfrommemori:86,detriment:92,came:[13,40,111,11,49],superset:[23,97],asid:[23,16],addr2:79,klimek:107,matchinstructionimpl:84,layout:[],ccmake:61,apach:[4,27],llvmcore:[33,52],theme:[6,100],busi:27,image_sym_type_word:109,exctyp:108,recursivetarget:66,plate:20,selectiondagbuild:84,enable_
profil:[66,98,87],addri:54,replaceusesofwithonconst:60,addrr:54,obscur:16,smallvectorimpl:16,ppc_fp128:[34,23,112],hasopsizeprefix:6,patch:[],emitstorecondit:86,sligtli:78,bpf_ja:84,respond:[32,107,42],sjljehprepar:108,mandatori:[23,37,16,54],fprofil:[71,95],fail:[],best:[32,92,42,73,108,45,62,56,87,88,27,11,78,113,80,84,16,98,18],dw_tag_reference_typ:[23,56],wikipedia:[28,13,23,49],copyleft:27,figur:[76,92,54,16,20,62,83,10,78,66,84,23],irc:[],sysroot:[9,6],glasgow:23,xvf:37,henrik:4,extend:[],extens:[],extent:[73,27,23,103,55],toler:[73,23,94],advertis:108,rtti:[],"0f3f800000":8,accident:[76,4,20,92],atomicexpandpass:86,logic:[32,92,34,1,23,43,5,47,2,49,13,14,15,16,19,102,103,108,84,27,113,28,66],hh567368:92,compromis:16,with_assert:61,assur:67,mattr:[80,77,5,54],preemptibl:32,creategvnpass:[41,47,2,49,50],"2nd":[23,31,16,116],dibuild:[41,56],diff:[],summat:23,assum:[],summar:[73,32,1,84],duplic:[],frc:84,frb:84,fra:84,bewilder:66,union:[92,42,84,47,56,15,23],n_hash:56,frt:84,bpf_
mod:84,life:[27,92,51],regul:76,mrm6m:54,worker:26,isfunct:56,cufunct:8,"25x":31,lift:51,legacypassmanag:[41,47,2,49,50],child:[14,23,2,102],objectfil:75,emploi:[23,16],image_scn_mem_not_cach:109,commerci:27,employ:27,one_onli:22,debug_metadata_vers:41,emit_22:54,unop:[41,14,15,47,2],llvm_enable_p:61,filename0:71,lto_module_is_object_file_in_memori:90,createret:[41,43,47,2,49,50],format:[],bikesh:102,generalcategori:20,falsedest:23,split:[32,65,54,103,34,20,84,85,86,83,27,78,23,52],immtypebit:6,functionpassmanag:[41,47,2,49,50],mmsa:31,annoat:29,reassoci:[],cxx0x:92,dest1:23,fairli:[54,42,113,45,98,2,49,86,11,51,28,13,14,16,17,18],dest2:23,"07b":31,boiler:20,ownership:[41,47,2,49,50,27,16],refin:[84,16,42],tune:[],tokvarnam:30,nuzman:0,gzip:[24,94],argmemonli:23,modnam:50,ordin:20,bit:[],previous:[61,54,43,30,20,49,94,95,108,23,35,19],typeless:31,easi:[92,67,33,34,35,1,23,40,47,43,113,45,9,49,50,10,11,12,13,15,16,17,18,19,102,73,56,76,21,24,61,26,84,87,64,27,112,28,115,31],bitwidth:
[34,23,112],had:[8,72,34,31,67,86,76,88,78,38,4,115,23],instrprof:23,har:[24,52],hat:67,sanit:[26,61,31],ocamlbuild:[12,13,14,15,18,19],issimpl:86,preserv:[24,40,84,97,103,42,72,20,55,76,95,11,78,108,88,23],instrumen:71,st_mode:97,attrparsedattrkind:21,isdeclar:16,measur:97,specif:[],fcmpinst:16,nonlazybind:23,remind:[27,94],underli:[],right:[],old:[],getargumentlist:16,unabashedli:66,attornei:27,olt:23,paralleltarget:66,dominatorset:76,txt:[24,92,61,55,20,94,10,79,27,28,115,26],sparcsubtarget:54,bottom:[32,60,107,54,0,34,20,76,13,4,23,59,80],undisturb:92,lto_module_get_num_symbol:90,stringsort:92,subclass:[],cassert:[92,8],armv7l:36,topleveltarget:66,op_begin:16,condit:[],foo:[92,0,72,3,23,71,8,43,5,98,48,49,50,10,12,13,84,16,18,19,102,103,73,20,104,56,22,78,79,59,108,62,42,67,113,30,116],"0f00000000":8,armv7a:[9,94],sensibl:16,leftr:34,egregi:27,tablegen:[],bindex:54,emitt:[],image_scn_mem_lock:109,llvmanalysi:52,true_branch_weight:3,troubl:[24,20,27,37],slightli:[],xor64rr:84,dw_
tag_array_typ:[23,56],selectiondagisel:21,basenam:56,expandop:65,mbb:[84,54],creativ:54,mcinstlow:84,wrap:[75,24,92,103,45,43,23,20,67,48,56,27,112,113,4,16,17,18,19],msp430:[24,84,23,87],data32bitsdirect:54,suffici:[24,103,62,102,32,73,5,20,42,45,86,83,51,23,72,66,29,16,17,116],support:[],sub_rr:116,happi:[15,47,52],sub_ri:116,width:[],cpprefer:16,distsubdir:66,fco:54,use_back:16,headach:33,setxyzzi:92,"0x2413bc":76,fpga:84,offer:[73,31,67,16,86],refcount:73,strike:[43,19],dllstorageclass:[23,112],multiprocessor:[73,76],reserveresourc:84,profdata:[],mymod:66,"_main":[79,109],insidi:92,reiter:23,handili:92,fermi:84,dump_valu:[12,13,14,15,19],rerun:66,isexternalsymbol:54,later:[32,92,34,35,95,23,71,41,43,5,50,10,51,72,12,13,14,15,16,52,19,75,54,56,76,24,31,84,88,18,113,66,115],proven:[32,47,111,51,15,23],flagsflat:67,ericsson:23,build_phi:[13,14,15],bswap:[],role:[92,33,34,56,113,30,18],finalizeobject:[75,41,47,2,49,50],presum:23,smell:16,roll:[92,102],"_p1":56,legitim:92,notif:42,in
tend:[],createargumentalloca:[41,47],intens:[16,51,0],intent:[97,30,84,47,27,90,78,15,23],keycol:69,dyn_switch:92,"1s100000s11010s10100s1111s1010s110s11s1":16,cumemcpyhtod:8,isfloatingpointti:16,time:[],push:[41,73,31,84,92,83],image_file_dl:109,corpu:26,breadth:[80,45,17],mrmsrcmem:54,ptrtoint:[],sparctargetmachin:54,osi:98,aptr:23,const_nul:[13,14,15],image_sym_type_short:109,decid:[65,67,61,107,0,23,20,62,47,2,50,76,113,78,72,12,14,15,16,18,56],hold:[32,34,23,6,75,41,43,113,45,47,2,49,50,10,12,13,14,15,16,18,19,54,73,20,56,76,24,26,84,52,28,116],decim:[97,20,67,22,23,116],x08:109,decis:[92,0,72,84,83,50,27,78,108,12,23],x03:109,x01:109,macho:[75,84],oversight:27,x04:109,cheap:[92,16,86],uint32_max:56,cudevicecomputecap:8,vmcore:[20,61],fullest:92,exact:[32,92,55,73,23,20,86,56,76,90,108,28,16,35],numlin:71,solver:84,tear:108,identifierstr:[41,43,113,45,47,2,49,50],unsupport:[84,54,33,1,86,94,10,37],team:[52,94],cooki:[23,16],prevent:[32,92,0,72,4,23,41,42,43,5,98,47,10,15,16,19,7
3,20,56,76,31,84,85,27,88,66],dcmake_cxx_flag:9,"_abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz0123456789":50,numroot:73,heavyweight:16,relocat:[75,80,23,54],llvm_lit_tools_dir:[37,61],regex_t:26,filenameindex1:71,lazili:[16,31,50,112,12,90],currenc:[12,84,27,50],thecu:41,merge_bb:[13,14,15],current:[91,32,92,78,67,33,34,1,77,48,37,3,69,4,5,6,71,39,40,41,84,8,43,44,45,98,9,2,49,50,10,11,51,47,12,13,14,15,16,17,18,19,75,54,103,73,20,65,56,76,114,21,22,23,80,111,94,97,24,61,25,72,108,26,42,85,86,87,63,64,27,88,52,112,113,28,66,30,31,116],image_scn_cnt_cod:109,i256:23,objdir:[66,87],boost:31,addpdrr:116,intraprocedur:83,unvectoriz:0,cudevicegetnam:8,dropdown:107,autogener:27,live_begin:73,splice:[23,16],address:[],along:[],ffast:0,cur_var:15,volumin:16,commentstr:54,queue:[76,16,54],throughput:51,replaceinstwithvalu:16,safepoint:[],mipsel:87,bpf_ld:84,commonli:[92,54,73,16,112,23],ourselv:[92,56,8],ipc:4,ipa:60,love:16,"2ap3":22,pentium:[24,54],prefer:[],ipo:[34,60],src2:[84,6,1
16],regalloc:[76,80,77,84],src1:[84,6,116],fake:[80,23],instal:[],llvm_lib_search_path:24,callstack:108,anothercategori:20,virtreg:84,image_sym_class_nul:109,abbrevid:112,scope:[],tightli:[41,43,113,47,2,49,50,92,12,13,14,15,23,18,19],"66ghz":114,peopl:[24,40,92,107,39,33,20,45,65,94,76,27,11,4,103,84,23,17,98],n2627:92,claus:[84,27,23,108],refrain:[23,94],enhanc:[],dagarg:30,linkmodul:66,langref:[31,65,86],easiest:[24,40,54,86,94,76,11,115],behalf:[27,107],b_ctor_bas:5,subel:23,descriptor:[41,54,108,56,88,112,23],valuet:16,whatev:[32,61,103,42,23,20,67,24,4,5],problemat:92,encapsul:[92,102,57],recycl:84,setrecordnam:112,optnon:23,fpm:50,r11b:6,r11d:6,forexprast:[41,47,2,49],fpu:[23,9,36],parameter:116,r11w:6,vec0123:23,remap:[],jazz:52,dw_apple_property_gett:56,spot:[32,26,94],mrm4m:54,mrm4r:54,succ:92,date:[24,97,42,33,31,49,94,37,87,66,13,83,116],shuffl:[1,23],data:[],codes:6,stress:[],indexloc:16,bpf_xor:84,disable_auto_depend:66,stdio:[24,64,37,13,12,4,14,15,90],stdin:[41,56,10
,12,13,14,15,5,18,19],fp5:[6,116],fp4:[6,116],sandbox:[33,9],fp6:[6,116],fp1:[6,116],fp0:[6,116],fp3:[6,116],fp2:[6,116],callabl:[],iftmp:[41,47,2,49,13,14,15],untest:33,use_llvm_executionengin:[12,13,14,15],my_funct:8,llvm_library_vis:73,revisit:72,numbyt:88,x86retflag:116,overhaul:94,thumb:[],image_sym_class_block:109,precedecnc:[41,47,2],instantli:16,"__stack_chk_guard":23,jit:[],canonicalis:78,image_sym_class_end_of_struct:109,llvmbuildlandingpad:[],mips32r3:31,outli:108,mips32r5:31,mips32r6:31,smarter:20,isbinaryop:[41,47,2],"0x00000147":56,inpredsens:69,therebi:[20,88],"0x00000140":56,mcode:22,revers:[],llvm_src_dir:[98,36,87],separ:[92,67,35,95,4,23,8,5,9,48,10,18,54,103,73,20,56,76,21,111,59,24,61,31,84,86,87,27,88,52,112,113,28,66,115,90,26,116],dwarf2:41,complextyp:109,sk_squar:102,compil:[],argvalu:[20,99],registertarget:54,"__has_attribut":21,blx:22,movsx64rr32:84,"0x100":56,blk:16,nsw:[27,23,51,103],getschedclass:54,pseudocod:54,million:[23,16],removefrompar:16,crazier:
[13,49],micromip:31,"byte":[72,38,23,71,65,97,42,12,13,14,15,16,18,19,54,103,104,56,78,26,84,85,86,88,112,31],subregist:[88,54],reusabl:84,departur:66,jitcompilerfunct:54,ifuzz:26,sysconfdir:66,modest:92,recov:[91,108,5,88,23,16],cbw:84,neglect:35,arraytyp:16,oper:[],onc:[91,92,108,67,33,34,35,1,94,95,37,4,23,6,75,39,7,84,42,43,44,98,47,49,50,11,72,12,13,15,16,18,19,54,103,73,90,20,74,40,76,24,60,61,83,26,62,87,64,27,113,112,65,66,115,30,116],iaddroff:84,coveragemappingdataforfunctionrecord1:71,"0x7f":[23,116],printinformationalmessag:20,symmetri:10,open:[],lexicograph:[34,92],addtmp4:[43,19],insttoreplac:16,f88:8,convent:[],bite:98,f80:23,enable_optim:[63,66,87,94],optlevel:20,draft:[24,86,56],addtmp1:[12,50],getsubtarget:[31,54],conveni:[32,92,1,23,71,40,8,98,2,49,10,11,13,14,16,52,102,20,24,26,84,27,116],goldberg91:73,usenamedoperandt:54,fma:[],eor:23,sometest:35,programat:[31,14,84,2],insertion_block:[13,14,15],artifact:[34,103],"__apple_namespac":56,jscop:31,vec012:23,unnamed_a
ddr:[23,112],rival:16,rzi:8,param2:16,param1:16,"0x12345678":56,sai:[40,41,102,97,35,45,43,5,20,84,11,23,66,69,4,103,115,16,17,19],nicer:[20,41,16,67],argument:[],second_tru:23,sar:84,saw:[76,13,90,49],entrytoken:84,notw:5,xxxgenregisterinfo:54,wrapcolumn:67,destroi:[67,54,16,84,48,76,108,23,98],note:[],denomin:92,take:[32,92,108,67,33,34,102,1,77,48,37,38,69,5,75,7,41,84,8,43,23,45,98,47,2,49,50,11,72,12,13,14,15,16,17,18,19,54,103,73,90,20,74,40,56,76,21,78,57,80,93,24,82,83,26,42,109,86,87,110,64,27,88,113,112,65,66,115,30,31,116],tolmach:73,jumptabl:23,printer:[],buffer:[23,40,41,43,113,47,2,49,50,11,12,13,14,15,16,17,18,19,56,108,26,90],fcc_ug:54,compress:[24,61,112,38,66,16],private_segment_align:25,insertel:[],abus:16,homepag:[24,37],allevi:[23,20,84,16],"_function_nam":22,drive:[28,72,36],setinsertfencesforatom:86,event:[61,16,88,72],behe:72,merit:92,"__llvm_covmap":71,cclib:[14,15],objptr:23,slot:[],xmm:[23,5,54],slow:[76,24,26,63,77,16],transact:31,activ:[39,92,54,42,73,23
,53,84,48,76,27,88,108,16],v2size:42,freebsd5:84,ubla:31,codeblock:73,v16f32:23,dominatortre:76,flagscpu1:67,clang:[],x86reloc:54,modulelevelpass:76,amdkernelcodet:25,borrow:23,specialsquar:102,use_bind:[12,13,14,15],getframes:73,openorcreatefileforwrit:4,xmax:[14,2],clenumvalend:20,where:[],compute_pgm_rsrc2_user_sgpr:25,sinbio:26,respres:16,deadlin:27,dw_at_apple_property_sett:56,callseq_start:72,arglist:23,xxxtrait:67,x86targetmachin:84,x24:109,build_mul:[12,13,14,15,19],getindex:54,spars:[],screen:33,secnam:22,imm32:84,opval:54,sparc:[],uncondition:[84,41,22,42],genericvalu:[12,13,14,15],eflag:[6,116],do_safepoint:72,extern_weak:[23,112],mani:[91,32,62,0,33,47,35,92,48,37,3,102,4,5,98,40,84,8,43,23,45,46,9,2,49,50,10,11,72,12,13,14,15,16,17,18,19,54,103,73,113,20,65,56,76,78,59,24,107,83,31,42,86,67,88,112,108,28,66,26],qhelpgener:61,dw_at_mips_linkage_nam:56,unistd:4,sccp:[],sentinel:[],constant:[],boat:92,xxxiter:16,printstar:[13,49],"200000e":[13,49],add16mr:6,image_scn_align
_4096byt:109,ismod:116,parseifexpr:[41,47,2,49],inst_begin:16,add16mi:6,reflex:34,constantfoldcal:65,symobl:22,thousand:32,release_15:24,ppcisellow:65,cxx_fuzzer_token:26,former:[72,84,86,51,113,18],lltok:65,getvaluetyp:54,combine1:84,combine2:84,emitalign:73,columnstart:71,polli:[],view_function_cfg:13,movsx16rm8w:84,lto_module_get_symbol_attribut:90,canon:[32,16,78,23,56],blah:[20,92],pthread:23,ascii:[41,97,43,113,45,47,2,49,50,56,112,12,13,14,15,23,17,18,19],binari:[],devcount:8,srem:[],unhandl:108,irread:61,"0x1603020":99,getfunct:[41,43,47,2,49,50,76,73,16],extern:[],defi:23,sret:[23,112],defm:[],fnname:[41,43,113,47,2,49,50],dw_form_ref_udata:56,clobber:[],dimension:[31,14,103,2,8],then_:[13,14,15],noencod:84,resp:[23,16],rest:[],checkcudaerror:8,fmadd:84,gdb:[],unmaintain:6,invalid:[32,92,72,1,23,75,41,42,43,113,47,2,49,50,12,13,14,15,16,18,19,54,103,20,74,56,76,24,60,108,26,67,110,88],loadable_modul:[10,66,76,73],cond_fals:[15,47],r13w:6,"__builtin_trap":26,ghostli:16,"__im
p_":23,littl:[],instrument:[71,24,32,26,103,110,95,3,23],r13d:6,r13b:6,exercis:[10,40,11],dwarfdebug:56,featurev8deprec:54,mrm2m:[54,116],around:[32,92,34,94,4,23,40,41,42,113,98,48,49,11,13,16,54,103,73,20,56,76,57,24,31,86,27,28],libm:[12,43,50,23,19],getunqu:16,unveil:[45,17],libz:23,traffic:[47,31,15,16],my86flag:67,llvm_lib:61,world:[],mrm2r:[54,116],find_program:61,intel:[],"__gxx_personality_v0":108,integ:[],timepassesisen:20,"0x60500020":109,inter:[4,27,3,60,42],manag:[91,33,72,94,37,75,40,42,44,98,47,50,11,15,83,54,103,73,76,24,60,107,16,88,108,114],pushq:72,attrlist:21,a64:78,handshak:26,pushf:84,pred_iter:16,constitut:[10,16,112,78],stryjewski:32,exig:16,seterrorstr:[41,47,2,49,50],issiz:16,definit:[],exim:26,parseextern:[41,43,113,47,2,49,50],evolv:90,noop:23,nonintuit:39,notabl:[65,61,103,16,31,84,87,23],ddd:97,pointnum:73,power:[32,36,48,23,6,105,42,43,5,45,47,2,49,50,100,12,13,14,15,16,17,18,19,20,107,25,31,84,113,90],isloopinvari:16,blockaddress:23,image_sym_type_uni
on:109,n1984:92,n1987:92,n1986:92,ispic:54,standpoint:16,isset:20,mingw32msvc:84,acc:16,spiffygrep:20,gplv3:64,aco:42,acm:[73,84],printmethod:54,compuat:60,act:[32,92,23,84,56,34,16,59],cater:21,industri:39,rebuild:[],specialfp:116,cflag:[66,52],surviv:[108,18,113],homeless:16,asymptomat:44,basictyp:23,ehptr:108,hex:[],movsx64rr16:84,kaleidoscop:[],isloadfromstackslot:54,verbatim:[20,54],thedoclist:67,mantissa:23,conclud:[13,14,2,49],htpasswd:27,createjit:75,clenumv:20,categor:[32,20,21,54],conclus:[],ifunequ:23,pull:[24,92,86,107],tripl:[],dirti:[92,50],rage:38,agrep:35,image_sym_dtype_point:109,inaccuraci:23,emitprologu:54,gcolumn:0,puls:26,basenamesourc:66,uid:97,creat:[],certain:[72,1,23,71,65,97,42,5,47,50,12,15,16,73,20,76,22,78,24,31,84,63,88,66,116],numregion:71,getnamedoperandidx:54,creal:[14,2],movsx32rr8:84,googl:107,discrimin:[84,92,23,102],extract:[],emphas:[92,115],collis:[43,23,92,16,56],writabl:56,freestand:23,genuin:16,of_list:[12,13,14,15,18,19],benchspec:35,bpf_ld
x:84,numexpress:71,spiffysh:20,allowsanysmalls:16,mask:[],shadowlist:54,tricki:[73,76,92,86],mimic:92,createuitofp:[41,43,47,2,49,50],prealloc:16,cpp:[92,0,34,4,99,5,65,41,8,43,113,98,47,2,49,50,10,101,54,73,20,56,76,21,24,61,26,84,87,66],cpu:[84,54,67,34,26,1,9,36,76,77,112,57,80,23,31],illustr:[45,43,23,20,47,56,50,76,90,78,113,12,15,16,17,18,19],labeltyp:16,scc:[],dw_at_apple_properti:56,mno:31,fntree:34,smp:76,dw_lang_c99:[23,56],add16ri:6,incap:[40,11,112],add16rm:6,only_tool:[24,66],tail:[],add16rr:6,norm:[66,30,116],getframeinfo:[84,54],"102kb":20,gcov_prefix_strip:95,candid:[],element_typ:[12,13,14,15,19],attr0:112,attr1:112,strang:[],condition:[73,1],quux:92,retcc_x86_32_c:54,sane:[45,61,17,86],small:[92,34,35,94,38,4,23,71,39,41,8,44,45,10,51,16,17,102,103,73,20,56,76,80,83,26,84,110,27,88,112,28,31],release_xi:94,impract:16,stackgrowsdown:54,"__image_info":23,sync:[24,26,67,86,8],past:[41,107,54,103,23,92,2,27,72,14,16,116],pass:[],suboptim:31,fneg:23,deleg:[108,92,23,86]
,xor:[],registerregalloc:76,clock:[76,23],section:[],delet:[],succinct:1,letlist:30,contrast:[102,43,108,84,76,19],hasn:[76,103,16,50],full:[],hash:[],vtabl:[92,5,104],unmodifi:72,tailcal:84,blocknam:112,inher:[23,98,16],parenthesi:[113,92,18],dw_tag_arg_vari:[41,23],islvalu:92,simpleproject:61,myownp3sett:56,shufflevector:[],prior:[71,24,108,20,84,48,76,27,112,28,23,31],lto_module_get_symbol_nam:90,pick:[],action:[],narrowaddr:23,token_prec:[12,13,14,15,18,19],via:[],depart:[92,97],dw_tag_namespac:56,ifcond:[41,47,2,49,13,14,15],vim:[24,115,6,66],memrr:54,image_sym_class_member_of_union:109,ifcont:[41,47,2,49,13,14,15],unbias:59,decrement:108,select:[],x44:109,stdout:[24,26,109,37,12,13,14,15,23,18,19],llvm_doxygen_qch_filenam:61,targetselect:[41,47,2,49,50],objectivec:23,isconst:[16,112],more:[],isintegerti:16,door:102,tester:[],hundr:51,sahf:84,zeroext:[23,112],addcom:73,webkit:[88,23],multiset:16,compani:27,cach:[75,32,41,61,42,23,56,84,36,86,76,88,16],uint64:[91,88],llvm_on_uni
x:4,enable_if:102,sparcv8:23,at_apple_properti:56,x86callingconv:54,isnullvalu:34,returntyp:[73,23],learn:[24,40,92,107,34,47,115,11,23,15,16],cmpinst:16,add_librari:61,bogu:76,scan:[76,40,92,73,34,26,1,77,50,10,21,11,12,80,84,31],challeng:[72,14,92,2],registr:[],accept:[24,92,107,25,8,102,5,20,98,94,64,37,27,22,23,34,29,16,30,116],pessim:[91,32],x86instrinfo:54,reconstruct:[56,97,103],v_reg:84,huge:[24,92,10,21,27,6],llvmgrep:24,readobj:[],attrpchwrit:21,clangxx:10,appenduniqu:23,simpl:[],prefetch:[],d14:54,plant:76,referenc:[34,23,41,43,113,47,2,49,50,12,13,14,15,16,18,19,54,20,104,56,111,60,90,64,112,30],spillalign:54,variant:[76,32,54,16,20,10,28,88,23,13,12,4,14,15,5,17,18,19],unsound:72,plane:[14,2],dllvm_use_sanit:26,maywritetomemori:[16,86],circumst:[54,5,47,50,76,23,108,12,66,15,16],github:[24,26,16,107,53],arcanist:[39,107],d13:54,llvmbitcod:65,imm_eq0:6,atan2:[45,17],nvidia:[84,8],returns_signed_char:23,constitu:[13,49],ith:16,trade:[83,16],i386:[79,84,23],paper:[39,105,9
2,16,84],vec2:[23,16],vec0:23,vec1:[23,16],bou_unset:20,nifti:[76,13,40,11,49],bpf_jmp:84,alli:23,bypass:23,superflu:103,targetselectiondag:[65,84,54],image_sym_type_void:109,argsv:[41,43,47,2,49,50],cond_next:[15,47],authent:[114,105],achiev:[],tokcodefrag:30,lto_module_is_object_file_in_memory_for_target:90,found:[32,62,0,33,84,94,37,38,69,4,5,39,41,97,8,43,44,47,2,10,14,15,16,52,19,54,73,20,56,76,23,24,61,82,83,31,42,87,67,27,108,66,90,26],gettermin:16,errata:105,bpf_mem:84,quesion:34,"0b000011":54,procedur:[60,105,45,34,20,94,3,78,16,17,52],realli:[],notabili:31,loweralloc:76,getcalleesavedreg:54,reduct:[],reconstitut:23,ftp:24,agre:[32,27,67],ftz:8,stackframes:73,research:[39,35,65],sparingli:51,x86genregisterinfo:[84,54],occurr:[],ftl:[88,23],loopbb:[41,47,2,49],isfirstclasstyp:34,distoth:66,mrm0r:54,polyhedra:31,numabbrevop:112,believ:[92,23,2,49,50,27,12,13,14,16],"__cxa_begin_catch":108,mrm0m:54,wall:[76,40,1,11],fnptrval:23,xxxend:16,struggl:24,amper:36,testament:[45,17],g
e_missing_jmp_buf:92,new_then_bb:[13,14,15],cst_code_integ:112,instprint:21,dw_at_high_pc:56,curesult:8,unprofit:32,number:[],distchecktop:66,obj_root:[24,87],horribl:92,dw_at_low_pc:56,differ:[],exponenti:[32,20,23],checkpoint:108,unrecogniz:111,functionast:[41,43,113,47,2,49,50],illeg:[32,84,103,8,23,20,0,50,72,16,26,98],mcjit_module_:50,dfa:[84,21,106],fptr:[41,47,2,49,50],relationship:[],toplevelexpr:[41,43,113,47,2,49,50,12,13,14,15,18,19],bio_writ:26,dagarglist:30,consult:[24,60,97,39,76,37,66],compute_pgm_rsrc1_vgpr:25,aad:84,llvm_svn_rw:99,tokstr:30,seamlessli:90,reus:[84,56,76,27,88,23],arrang:[76,32,102,73,20,84,10,23],comput:[],packag:[],qpx:[31,23],returns_twic:23,flto:64,equival:[32,92,34,23,40,8,50,11,16,103,73,20,22,78,80,24,25,108,84,86,112,66,30,116],odd:[20,27,92,31,62],self:[],also:[],"__main":76,ex2:8,ptrb:8,ptrc:8,coff:[],ptra:8,pipelin:[76,32,41,54,8,72,31,47,2,49,50,10,51,112,38,12,13,14,15,23],unset_vari:66,rhs_val:[12,13,14,15,19],plai:[40,34,45,76,11,30,17]
,"_z3foov":23,dstindex:54,plan:[],exn:23,ptr7:23,alu32_rr:69,"0x14c":109,ptr2:23,ptr3:23,ptr0:23,ptr1:23,ext:78,abnorm:[4,51],exp:[],rewritestatepointsforgc:[],pubnam:56,gold:[],getsymbolnam:54,xcode:[24,61,99],gcmetadaprint:73,session:[115,16,99],tracevalu:32,affin:31,ugt:23,impact:[92,73,16,56,51,23],cr0:23,cr7:23,addrri:54,writer:[],solut:[],printdatadirect:54,baseregisterinfo:21,llvm_executionengin:[12,13,14,15],factor:[92,0,16,84,23,6,116],bernstein:56,i64imm:54,llvm_obj_dir:98,microprocessor:[84,23,54],regstat:84,mainten:[69,27,90],noaa:32,f2_1:54,synthet:54,f2_2:54,synthes:[12,65,92,56,50],"__stack_chk_fail":23,machinememoperand:86,coerce_offset0:5,link_compon:[66,52],set:[],image_sym_class_member_of_enum:109,seq:109,creator:[76,61],overwhelm:[45,17],startup:[24,92,8,1,63,23],cbpf:84,see:[],sed:[24,98,66],sec:23,sea:[105,25],overboard:92,analog:[73,23,116,16,72],seh:[108,23],v_mov_b32:25,reglist:54,parsenumberexpr:[41,43,113,47,2,49,50],lto_codegen_cr:90,topmost:73,restructur
:[108,31],subdir:66,documentlisttrait:67,thrive:39,signatur:[24,97,72,31,84,76,78,38,23],machineoperand:[84,54],javascript:[23,40,11,88],libnam:[76,66,101],myocamlbuild:[12,13,14,15,19],disallow:[103,72,20,88,28,23],nohup:33,dividend:[84,23],proj_src_dir:66,sparctargetlow:54,last:[92,0,72,1,94,102,23,41,97,43,5,45,2,10,14,16,19,54,20,76,108,31,84,27,112,115,30,116],operarand:3,cmake_cxx_flags_relwithdebinfo:24,whole:[32,92,34,35,23,65,97,113,9,49,50,10,12,13,16,18,73,76,57,26,84,27,28],lower16:22,partialalia:42,load:[],episod:[13,49],pointkind:73,dw_tag_namelist:56,hollow:67,lex:[41,45,12,13,14,15,30,17,18,19],thedoc:67,functionpass:[],"0x100000f24":79,"0xa":84,worthless:92,static_cast:[41,47],devic:[7,96,82,8,93,74,36],perpetu:27,sinc:[62,67,33,34,36,94,37,92,69,4,23,6,75,41,84,8,43,113,45,98,9,2,49,50,47,12,13,14,15,16,18,19,54,103,73,102,20,56,76,59,97,24,72,108,31,42,85,27,88,112,66,115,30,26],"0xe":112,devis:52,firm:66,gettokpreced:[41,43,113,47,2,49,50],fire:[108,92,83],func:[
71,7,23,76,12,13,14,15,16,18,19],registerpass:76,rdtsc:23,uncertain:92,straight:[42,43,34,45,84,116,113,57,4,72,16,17,18,19],erron:[24,20],histor:[92,103,16,86,10,23],durat:[76,84,42],passmanag:[],signature_invalid:24,error:[],dvariabl:61,v1size:42,pound:[66,67],binutil:[114,24,105,9,64],genregisternam:84,miscommun:27,inst_invok:112,chase:62,i29:23,decor:56,irrelev:[103,42],initializerconst:23,i20:23,i24:23,x64:[114,24,5,108],shorter:31,funni:[15,47],decod:[],dllvm_enable_sphinx:24,built_sourc:66,global_end:16,bitread:28,image_sym_class_union_tag:109,dw_at_declar:56,stack:[],recent:[24,33,108,26,67,73,27,23],call32r:116,eleg:[40,113,49,50,11,12,13,18],rdi:[84,88,6],dw_apple_property_readwrit:56,llvm_unreach:[34,92],person:[],parse_prototyp:[12,13,14,15,18,19],expens:[91,32,92,54,34,20,86,76,108,16],call32m:116,llvm_tablegen:61,crosscompil:[84,9],else_v:[13,14,15],immutablepass:[],debug_level:20,simd:[80,77,23,0],numshadowbyt:88,sidebar:94,mandat:84,smooshlab:39,eager:16,input:[],san
iti:[28,24,66],transpar:[65,92,107,103,16,20,90],subfield:116,intuit:23,dw_tag_ptr_to_member_typ:[23,56],"0x00000048c979":26,formal:[34,16,6,23,116],llvmgettargetmachinedata:31,todefin:21,atomicexpand:86,ivar:56,stylist:92,funcresolv:16,image_sym_type_nul:109,parse_toplevel:[12,13,14,15,18,19],ii32:116,x86framelow:84,moduleid:[10,43,19],encount:[23,111,84,16,54],image_file_debug_strip:109,sampl:[],sight:[15,47],itanium_abi_tripl:10,attrvisitor:21,libssl:26,"_bool":[15,47],p5i8:8,llvm_obj_root:[10,66,35,52],xxxgendagisel:54,reloc:[],agreement:27,wget:[24,26],materi:34,codeemittergen:21,find_first_of:50,image_sym_type_long:109,condbranch:54,oneormor:20,getinsertblock:[41,47,2,49],putchard:[40,41,43,47,2,49,50,11,12,13,14,15],primarili:[24,7,46,32,73,48,26,1,2,55,36,28,14,84,16,58,116],getimm:54,xxxinstrformat:54,requires_rtti:63,contributor:27,volcan:25,pcre:26,occupi:[23,97],span:[76,92,6],submit:[],custom:[],getpointeetyp:31,createcondbr:[41,47,2,49],parse_arg:[12,13,14,15,18,19],ex
pound:56,subgraph:32,atop:73,nodupl:23,atoi:23,link:[],atom:[],line:[],mitig:73,workitem_vgpr_count:25,cie:60,cin:98,intim:92,hex8:67,"0xffffffff":[23,112],pointi:67,call_site_num:108,"char":[92,0,99,23,71,41,97,8,43,113,47,2,49,50,12,13,14,15,16,17,18,19,54,103,20,56,76,31,42,90,26],srcvalu:72,linkonceodrlinkag:16,tok_unari:[41,47,2],intrepid:[113,18],elfv2:31,xxxcodeemitt:54,ud2a:84,kwalifi:109,scrape:1,download_prerequisit:24,disp32:84,isnotduplic:6,"0x000000000059c583":99,caml:[],lang:20,mayalia:42,land:[72,27,23,48,108],x86codeemitt:54,algorithm:[],agg:23,libstdc:[24,92,9],fresh:[24,26,66],hello:[],mustalia:42,llvmcontext:[],mypassmanag:31,code:[],partial:[],resultv:23,scratch:[23,84,16,54],personalityfn:112,setcc:[84,16],globallisttyp:16,printimplicitdef:54,young:16,send:[],tr1:16,sens:[40,92,61,97,103,42,43,23,20,84,48,86,56,11,72,16,98,19],getprocesstripl:41,sent:[39,27,107,93,94,77,72,110],unzip:[33,24],flagscpumask:67,clearresourc:84,registeredarg:73,tri:[32,61,54,34,45,84
,83,76,115,23,17],bsd4:97,setconvertact:54,dname:20,libfil:101,trc:84,scalabl:42,tre:32,fewer:[73,32,72],"try":[],race:[23,16,86],build_uitofp:[12,13,14,15,19],vehicl:92,use_s:16,monospac:115,natur:[],odr:23,proj_obj_dir:66,psubu:10,n64:31,video:16,ueq:[47,15,23],index:[],step_val:[13,14,15],targetregisterclass:[84,54],asmwrit:[],test_fuzz:26,henceforth:[85,23],paramti:112,image_scn_align_64byt:109,dyn_cast_or_nul:16,lllexer:65,leb:71,dw_tag_gnu_template_param_pack:23,mappingtrait:67,len:23,bitstreamwrit:65,rglob:7,let:[],ubuntu:[24,9,36],ptx30:84,openmp:27,great:[92,73,45,84,2,76,27,51,66,14,16,17],survei:105,dllvm_enable_doxygen:61,oneargfprw:116,force_off:61,technolog:[90,31,11,40],rdx:[72,84,88,6],flagshollow:67,cta:8,ifloc:41,sgt:23,pf1:34,pf0:34,dfpregsregisterclass:54,sgn:23,llvm_enable_cxx1i:61,sge:23,movsx32rr16:84,"__________":16,getnumparam:16,eltti:[41,112],zip:[24,66],commun:[],my_fmad:8,doubl:[32,67,34,37,23,40,41,105,102,43,5,45,47,2,49,50,11,12,13,14,15,16,17,18,19,5
4,20,84,112,113,66,116],upgrad:[],next:[],doubt:[115,102],lock:[76,23,16,86],commut:[32,84,54,42],fpregsclass:54,avx512:23,gladli:[24,37],firstcondit:16,bunzip2:24,objectslo:66,uvari:61,get_instrinfo_operand_enum:54,safepoint_pol:72,devmajor:8,erasur:16,intregssuperregclass:54,thin:16,gc_root:72,statepoint_token:72,dw_form_data4:56,n2431:92,weaker:23,dw_form_data1:56,dw_form_data2:56,n2437:92,process:[],n2439:92,preformat:115,high:[],wavefront_s:25,fprintf:[41,43,113,47,2,49,50],streamer:84,dw_ate_signed_char:23,onlin:[15,47],adc32mi8:6,visitsrl:65,delai:[34,31,16],"__builtin_call_with_static_chain":31,saveguard:31,infeas:60,allocainst:[92,16,47,41,15,23],cuda:[84,105,8],npo:50,nullpointerexcept:91,overridden:[],singular:[92,16],surfac:84,xc3:109,loc0:88,loc1:88,xc7:109,xc4:109,x86registerinfo:[84,54],optyp:54,dw_tag_class_typ:[23,56],alloc:[],essenti:[54,73,16,74,86,112,34,30],install_prefix:61,sdiv:[],counter:[],robot:39,element:[],liveintervalanalysi:84,unaccept:27,allow:[],retva
l:[41,43,47,2,49,50,23],stepexpr:[41,15,47,2,49],movl:[23,5,88,72],decltyp:[92,23],fstrict:23,movi:92,typecod:65,insight:[71,23],stacksav:[],movz:[23,78],movw:[23,22],movt:22,ofstream:20,movq:[72,88],perfect:[27,78],chosen:[92,73,84,1,78,23],cond_tru:[15,47],lastinst:54,decad:6,therefor:[71,32,67,103,8,73,23,20,84,86,76,27,88,78,108,29,16],python:[24,40,33,31,1,9,10,73,37,11,30],initializenativetarget:[41,47,2,49,50],overal:[107,103,73,108,84,49,21,27,13,23],innermost:0,facilit:[92,16,67,56,27,23,52],add32rr:6,fcc_val:54,anyth:[32,92,37,6,43,98,49,50,12,13,16,19,102,56,77,80,24,84,86,87,27,88],cross_ov:26,xvjf:24,truth:[13,23,49],"0b111":116,llvminitializesparcasmprint:54,compute_xx:8,idxmask:23,subset:[40,103,8,23,35,1,42,56,10,27,11,16],"0x7fffffffe040":99,bump:[73,85,16],"0x400":56,lsampl:52,"static":[],uiuc:27,unique_ptr:[41,47,2,49,50],variabl:[],contigu:[23,16,56],possbil:67,tok_if:[41,47,2,49],tok_in:[41,47,2,49],dw_tag_shared_typ:56,shut:[92,54],initializepass:42,bpf_dw:84,u
npars:[113,1,18],tempt:[4,92,24],image_file_system:109,shortest:[34,30],bam:92,image_sym_class_sect:109,spill:[72,84,88,54,80],runtimevers:[23,56],unnam:[32,20,92,30,23],lexer:[],scari:[40,11,17,45],length:[],enforc:[92,73,5,20,84,86,27,88,23,16,116],outsid:[],scare:27,noitinerari:[6,54],softwar:[],denorm:[67,23],add_pt:69,spaghetti:[45,17],selectiondagnod:54,fcontext:41,owner:[],stringswitch:21,add_pf:69,featurev9:54,sparcgensubtarget:54,licens:[],system:[],parse_oper:[14,15],gcse:[76,32,16],termin:[],f_inlined_into_main:79,llvmgcc:66,low:[],ldrex:86,gotcha:92,endexpr:[41,15,47,2,49],baseclasslist:30,"12x10":23,haven:[76,35,92,23],"0x40":56,bother:[15,47],fcc_u:54,"__llvm_coverage_map":71,featurevi:54,stricter:[5,86],f1f2:34,xxxregisterinfo:54,tdtag:21,getzextvalu:16,viewer:92,op_end:16,var_arg_function_typ:19,clearli:[88,27,92],optimis:12,mdstring:3,"0x00002200":56,tramp1:23,accuraci:[32,23],at_typ:56,rvalu:92,type_of:[12,13,14,15,19],courtesi:27,griddim:8,poison4:23,poison3:23,po
ison2:23,zec12:31,incfil:66,setloadextact:54,placement:[],stronger:[23,16,86,72],parsevarexpr:[41,47],face:[76,4,21,92,85],isbranch:6,orcmcjitreplac:31,brew:16,linkonc:[],fact:[92,23,40,97,42,43,98,47,2,50,11,51,12,14,15,16,102,103,20,76,24,60,108,31,84,27,28,30,116],movslq:88,dbn:24,borderlin:92,truedest:23,dbg:[],bring:[40,92,73,72,11,16],rough:[116,30,86,103],trivial:[],redirect:[10,44,26,41,94],roots_end:73,getelementptr:[],hash_data_count:56,"0x01":[71,6,56],should:[],jan:97,tape:24,create_funct:[12,13,14,15],find_first_not_of:50,opreand:16,nonzero:[112,116],hope:[92,73,34,63,27,72],meant:[71,24,39,33,30,74,37,23,34,66,115,16,116],move:[],familiar:[24,41,102,25,8,34,45,84,49,76,66,13,17],memcpi:[],autom:[24,107,84,21,27,6,52],smash:23,isatleastreleas:86,symtab:16,ptr_rc:84,reid:4,dw_ate_sign:[23,56],stuff:[],booltmp:[41,43,47,2,49,50,12,13,14,15,19],tok_def:[41,43,113,45,47,2,49,50],comma:[20,67,87,49,13,29,23,116],unimport:[33,72],cmake_cxx_compil:24,temporarili:[66,83],binary
_nam:79,oprofil:[63,61],writetypet:65,wire:98,op_iter:16,fakesourc:66,verilog:31,live_iter:73,sectionmemorymanag:[75,41,47,2,49,50],unrecurs:[15,47,41],email:[24,40,60,107,39,86,27,11],superword:[60,0],dislik:27,linkonceanylinkag:16,memri:[84,54],mrecip:31,use_iter:16,doxygen:[],scalaropt:101,valgrind:[10,44,1,62],sdtc:54,etc:[],"0fbf317200":8,vk_basicblock:92,preheader_bb:[13,14],position_at_end:[12,13,14,15,19],exprprec:[41,43,113,47,2,49,50],indici:112,distil:10,bininteg:30,rpcc:23,llvm_external_:61,triniti:105,insuffici:[4,23,36,54,56],path_to_llvm:24,immedi:[32,92,72,23,75,40,97,8,98,47,50,11,12,84,16,54,76,15,25,108,42,86,88,112,29,116],hex16:67,deliber:[92,88],image_sym_type_char:109,togeth:[32,92,78,0,34,35,5,71,40,97,42,43,44,45,2,49,10,11,13,14,16,17,18,19,73,20,74,56,76,111,23,59,82,83,31,84,110,27,113,28,26,116],allocationinst:16,my_jit_tool:66,sphinx_output_man:61,rbx:[84,6],dataflow:[47,15,23],cvt:8,reloc_absolute_dword:54,rbp:[84,6],suport:16,llvm_tools_binary_dir:61,
p0f_isvoidf:72,lto_module_create_from_memori:90,immtyp:6,libxml2:9,apfloat:[24,41,43,47,2,49,50,19],site:[],sn_map:34,archiv:[],incom:[54,23,84,47,49,27,13,14,15,16],surprisingli:[24,113,50,51,12,18],uncategor:20,mutat:[],referenti:32,basicblocklisttyp:16,lex_com:[12,13,14,15,17,18,19],dan:67,preserve_mostcc:[23,112],phi:[],kernarg_segment_align:25,expans:[71,54,30,84,95,57,23],upon:[75,98,54,73,16,74,56,27,66,23,52],foldmemoryoperand:[84,54],php:107,expand:[],micromips32:31,off:[92,72,23,6,40,41,97,8,43,45,47,2,49,50,10,11,12,13,14,15,16,17,19,24,61,83,31,84,63,27],symbol2:22,diversifi:26,argnam:[41,43,113,20,47,2,49,50],a_ctor_bas:5,command:[],filesystem:[1,9],outputfilenam:20,newest:22,ptrval:23,less:[32,92,33,34,1,36,48,95,23,6,71,40,41,97,42,43,113,45,98,47,2,49,50,10,11,12,13,14,15,16,17,18,19,73,20,56,78,24,31,84,112,115,26],value_2:28,web:[],makefil:[],blockfrequencyinfo:[39,59],exempt:92,ptx31:84,target_opt:87,nonnul:[23,51],nvt:54,unintrus:23,indvar:[],goingn:16,piec:[62,9
4,92,23,41,43,113,45,47,2,49,10,13,14,15,83,17,18,19,103,56,24,26,84,27,112,28,116],placesafepoint:[],core2:10,five:[108,20,84,16],release_16:24,tick:97,recurs:[32,72,1,23,40,43,113,45,47,2,49,11,13,14,15,16,17,18,19,73,21,66],recurr:32,desc:[76,20,54],addsdrm:116,resid:[112,8,73,26,56,76,78,23,31],emmc:36,loopinfobas:16,isus:84,objectbuff:75,byteswap:65,resiz:92,"0x29273623":56,captur:[23,40,41,43,5,47,2,49,50,10,11,12,13,14,15,83,18,19,20,65,56,84,88,112,113],vsx:[31,23],main_loop:[12,13,14,15,18,19],build_exampl:66,mem2ref:72,i64:[54,8,5,84,56,3,88,78,72,103,23,6],i65:23,safepoint_token:72,flush:[75,92,8,36,12,13,14,15,23,18,19],guarante:[],transport:31,ltmp1:72,"__syncthread":8,avoid:[],image_sym_class_fil:109,arg_siz:[41,43,47,2,49,50,73,16],barlist:92,multidimension:23,stage:[39,54,8,33,44,20,84,94,95,113,34,90,18],"0x4200":56,c_str:[41,8,43,113,20,47,2,49,50,16,45],interven:88,nullari:[113,18],declcontext:102,dw_op_deref:23,getbitwidth:16,not_nul:91,handleextern:[41,43,113,47
,2,49,50],dw_tag_base_typ:[23,56],retcc_x86_32:54,takecallback:16,waterfal:114,mere:[32,103,43,72,37,23,19],merg:[],createsubroutinetyp:41,bclinklib:66,valuesuffix:30,multidef:116,textfileread:92,getmodulefornewfunct:50,p4i8:8,mandel:[14,2],mdnode:[3,23,56],"function":[],namedvalu:[41,43,47,2,49,50],innoc:[13,49],documentlist:67,getenv:4,dw_at_entry_pc:56,inst_cal:112,data16bitsdirect:54,lookup_funct:[12,13,14,15,19],evidenc:103,localexec:[23,112],otherwis:[32,92,67,34,1,36,94,95,38,5,71,7,41,96,43,44,45,46,9,2,49,50,51,47,12,13,14,15,16,17,18,19,101,55,73,90,20,74,76,77,23,89,80,58,59,93,60,61,82,25,72,83,26,62,86,113,112,108,66,106,30,116],problem:[],"int":[92,78,0,34,48,37,69,99,5,6,71,40,41,84,8,43,44,45,98,47,2,49,50,11,72,12,13,14,15,16,18,19,54,103,73,90,20,56,23,79,24,83,26,42,109,86,67,64,113,115,30,116],filenam:[92,93,5,38,70,6,71,7,41,96,44,101,20,74,56,77,23,89,80,58,61,82,110,111,66,106,116],rightli:66,ini:28,ind:41,inf:[80,20,77,23,56],ing:[32,92,43,47,50,12,15,19],inc
:[24,54,84,76,21,69,66],filenameindex0:71,bzip2:[24,66],nonetheless:23,optsiz:[23,112],libcxx:[33,31],lookup:[],varieti:[92,36,40,105,97,42,43,2,49,50,11,12,13,14,16,19,73,56,24,60,108,31,84,86,88,112,28,30],getopt:20,liblzma:9,computearea:102,aliasresult:42,"__cxa_allocate_except":108,potenti:[32,92,72,1,94,23,42,113,45,98,49,51,13,83,17,18,20,24,108,26,84,27,88],kernarg_segment_byte_s:25,emitsymbolattribut:84,fexist:34,in0:23,in1:[84,23],in2:84,instrssrr:116,eof:[41,43,113,26,47,2,49,50,45],header_data:56,cumemfre:8,rule:[],"__sync_":86,configmaxtest:16,hashes_count:56,sourceloc:41,sm_20:[84,8],sm_21:84,untrust:27,"0x16151f0":99,show_bug:26,"const":[],r8b:6,r8d:6,deviat:[84,92,22],matlab:31,binoppreced:[41,43,113,47,2,49,50],worth:[83,92,16,36,102],r8w:6,rowfield:69,hasfparmv8:6,printnextinstruct:16,getpar:[47,41,16,2,49],llvm_enable_ffi:61,cmd:107,upload:107,defens:27,mllvm:0,unmanag:72,math:[],add_rr:116,add_char:[12,13,14,15,17,18,19],externally_initi:[23,112],callcount:16,cmp:
[32,84,16,23],pty:23,soutbio:26,hork:116,consequ:[24,42,23,83,10,88,108,66,16],image_scn_mem_shar:109,llvmbuild:[],runfunctionasmain:99,loop_bb:[13,14,15],flaghollow:67,topolog:5,told:92,ontwo:23,somefunc:[92,16],mcoperand:84,pred_end:16,dw_op_bit_piec:23,myregisteralloc:76,dw_virtuality_pure_virtu:23,optzn:[41,62,47,2,49,50,12,13,14,15],"0f7f800000":8,aka:[41,42,43,23,45,84,47,2,49,50,113,12,13,14,15,16,17,18,19],werror:64,dcmake_cxx_link_flag:24,idnam:[41,43,113,47,2,49,50],instr:[71,73,84,110,95,106,116],setgc:73,sspstrong:23,ftoi:54,total:[32,23,35,85,86,56,76,112,38,34,16],bra:8,highli:[73,16,26,84,47,51,15,23,52],bookkeep:[32,16],plot:[14,2],postincr:92,bleed:39,foster:[4,27],greedi:[84,20,77],simplifycfg:[],setreg:84,v_mul_i32_i24_e32:25,iscommut:6,int16_t:[67,54],rediscov:[40,11],reinterpret:78,numberofauxsymbol:109,toolkit:[16,8],tblegen:21,valueenumer:65,armgenasmmatch:21,insignific:[88,46,23],err:[76,26,16,8],restor:[41,54,85,84,47,2,49,48,112,108,13,14,15,23],next_prec:[
12,13,14,15,18,19],work:[],foo_ctor:48,coalesc:[80,46,16,84],b32:8,viewcfgonli:[16,49],could:[],"16gb":114,novic:61,autodetect:[80,77,95],dllvm_enable_assert:24,u64:8,indic:[],somefil:98,deepcheck:16,unavail:[86,54],constantstruct:16,createinstructioncombiningpass:[41,47,2,49,50],str2:116,ordinari:[71,67,23],lexloc:41,sever:[32,92,33,34,35,1,38,4,23,6,71,39,40,97,42,43,98,49,10,11,13,16,52,19,54,73,20,65,56,76,21,57,24,61,82,83,26,84,87,110,112,108,66,90,31,116],verifi:[],bindir:[66,101],ssl_set_bio:26,recogn:[32,41,35,45,34,20,84,49,90,13,23,17],superreg:54,rebas:24,lad:20,chines:24,after:[],hex32:67,lab:[114,39,26],law:92,demonstr:[71,102,54,43,23,31,50,12,16,19],sparccallingconv:54,domin:[],sgpr:23,opaqu:[],lto_module_dispos:90,recompil:[91,42,31,49,88,78,13],icmpinst:16,buildslav:114,spilt:84,order:[],movhpd:5,hex64:67,diagnos:[76,46,0],use_camlp4:[12,13,14,15,18,19],offici:[],opnod:54,llvmsystem:66,pascal:23,noimm:6,getnexttoken:[41,43,113,47,2,49,50],flexibl:[],getattribut:34,
bytecod:[31,112,87],isascii:[41,43,113,47,2,49,50],isellow:21,setoperationact:[84,54],isunpredicatedtermin:54,them:[32,92,78,67,33,34,35,95,37,69,4,113,5,71,39,40,41,84,8,43,44,45,98,9,2,49,50,10,11,51,47,12,13,14,15,16,17,18,19,54,103,73,102,20,56,76,111,23,57,97,24,61,82,72,83,31,42,85,86,87,110,63,27,88,52,112,108,28,66,29,90,116],dw_apple_property_atom:56,thei:[91,32,92,78,0,33,34,35,1,36,94,38,69,4,5,6,71,39,40,102,97,42,43,44,46,47,48,49,50,10,11,51,72,12,13,15,16,98,18,19,54,103,73,113,20,74,56,76,21,23,80,111,24,60,83,31,84,86,87,67,27,88,52,112,108,28,66,29,26,116],fragment:[55,73,16,35,84,56,23,30,116],safe:[],printccoperand:54,scene:16,"break":[],bang:30,astread:21,selti:23,lifelong:39,stdarg:23,"__cxa_rethrow":108,sequentialtyp:16,monolith:[27,85],"0x000003cd":56,const_op_iter:16,network:[31,84],visiticmpinst:83,sprintf:50,lib64:[24,61],forth:78,image_file_relocs_strip:109,multilin:[1,30,116],srcmakefil:66,registeralias:21,ms_abi_tripl:10,barrier:[],multilib:9,standard:[
],nth:92,fixm:[24,54,50],shadowstackgclow:73,debuglev:20,mvt:[84,54],angl:[92,67],zerodirect:54,regress:[],gcregistri:73,subtl:[40,103,113,26,49,50,11,12,13,18],refil:34,render:[23,14,84,16,2],printdeclar:54,subreg:54,i48:23,setcondcodeact:54,llvm_build_32_bit:61,"0x00000000016677e0":99,ispredic:6,libllvmir:16,image_file_bytes_reversed_hi:109,isalpha:[41,43,113,45,47,2,49,50],baseclasslistn:30,power7:31,john:[27,92],"40th":[45,17],headerdata:56,getdatasect:73,inexact:23,still_poison:23,registerpasspars:76,gcmetadataprinterregistri:73,analyzebranch:54,tex:35,llvm_build_root:61,target:[],provid:[],cppflag:[66,52],minut:24,uint64_t:[34,67,50,57,16,59],hassse2:116,hassse3:116,emitfunctionstub:54,contenti:92,n1737:92,manner:[71,24,54,103,108,23,84,86,87,27,72,16],strength:[],recreat:[24,67,23],is_nul:91,laden:[40,11],latter:[54,72,84,86,113,23,34,16,18],image_rel_amd64_secrel:22,"0x400528":79,postcal:73,llvm_doxygen_qhp_namespac:61,smul_lohi:84,bruce:16,cumodul:8,dllvm_use_sanitize_cover
ag:26,lexic:[],keystrok:92,retcc_sparc32:54,passthru:23,valuerequir:20,instritinclass:6,bracket:[92,108,67,56,27,28,23],unchang:[23,16,42],notion:[92,102,84,56,49,50,76,27,12,13,23],bpf_jeq:84,md_prof:3,opposit:[66,60,97,67],"__cxa_throw_except":108,tailcallopt:[84,23],buildbot:[],op0:112,involv:[32,92,67,72,94,69,4,23,65,41,42,113,47,49,51,13,15,16,18,54,103,73,59,31,84,86,66],op2:23,the_funct:[12,13,14,15,19],"41m":20,wzr:23,sroa:60,baseopcod:[69,54],latenc:[80,84,23],callbackvh:16,govern:23,instlisttyp:16,predecessor:[],showdebug:99,likewis:[24,23],tag_memb:56,llvm_include_tool:61,subtarget:[],"__mips_isa_rev":31,didescriptor:56,numregionarrai:71,lit_arg:10,fomit:84,isosdarwin:41,emb:[23,40,11,112],cleanli:[76,92,27,23,94],st_uid:97,cudevicegetcount:8,memorywithorigin:61,movsx32rm16:84,chapuni:39,dw_ate_float:[41,23],eatomtypedieoffset:56,awar:[],sphinxquickstarttempl:[115,87],unordered_set:16,awai:[32,92,102,73,5,45,56,59,76,90,23,16,17],getiniti:16,accord:[61,102,54,33,16,20,67
,94,73,88,112,72,23,59],unsett:76,newnam:50,smallsetvector:16,preprocessor:[71,40,61,54,20,98,50,95,11,12,66,16],isjumptableindex:54,behaviour:[],image_file_machine_armnt:109,cov:[],howev:[91,92,0,72,35,48,37,69,4,23,6,75,40,97,42,98,47,2,49,50,10,11,12,13,14,15,16,103,73,20,56,76,22,78,24,107,83,84,85,86,63,64,27,88,112,28,66,115],shouldn:[75,92,42,20,9,17,66,23,45],jitcompilerfn:54,calltmp:[41,43,47,2,49,50,12,13,14,15,19],ilp:[31,0],xmm6:[6,116],com:[24,92,107,53,26,27,16],ctxt:67,con:[30,78],testcleanup:23,widen:[84,0],xmm4:[6,116],resultti:23,exeext:[10,66],getbasicblocklist:[47,41,16,2,49],permut:23,prologu:[],wider:[65,86,103],add_instruction_combin:[12,13,14,15],xmm8:6,speak:[13,14,2,49],degener:[32,15,47],"__builtin_expect":3,macport:63,debug_info:56,subscrib:[27,107],mallocbench:35,compatible_class:84,machineblockfrequencyinfo:59,hoist:[32,16,86,88,42],unclutt:4,use_llvm:[12,13,14,15,19],binaryoper:[92,16],inhibit:23,ident:[32,92,34,23,97,42,5,47,49,50,10,12,13,14,15,16,17
,18,19,73,56,78,84],aix:[84,105],gnu:[76,24,92,61,97,54,108,84,36,87,10,64,111,114,66,23,116],zlib:[24,61],cxx_statu:92,aim:[71,92,44,83,27,78,4,23],scalarrepl:[],pairwis:42,publicli:[16,56],aid:[73,31],vagu:27,keytyp:56,u999999:107,xstep:[14,2],printabl:[23,97,54],conv:98,theexecutionengin:[41,47,2,49,50],extractloop:32,shadowstackgc:73,uint32x2_t:78,cond:[41,54,98,47,2,49,13,14,15,23,59],int_of_float:[14,15],dw_tag_label:56,old_val:[13,14,15],descent:[113,45,2,14,17,18],incorrectli:[43,45,92,19],perform:[],helperfun:50,descend:23,doxgyen:61,addintervalsforspil:84,fragil:[],code_own:27,evil:[16,6,78],hand:[32,92,67,33,34,4,6,102,43,113,45,2,50,11,12,14,16,17,18,19,54,103,73,21,57,61,31,84,86],fuse:[32,23,80],use_llvm_scalar_opt:[12,13,14,15],disassembleremitt:21,operandv:[41,47,2],kept:[76,27,92,60,42],undesir:23,scenario:[10,83,98,16,86],thu:[32,92,34,23,71,84,42,43,113,98,2,49,50,10,51,72,12,13,14,15,16,18,19,73,20,56,76,59,107,83,62,27,112,108,66],hypothet:[76,34,84,16,72],whizb
ang:92,get_reginfo_target_desc:21,contact:[76,114,31,27],thi:[],gettok:[41,43,113,45,47,2,49,50],clenumvaln:20,value_load:23,destsharedlib:66,basetyp:23,mandelbrot:[14,45,2,17],stack_loc:84,ifdef:[71,4,20,11,40],sparctargetasminfo:54,getkei:16,opencl:[31,8],spread:32,board:[9,36],parse_primari:[12,13,14,15,18,19],relwithdebinfo:[24,61],mayb:[26,21,11,40,65],stringwithspecialstr:56,fusion:[31,23],fsin:[77,54],startval:[41,47,2,49],ppc32:84,bpf:[],sectnam:20,p3i8:8,bucket_count:56,bpl:6,image_file_machine_ebc:109,openfil:92,prefixdata:112,manual:[],percentag:38,cfrac:35,bork:[20,116],flatten:[84,23,0],bore:76,pos2:20,pos1:20,getmodulematchqu:54,colloqui:23,fpic:61,loadregfromaddr:54,mandleconverg:[14,2],dopartialredundancyelimin:20,trunk:[24,39,26,84,56,94,10,37,27,35],peek:[12,13,14,15,18,19],plu:[112,54,73,23,49,27,113,78,108,13,16,18],aggress:[],memdep:[],someclass:30,pose:[73,60],confer:[73,84],fastmath:8,repositori:[24,98,107,39,108,26,62,9,56,87,10,27,31],post:[],bpf_mov:84,obj:
[101,33,72,35,73,37,77,79,23],literatur:84,image_scn_align_4byt:109,gc_transition_end:72,canonic:[],s64:8,deltalinestart:71,nctaid:8,sames:23,curiou:34,xyz:[69,80,77],"float":[],profession:27,bound:[],unittestnametest:61,opportun:[32,54,0,50,51,12,23],accordingli:[69,23,16,73],wai:[],copycost:54,callexprast:[41,43,113,47,2,49,50],n2764:92,lowest:[71,41,43,113,47,2,49,50,92,78,86,12,13,14,15,23,18,19],asmwriternum:106,raw_ostream:[],end_amd_kernel_code_t:25,somehow:[76,16],"true":[32,92,67,34,3,69,23,6,41,84,8,102,44,9,49,10,12,13,14,15,16,19,54,103,73,20,56,76,79,80,24,31,42,86,64,30],reset:[26,112,116],absent:16,optimizationbit:20,legalizeop:65,x86_fastcal:84,anew:56,absenc:[84,83],llvm_gc_root_chain:73,emit:[],hotter:59,alongsid:112,wcover:92,request:[],noinlin:[99,23,112,57],xxxjitinfo:54,postscript:32,valuelist:30,function_entry_count:3,encrypt:27,refactor:[15,47,60],instr0:34,instr1:34,instr2:34,entrypoint:23,test:[],shrink:84,roots_siz:73,realiti:94,xxxtargetasminfo:54,fpreg:5
4,dw_op_addr:56,sync_command:26,"2acr96qjuqsym":27,sanitizercoverag:26,debugflag:[20,16],clang_cl:10,pathnam:[24,101,87],set_value_nam:[12,13,14,15,19],libgcc1:9,concept:[],mayload:6,consum:[],dw_tag_inlined_subroutin:56,supplement:105,value_typ:67,middl:[],zone:23,graph:[],certainli:[73,32,40,11,51],jvm:[40,11],"0x200":56,dootherth:92,munger_struct:103,generateuniquenam:50,brows:[43,61,107,19],seemingli:54,dw_apple_property_readonli:56,avx1:10,avx2:10,administr:[],aad8i8:84,gui:[37,92,61],libthread_db:99,adc64ri8:6,gut:66,sparcinstrformat:54,usescustominsert:6,upper:[92,54,44,23,66,16],isvolatil:23,brave:[113,18],bpf_jgt:84,htm:31,preservemost:23,cost:[],build_fmul:19,bpf_jge:84,cov_flag:26,after_bb:[13,14,15],gr16:84,appear:[71,32,46,97,54,42,16,31,1,36,83,56,86,92,26,23,72,103,30,20,98],scaffold:[113,18],"23421e":23,constantarrai:16,uniform:[92,16],isoptim:[23,56],va_list:23,image_sym_class_funct:109,defici:[],caveat:41,gener:[],inputcont:67,satisfi:[91,42,47,86,94,27,4,15],pcre_
fuzz:26,vice:[],isstor:84,precursor:27,plotter:[14,2],image_sym_class_argu:109,mach_universal_binari:79,behav:[91,92,42,108,62,86,95,23],myvar:103,triag:84,regardless:[32,7,92,61,82,73,93,74,47,56,63,37,96,15,23],extra:[],stingi:16,stksizerecord:88,marker:[],legal_el:50,llvm_on_xyz:4,regex:[95,20,5,35],prove:[32,42,34,35,48,51,23],"super":[84,90,54],naddit:20,subvers:[],live:[],suppos:[67,102,34,84,76,108,28,4,23],lgtm:[60,107],tlsv1_method:26,"0xl00000000000000004000900000000000":23,cxxabi:24,finit:[84,21,23],getfunctionaddress:50,viewcfg:[16,49],geordi:39,iffals:23,logarithm:[],graphic:[14,11,2,40],at_nam:56,canconstantfoldcallto:65,prepar:[],focu:[84,90,115,0],cat:[24,73,20,10,79,26],ctfe:31,can:[],debug_symbol:[63,66],boilerpl:[102,73,20,50,21,12],heart:[72,66,55],underestim:23,basemulticlasslist:30,chip:[54,8,84,9,36,10,77,80],spu:54,abort:[92,23,26,84,108,83,116],spl:6,occur:[32,92,72,1,5,3,38,4,23,7,96,97,44,98,10,93,84,16,52,101,103,73,74,76,77,60,82,108,62,27,88,18,112,113,
66,106,30],multipl:[],image_sym_class_regist:109,ge_missing_sigjmp_buf:92,regioninfo:32,"0x80":[97,56],x86instrss:54,product:[73,34,31,84,2,94,76,27,23,113,66,14,30,59,18],multiplicand:23,southern:[105,25],cours:[40,61,42,34,20,45,65,76,11,26,113,66,16,17,18],uint:77,drastic:4,lto_codegen_compil:90,breakag:27,voidtyp:16,goal:[],copyphysreg:54,getcalledfunct:16,explicit:[91,92,34,23,40,41,8,98,47,2,49,50,11,12,13,14,15,16,102,103,73,20,76,22,24,60,25,31,84,86,27,28],dllvm_dir:61,objectimag:75,ghc:[84,23],thread_loc:[72,84,23],approx:8,arch_nam:79,approv:[27,94],graphviz:[32,16],brain:92,svnrevert:24,cold:[23,51,59],still:[32,92,0,34,35,1,48,95,37,4,23,71,40,84,98,47,2,49,11,13,14,15,16,75,102,73,20,56,76,78,24,107,83,31,62,67,63,64,27,88,66,26],ieee:[77,23,51,97],dynam:[],mypass:[76,16],conjunct:[55,33,23,66,4,5,116],precondit:[],getoperand:[84,92,16,54],window:[],addreg:84,curli:[10,23,92,16,116],val_success:23,llvm_doxygen_qhelpgenerator_path:61,has_asmprint:28,non:[],evok:23,recal
:[43,34,67,49,50,12,19],halv:65,half:[],recap:78,now:[],nop:[23,22,88,72],discuss:[71,24,92,102,54,39,23,20,56,76,27,88,26,72,113,16,6,18,51],group_segment_align:25,build_sub:[12,13,14,15,19],drop:[92,27,23,107],reg1024:84,reg1025:84,reg1026:84,reg1027:84,image_scn_align_1024byt:109,dw_tag_vari:[23,56],domain:[40,54,73,84,11,100,23,6],replac:[],arg2:[45,23,17],condmovfp:116,contrib:24,backport:9,reallyhidden:20,year:[92,6],operand:[],rl4:8,happen:[],rl6:8,rl1:8,rl3:8,rl2:8,shown:[71,67,54,35,8,58,23,20,1,2,56,95,37,88,26,78,102,14,115,16,6],accomplish:[24,102,32,73,45,87,27,16,17],"_e32":25,oldval:[47,41,23,2,49],rational:[],ldrr:54,release_34:24,release_31:24,release_30:24,release_33:24,release_32:24,ssl_filetype_pem:26,argu:92,argv:[71,8,20,56,99,80,83],ldrd:86,mandelconverg:[14,2],argc:[71,8,20,56,99,23],card:[72,36],care:[24,40,92,54,42,5,35,84,47,86,94,76,116,11,23,4,29,15,16,6,98],xor16rr:84,couldn:[34,42],adc32rr:6,unwis:[23,97],global:[],adc32ri:6,blind:84,subrang:23,yoursel
f:[24,65,23,27,16,116],stringref:[],size:[],yypvr:115,silent:[27,23,116,42],caught:[108,92,23],yin:67,himitsu:24,checker:[21,103,62],cumul:84,friend:98,r173931:21,nummeta:73,ariti:73,especi:[32,27,54,34,20,98,92,36,86,3,51,23,60,4,16,52,56],dw_tag_interface_typ:56,apple_nam:56,cpu0:53,cpu1:67,llvmtop:76,mostli:[32,40,41,61,54,24,34,20,84,86,49,37,60,11,13,26],quad:[72,23,54],than:[],png:61,"0x432ff973cafa8000":23,d02:104,xcore:[],spisd:54,exampl:[],optimist:31,browser:[39,107],anywher:[115,34,47,10,90,51,23,113,66,15,5,6,18],getint32ti:92,cc_sparc32:54,bitcast:[],engin:[],mccodeemitt:[84,21],begin:[92,67,34,94,37,4,23,75,41,97,42,102,46,47,49,50,12,13,14,15,16,18,19,54,73,20,56,24,60,25,108,84,87,27,88,112,30],importantli:[13,27,92,49,42],numrecord:88,toplevel:[12,13,14,15,18,19],setdebugloc:41,cstdlib:113,getpointers:73,renam:[24,92,33,23,47,56,43,66,15,16],mri:84,"_p3":56,steadi:91,callinst:16,llvm_libdir_suffix:61,add_reassoci:[12,13,14,15],image_file_bytes_reversed_lo:109,fifth:
[71,23,54,8],onli:[],ratio:59,image_rel_i386_dir32nb:22,expr_prec:[12,13,14,15,18,19],llvm_enable_abi_breaking_check:16,endloop:[41,15,47,2,49],overwritten:[88,84,23],llvminitializesparctargetinfo:54,cannot:[32,92,0,95,37,4,5,75,40,42,23,48,11,83,54,103,73,20,76,111,22,78,16,84,86,110,27,44],truli:16,mrm6r:54,inttoptr:[],operandlist:116,seldom:34,intermitt:24,bio_new:26,object_addr:73,gettypenam:16,rrinst:116,"0x0000000000d953b3":99,dllvm_include_exampl:24,hierarchi:[],istreambuf_iter:8,"0x48c978":26,foo_test:10,concern:[103,73,16,27,28,23],"1svn":94,initialize_ag_pass:76,dityp:41,mrminitreg:54,printinstruct:[21,54],regcomp:26,between:[],"import":[],run_long_test:10,paramet:[],constantpoolsect:54,clang_cpp:10,"__text":84,intregssubclass:54,dw_tag_subrange_typ:56,mono:31,pertain:[66,27,56,108],maptag:67,inputfilenam:20,nearbi:[91,34],inconsist:[92,56,103],qualtyp:92,image_sym_type_struct:109,gr32:[84,6,116],dispatch:[88,16,18,113],mutate_depth:26,caret:95,clarif:[105,27,92],invert:[1
0,23,51],shim:32,valuekind:92,invers:[32,23],fixabl:51,uglifi:[12,50],getentryblock:[47,41,16],derefer:[23,16,56,103],normalformat:20,rubi:73,getjitinfo:[84,54],thischar:[41,43,113,45,47,2,49,50],eip:6,global_context:[12,13,14,15,19],pedant:61,fastemit:21,trick:[],initializenativetargetasmpars:[41,47,2,49,50],dw_at_artifici:56,functionaddress:91,metric:[76,26,59,94],henc:[24,30,20,98,87,88,90],worri:[24,41,107,113,20,23,18],eras:[41,43,20,98,47,2,49,86,66,16,56],bigblock:80,antisymmetri:34,develop:[],proto:[41,43,113,47,2,49,50,12,13,14,15,18,19],"__nv_powf":8,sizeofimm:54,bpf_lsh:84,cc1:99,epoch:[67,97],cindex:54,externalstorag:20,document:[],finish:[0,33,34,94,99,23,75,41,43,47,2,49,50,12,13,14,15,83,18,19,76,61,107,108,84,115],futhermor:72,closest:[41,23],someon:[40,92,73,84,65,27,11,115],removebranch:54,valuelistn:30,gridsizei:8,tradition:[31,84,42],pervas:[16,102],createstor:[41,47],ccc:[23,9,112],bitmap:112,tpoff:72,touch:[32,92,23,56,76,16],tool_verbos:[66,87],speed:[24,92,20
,47,10,27,31,15,26],create_modul:[12,13,14,15,19],death:26,struct:[],bb0_29:8,bb0_28:8,getx86regnum:54,bb0_26:8,desktop:63,identif:[24,9,30,23],gettoknam:41,treatment:[73,54],versa:[],real:[24,92,54,8,5,20,42,45,2,56,26,23,14,16,6],imul16rmi8:84,frown:27,"0x82638293":56,read:[],cayman:105,amd:[],regfre:26,googletest:1,bangoper:30,threadsaf:73,benefit:[32,92,42,73,26,103,56,16,52],lex_numb:[12,13,14,15,17,18,19],output:[],debug_pubtyp:56,matur:[73,20],journei:[15,47],cmake_install_prefix:[24,37,9,61],viral:27,getregisterinfo:[84,54],extralib:66,blockidx:8,lto_codegen_set_debug_model:90,rauw:[34,60,16],tdm:114,tok_binari:[41,47,2],sixth:54,objectbufferstream:75,asan:26,flagprototyp:41,"throw":[],dw_tag_subprogram:56,comparison:[],sra:[30,116],central:[4,56,108],greatli:[72,31,56],underwai:31,shadowbyt:88,srl:[30,116],numbit:16,chop:56,degre:[114,86,51,0],dw_tag_subroutine_typ:[23,56],sixkind:23,backup:64,processor:[24,61,54,0,73,105,31,84,56,87,6,21,78,80,66,23,20],valuecol:69,bodylis
t:30,op3val:54,llibnam:20,localaddress:23,xxxbegin:16,outloop:[41,15,47,2,49],yout:67,your:[],parsebinoprh:[41,43,113,47,2,49,50],verifyfunct:[41,43,47,2,49,50],loc:[72,41,56,54,89],log:[],opengl:[40,92,11],aren:[32,40,92,103,24,73,23,42,49,50,37,27,11,12,84,16],haskel:[16,40,11,23],start:[],returnindex:57,lot:[32,92,67,35,36,23,6,40,41,102,43,113,45,98,47,2,50,11,12,14,15,16,17,18,19,54,103,73,20,65,56,76,57,24,83,31,84,63,27,66],stkmaprecord:[72,88],submiss:27,tight:[90,51],satur:[14,2],llvm_cmake_dir:61,"default":[],inlni:79,start_bb:[13,14,15],bucket:[16,56],v31:23,v32:8,loadabl:[],scanner:[45,17],decreas:80,opnam:54,producess:87,value_1:28,prepend:[95,16,56],valid:[],release_19:24,release_18:24,release_17:24,ignor:[91,0,34,38,5,39,41,42,43,23,45,46,47,2,49,50,12,13,14,15,16,17,18,19,54,20,56,59,24,84,27,112,113,28,66,29],you:[],release_14:24,release_13:24,release_12:24,release_11:24,poor:[13,92,49],polar:67,lowerbound:23,registri:[],base_offset:72,bpf_st:84,cmake_minimum_requir
:61,binfmt:24,pool:[54,84,76,88,112,38],reduc:[],assert:[],adc64mr:6,value_n:28,skeleton:24,osx:97,messi:84,ssl3_read_byt:26,month:[39,94],correl:[73,23],"__cxa_end_catch":108,getglob:54,pandaboard:36,paramidx:112,getnullvalu:[47,41,16,2,49],"_ri":116,cpufrequtil:36,sparcinstrinfo:54,articl:[32,24,34,47,49,13,15],sdisel:60,gcfunctionmetadata:[73,88],phielimin:84,"_rr":116,datalayout:[],verb:[66,92],mechan:[],veri:[32,92,0,34,35,36,94,5,6,98,39,40,42,43,23,45,46,47,2,49,50,10,11,51,100,12,13,14,15,16,17,18,19,102,103,73,113,20,56,76,21,24,83,26,84,86,67,27,112,108,29,116],passmanagerbas:54,targetregisterdesc:[84,54],methodbodi:54,masterhelp:50,eatomtypetag:56,emul:[23,65,92,16,84],lldb:[28,27,92,56,99],cosin:[23,54],customari:[20,27,23],dimens:23,unnorm:23,fixedt:56,preserveal:23,casual:[66,27],kistanova:114,dofin:[],nand:23,fpformat:[6,116],isobjcclass:56,llvmlibspath:66,fp128:[34,23,112],"0x00000100":56,signextimm:84,getanalysisusag:[],modular:[28,76,74,92,42],excess:[80,26,77],mcl
abel:84,strong:[34,98,86,27,51,23,5],modifi:[],divisor:23,ahead:[],dform_1:84,t1_lib:26,noimplicitfloat:[23,112],amount:[32,92,62,34,23,6,65,45,98,50,12,83,17,73,20,74,76,77,80,16,84,85,21,88,108,66],sphinx_warnings_as_error:61,n1757:92,ask:[],famili:[40,25,23,56,37,11,72,16],sequencetrait:67,dangl:[13,16],"0x710":79,is64bitmod:54,isimmedi:54,zorg:114,massag:92,formul:4,bash:[4,115],auxiliarydata:109,taken:[32,40,97,54,42,33,34,20,84,108,3,11,51,23,66,4,72,16,6],distfil:66,zork:116,vec:[23,16],build_arch:[66,52],cbtw:84,valuetyp:[65,84,6,54],regoffset:29,oblivi:78,targetcallingconv:54,"0b000111":54,x00:109,x86instrmmx:54,histori:[],ninf:23,indirectbr:[],reindent:92,templat:[],vectortyp:16,unreli:[26,42],parsabl:72,phrase:92,anoth:[],llvm_enable_rtti:61,snippet:[73,27,16],reject:[],getarg:41,rude:108,personlist:67,secondlastopc:54,unlink:[43,24,16],retcc_x86common:54,"0x00003500":56,lifetim:[],machinepassregistri:76,polit:84,help:[],mbbi:84,soon:[33,113,49,76,27,13,90,18],mrmdestreg:
[6,54],held:[27,23,107,78],ffi:98,foo4:[64,90],foo1:[64,90],foo2:[64,90],foo3:[64,90],dfpreg:54,overhead:[73,26,98,50,69,12,16],segfault:31,eatomtypecuoffset:56,tok_els:[41,47,2,49],mergebb:[41,47,2,49],systemz:[],finer:[31,42],dil:6,cee:16,dexonsmith:56,sentenc:92,wideaddr:23,ninja:[24,26,9,61],gmon:66,libllvm:[63,24],stopper:33,addenda:105,x0c:109,iff:23,scalarevolut:[],fulli:[],heavi:[66,16,72],succ_iter:16,llvm_build_tool:61,beyond:[106,103,16,84,108,29,115,23,6],todo:[32,65,33,26,84,9,56,76,21,100],ific:20,isunaryop:[41,47,2],ppcinstrinfo:65,safeti:[],publish:[33,92,16],debuglevel:20,astnod:21,regexec:26,unreview:27,labf:20,ast:[],errorp:[41,43,113,47,2,49,50],dw_tag_volatile_typ:[23,56],mystruct:103,pub:56,mips64:[31,87],reason:[92,34,4,23,65,41,42,43,113,45,9,49,50,10,51,47,12,13,15,16,17,18,19,102,103,73,20,56,76,21,24,72,108,26,84,85,86,27,28,115,116],base:[],put:[91,32,92,67,34,94,23,71,40,41,42,5,45,47,49,99,10,11,13,15,16,17,73,20,56,76,107,83,84,86,115],asi:54,intermodu
lar:[39,90],wglobal:92,asm:[],basi:[45,72,23,20,2,73,38,14,16,17],launch:8,"_z4testb":108,warpsiz:8,undergo:[32,23],assign:[],myawesomeproject:23,obviou:[32,40,92,42,34,56,84,83,2,50,21,27,11,113,78,86,12,88,14,23,98],ultrasparc3:54,islazi:54,isregist:84,placehold:108,uninterest:[45,17],implementor:[12,13,6,49,50],miss:[47,25,0,23,31,9,2,83,64,92,51,113,14,15,16,35,18],st6:6,save_minimized_corpu:26,st4:6,st5:6,nodetail:38,st7:6,st0:[6,54,116],st1:[84,78,6,54],st2:6,st3:6,scheme:[92,54,73,16,57,47,108,38,15,23],schema:[67,1,109,56,55],adher:[4,27,16,6,100],xxxgencodeemitt:54,getter:[23,21,16,56],bidirect:16,adc32ri8:6,grep:[24,61,20,84,36,10,5,35],stl:[24,92,32,26,67,16,98],stm:23,do_something_with_t:91,rootmetadata:73,gpr:[29,84,23,116],str:[71,41,8,43,23,26,67,47,2,49,50,109,78,113,16],consumpt:[76,26,84],aliaseeti:23,toward:[39,27,16,59,23],grei:33,randomli:70,gofmt:92,"null":[],dllvm_target_arch:9,attrimpl:21,imagin:34,unintend:32,bz2:24,lib:[],lic:32,ourfunctionpass:16,lit:[],"_
_apple_objc":56,useless:[40,56,49,11,78,13],numfunct:[91,88],mixtur:116,c_ctor_bas:5,maco:[24,98,16],alpha:[23,54],mach:[],isbarri:[6,116],hipe:[84,23],clear:[92,72,48,23,41,43,113,47,2,49,50,12,13,14,15,16,18,19,103,73,74,27,28,66],implicitdef:84,clean:[],usual:[92,34,35,38,23,40,41,102,42,5,10,11,16,54,103,73,20,74,65,56,76,22,24,60,61,107,83,26,84,85,86,64,27,112,66,115,90,116],v4f64:23,unari:[],unsimm:84,v16:8,v15:23,instrins:23,i32imm:[54,116],"3x4":23,get_instrinfo_named_op:54,getgloballist:16,operandti:84,paus:[73,42],coerc:34,delin:1,pretti:[32,34,35,4,43,113,45,47,2,49,50,12,13,14,15,17,18,19,103,76,57,26,29,115,30,116],setnam:[41,43,47,2,49,50,16],xec:109,lastopc:54,"0x00ff0000":84,suspect:74,darwin:[91,41,84,10,88,79,66,23],ymm:23,defaultdest:23,dinod:41,prolang:35,parenexpr:[41,43,113,47,2,49,50,12,13,14,15,18,19],durint:3,has_asmpars:28,nativ:[],same_cont:22,"133700e":[43,19],setdata:92,rejit:[12,50],llvmlibdir:66,image_scn_lnk_oth:109,kawahito:84,"__llvm_profile_name_b
ar":71,ctaid:8,compute_pgm_rsrc1_sgpr:25,xword:54,close:[],"0x0b17c0de":112,whatsoev:23,dwarf:[],glue:[84,98],unoptim:[24,77,87],particip:[10,23,27,16,66],parse_unari:[14,15],pifft:35,won:[],isprefix:20,srcloc:23,honour:31,emitint32:73,makeup:16,fpform:6,numer:[37,23,6,41,43,113,45,47,2,49,50,51,100,12,13,14,15,16,17,18,19,54,20,111,31,30],isol:[],lowercas:[12,54,50],numel:23,distinguish:[71,40,73,16,11,78,72,4,23],both:[],clang_attr_identifier_arg_list:21,delimit:[24,25,108,23,29,30],fancyaa:76,sty:6,getnumvirtreg:84,protector:[23,56],lexidentifi:65,block_par:[13,14,15],"__objc":23,jeff:4,byval:[84,23,112],header:[],instrsch:16,"100mb":66,linux:[],test_corpu:26,forgiv:34,llvm_enable_thread:61,stamp:97,territori:24,empti:[92,34,1,23,41,43,113,47,2,49,50,10,72,13,16,18,19,54,73,20,56,79,61,108,26,67,27,66,30,116],destructor:[92,16,98,76,108,23],newcom:[15,47,6,100],sslverifi:24,newinst:16,addpassestoemitfil:76,patleaf:54,tok_var:[41,47],imag:[75,84,2,111,22,14,23],citizen:16,imac:0,c
oordin:[73,72,67],modrefv:116,imap:24,look:[32,92,67,34,1,94,37,102,99,5,71,39,65,41,84,8,43,23,47,2,49,50,10,11,72,12,13,14,15,16,18,19,54,103,73,113,20,56,76,21,79,24,60,61,107,25,90,26,42,85,86,87,64,27,88,52,112,108,28,115,30,116],flat_store_dword:25,ramif:103,"while":[],match:[],loos:[66,6],loop:[],pack:[33,84,43,51,112,23,19],malloc:[40,73,31,76,11,16],pragmat:31,readi:[34,94,75,41,43,113,45,47,2,49,50,12,13,14,15,17,18,19,20,56,76,64,27],readm:[10,24,27,115],"__gcmap_":73,risbgn:31,hideaki:84,"0x00001203":56,quadrat:[84,77,16],dependfil:66,fedora:24,grant:[34,27],tokinteg:30,belong:[34,20,16,23],llvm_site_config:[10,37],dest:23,octal:[20,97,116],curloc:41,conflict:[24,41,116,43,23,84,47,2,49,50,10,27,12,13,14,15,16,6,19],"0b10":116,goodwil:27,ccif:54,optim:[],image_sym_class_type_definit:109,temporari:[32,60,67,23,35,1,10,92,108,66,84,16,98],"3gb":37,vreg:84,numarg:[41,88],"0x16677e0":99,older:[24,54,73,20,36,27,66,29],mctargetstream:84,cmake_toolchain_fil:24,pointtoconstantm
emori:42,reclaim:[60,23],use_:16,llvalu:[12,13,14,15,19],weakest:[84,86],predetermin:42,safestack:23,cout:[67,92,98,8],isunord:86,emissionkind:[23,56],afre:48,dw_ate_unsigned_char:23,undeclar:[43,23,19],password:[114,27],xe8:109,shortcut:[45,17,18],supersparc:54,codegener:62,gnueabihf:[9,36],march:[24,31,62,56,77,80,5],intregsclass:54,mcsectionelf:84,xterm:92,nothidden:20,game:27,optimizationlist:20,characterist:[65,54,16,84,109,23],isproto:112,outright:103,signal:[91,20,86,99,10,23,26],resolv:[75,84,43,23,1,49,50,76,27,90,66,12,13,16,6,19],"______________________________________":16,popular:[24,84,36,42],bpf_alu:84,regionsforfile1:71,regionsforfile0:71,ptroff:84,some:[91,32,92,0,33,34,35,1,77,36,48,95,37,3,69,4,5,6,111,39,40,41,84,42,43,23,45,98,9,2,49,50,10,11,51,47,12,13,14,15,16,17,18,19,54,102,73,90,20,100,65,56,76,21,78,57,103,94,97,24,60,61,107,25,72,83,26,62,85,86,87,67,63,27,88,113,112,108,28,66,115,30,31,116],urgent:27,"__llvm_faultmap":91,mnemonicalia:84,shlib:24,mem_addr
ess:84,uselistorder_bb:23,addpreserv:[],printinlineasm:54,pathsep:10,n2930:92,slash:[23,97],castinst:16,bcanalyz:[],unreferenc:[66,23],cgi:26,originput:20,stem:16,"_ztii":[108,23],movsx64rr8:84,curtok:[41,43,113,47,2,49,50],disttarbz2:66,subtract:[71,26,84,23,65],"_ztif":108,"_ztid":23,blocksizei:8,idx:[41,103,43,47,2,49,50,92,23],nnnnnn:84,shini:76,blocksizez:8,f31:[23,54],blocksizex:8,block:[],"123kkk":20,gcroot:[],aq2:23,within:[32,92,67,34,35,1,23,41,84,8,5,45,98,47,2,49,50,72,12,13,14,15,16,52,102,103,73,74,104,56,78,24,60,83,42,88,112,108,66,116],loadsdnod:16,proj_install_root:52,ensur:[91,32,92,0,72,94,38,23,41,84,8,43,5,98,47,2,10,15,16,19,101,54,73,20,74,76,22,24,108,42,86,87,27,88,112,66],llvm_package_vers:61,properli:[],loopunswith:51,pwd:[24,26,9],bio_s_mem:26,vfprintf:23,newer:[24,37,27,99],cmpxchg:[],flagsfeatureb:67,flagsfeaturec:67,flagsfeaturea:67,specialti:16,info:[],fde:[84,60],"0xc3":116,emitglobaladdress:54,abs_fp64:6,similar:[32,92,0,34,36,4,5,41,97,8,43,23,45,
2,49,50,10,12,13,14,16,17,52,19,101,54,103,73,20,76,21,22,24,108,31,84,86,67,27,112,26,116],createdefaultmypass:76,obviat:52,reflectparam:8,doesn:[],repres:[],arg_iter:[41,43,47,2,49,50,16],incomplet:92,nextvari:[2,49],minsiz:23,titl:[31,27,107],speccpu2006:35,nan:[80,31,77,23,56],accross:23,proxi:84,setenv:66,"0x00007fff":84,resign:27,xtemp:86,drag:107,canfoldasload:6,rnnnn:27,svn:[],typeid:[],infrequ:76,svg:61,addmbb:84,orbit:[14,2],devminor:8,depth:[32,34,20,84,49,64,13,23,6],xxxgeninstrinfo:54,unconnect:103,mystringtyp:67,msbuild:[37,61],getkind:[21,102],image_scn_mem_preload:109,exit5:8,friendli:[39,92,113,27,100,29,18],"__llvm_profile_name_foo":71,breakcriticaledg:76,aris:[23,27,16,103],instr_iter:84,yoyodyn:27,then_bb:[13,14,15],image_sym_dtype_arrai:109,runnabl:[24,87],nonatom:56,llvmdisasminstruct:29,weakvh:16,button:107,llvm_enable_doxygen:[24,61],use_llvm_target:[12,13,14,15],dw_tag_const_typ:[23,56],ccifnest:54,relink:[101,83],vgpr:23,calleef:[41,43,47,2,49,50],jump:[],u
lt:[47,49,12,13,14,15,23,19],download:[24,61,54,33,31,9,94,10,64,114,66,16],click:[37,107],hasoneus:92,poke:112,slight:22,espresso:35,cell:54,experiment:[],registerschedul:76,ramsei:84,init_v:15,legalizeact:54,becom:[32,92,0,36,23,6,54,113,47,49,10,51,13,15,16,18,102,103,20,76,78,84,88,66],accessor:[76,113,84,56],"_source_dir":61,startexpr:[41,15,47,2,49],convert:[],convers:[],converg:[14,23,2],solaris2:76,findings_dir:26,chang:[],hexagon:[24,21,23,84,87],epilogu:[73,23,54],chanc:[75,3,45,67,17,27,6],testcase_dir:26,selectinst:92,n3272:92,although:[92,72,1,37,23,65,2,10,16,19,102,55,73,20,76,24,84,86,27,112,28,66,115],danger:[16,5,23],revok:27,win:[92,16,42],degen:23,dyn_cast:[],"boolean":[],llvmtyperef:[31,65],basic_block:19,externallyiniti:23,getrawsubclassoptionaldata:34,implic:[84,27],recordid:112,fibi:[15,47],remaind:[71,24,65,54,108,84,10,28,23],llvm_enable_warn:61,createfsub:[41,43,47,2,49,50],gc_transition_start:72,numelt:112,benchmark:[24,0,33,35,56,10,27,16,52],landingpad:
[],dcmake_osx_architectur:24,nvptx:[],findlead:16,retriev:[75,97,107,8,72,20,67,76,88,108,16],image_scn_gprel:109,perceiv:[40,11],memory_order_acq_rel:[23,86],linearscan:[76,80,84],meet:[76,24,27,84,34],machine_kind:25,control:[],malform:[32,83],sudo:[24,36],typeprint:65,llvm_use_intel_jitev:61,myfooflag:67,sought:23,emitepilogu:54,clang_attr_arg_context_list:21,egrep:24,addpreemitpass:54,dissolv:66,tag_base_typ:56,templatearglist:30,lto_module_is_object_fil:90,live_s:73,eliminatecallframepseudoinstr:54,mydoclist:67,"0x3feaed548f090ce":50,filterclass:69,syscal:[31,84],image_scn_lnk_info:109,vsetq_lane_s32:78,subtyp:[108,54],primaryexpr:[113,18],mcjithelp:50,jne:84,onzero:23,distzip:66,outer:[41,31,67,47,48,49,76,92,13,15,23],consensu:27,sextload:[6,54],topdistdir:66,attrparserstringswitch:21,dw_tag_auto_vari:[23,56],label_branch_weight:3,handl:[],auto:[],handi:[43,66,115,16,19],ctor:[92,23,48,98],memberlist:54,armgenregisterinfo:21,p15:8,p16:8,p17:8,front:[],p19:8,"enum":[92,69,23,6
,65,41,54,42,43,113,45,47,2,49,50,84,16,102,73,20,56,21,57,67,109,106],modr:84,somewher:[76,102,43,23,35,2,10,108,14,5,19],faultkind:91,slide:16,ourfpm:[41,47,2,49,50],upward:1,unwind:[32,60,54,108,31,84,48,22,51,58,23],globl:[72,22,8],selectiondag:[],grok:[43,98,19],chunk:[32,92,112,43,84,85,56,78,19],special:[],image_sym_type_byt:109,"0x00000130":56,influenc:[76,60,56,78],discharg:51,suitabl:[71,32,8,73,23,20,84,75,10,95,112,16],hardwar:[],statist:[],llvmtransformutil:52,spec95:35,lcssa:[],"__cuda_ftz":8,manipul:[],undo:78,typebuild:[65,16],getpointertonamedfunct:75,ecx:[84,22,6,116],image_scn_mem_writ:109,bodyexpr:[41,15,47,2,49],relpo:97,membership:16,keep:[],counterpart:23,bpf_and:84,use_empti:16,dumpmymapdoc:67,svptr:23,linkallcodegencompon:76,qualiti:[],fmul:[],stump:54,find_a:16,rs1:54,has_disassembl:28,scalartrait:67,perfectli:[92,103,5,84,113,23,98,18],mkdir:[24,61,26,87,94,64,66],second_end:23,attach:[24,92,107,8,31,47,56,99,27,15,23],functionpassctor:76,"final":[],prone:
[20,84,6,98,36],my_valu:92,rsi:[84,6],methodolog:108,qualifi:[],exactli:[],rsp:[72,84,85,6,88],ehashfunctiondjb:56,bloat:92,instvisitor:[65,16],"0x00001000":56,dubiou:97,dumb:[40,11],f16:23,exhibit:[83,86],multhread:16,xor8rr:84,reg2:5,procnoitin:6,reg1:5,goldberg:73,lightli:[33,23],tabl:[],need:[],altivec:[31,84,23],mangl:[111,92,27,23,56],createfunctiontyp:41,ind1:23,reloc_pcrel_word:54,"0x04":56,"0x05":88,"0x06":88,"0x07":88,"0x00":[71,88,97],parse_extern:[12,13,14,15,18,19],"0x02":[71,56],fileit:20,unawar:23,lgkcmt:25,platformstripopt:66,llvmgold:64,detector:34,equal_rang:16,singl:[],parseidentifierexpr:[41,43,113,47,2,49,50],discop:41,discov:[84,73,26,1,47,56,49,94,13,4,15],rigor:84,x86_ssecal:54,deploi:107,x86_fp80:[34,23,112],promoteop:65,url:[27,107,115],hasrex_wprefix:6,"0xe8":116,indx:67,inde:26,llvm_parallel_link_job:61,libcmt:37,"0x0d":88,"0x0e":88,constrain:[63,43,98,10,116,23,19],disable_assert:[63,66,87,94],"0x0a":[88,97],"0x0b":88,"0x0c":71,ssl_load_error_str:26,cute
:[40,11],verbos:[67,97,82,1,87,66],objc:[39,115,56],config_fil:66,molest:23,anywai:[32,92,9],varnam:[41,47,2,49,13,15],tire:[],losslessli:34,bpf_alu64:84,envp:99,x86_thiscal:84,themodul:[41,43,47,2,49,50],add_to_library_group:28,llvmtypekind:65,q31:23,tbb:54,shr:92,enabl:[],getmbb:54,she:[114,6],contain:[],shapekind:102,grab:[41,33,98,94,21,13,14,15,16],image_file_local_syms_strip:109,shl:[],legaci:[41,47,2,49,50,23],nolink:20,rc1:[33,94],dlibcxxabi_libunwind_path:31,vectorize_width:0,target_link_librari:61,image_scn_mem_16bit:109,mileston:34,statu:[],correctli:[92,34,23,113,98,49,10,72,13,84,16,52,103,20,56,76,61,108,31,67,85,86,27,18],writter:20,sectvalu:20,realign:[31,23],written:[],neither:[32,112,42,34,37,88,51,78,23],tent:23,vfp3:9,kei:[],header_data_len:56,parseabl:[72,23],popcnt:31,setgraphcolor:16,monitor:42,xxxreloc:54,admin:114,handledefinit:[41,43,113,47,2,49,50],dw_tag_inherit:23,test_format:1,unglamor:27,multi_v:20,orig:23,quit:[34,4,23,39,40,42,43,49,99,11,51,13,16,19
,103,73,65,24,26,84,88,66,115],slowli:[24,27],addition:[24,84,32,73,23,20,42,86,64,27,28,66,16],setindexedloadact:54,libdir:[66,101],image_sym_dtype_nul:109,treat:[],cputyp:112,alphacompilationcallback:54,otp:23,createcal:[41,43,47,2,49,50,16],acq_rel:[23,86],replic:[62,90,116,67],novel:[73,23,16],dw_tag_typedef:[23,56],harder:[32,72,26,98,113,4,23,18],print_str:[12,13,14,15,18,19],engag:27,demo:[],mips32r2:31,rootstackoffset:73,povray31:35,revis:[24,92,61,107,31,56,94,27,88,16],insertdeclar:41,welcom:[34,37,40,41,105,43,113,45,47,2,49,50,11,51,12,13,14,15,17,18,19,76,24,27],parti:[72,27,92,52],reloc_picrel_word:54,print_float:[12,13,14,15],ro_signed_pat:6,llvm_all_target:24,setcategori:20,matcher:[84,26,21,106],nightli:[],http:[24,53,41,107,39,33,26,9,94,10,37,27,114,92,35],tokprec:[41,43,113,47,2,49,50],effect:[],isopt:20,llvm_use_oprofil:61,global_s:16,bitpack:10,spreg:31,appendinglinkag:16,dllvm_enable_p:9,isrematerializ:6,dw_form_strp:56,fom:32,well:[],makefileconfig:66,undefin
:[],memory_order_consum:86,mistaken:[12,50],diflagartifici:23,aform_1:84,aform_2:84,namedvar:41,xs1:105,size1:23,size2:23,size3:23,outstream:73,dcmake_build_typ:[24,26],densiti:[14,92,2],warrant:65,nodebuginfo:20,takelast:16,bpf_xadd:84,howto:[53,21,115],mcsectioncoff:84,add_gvn:[12,13,14,15],burden:[27,23],n2343:92,lbar:84,n2346:92,n2347:92,loss:[73,16],lost:[40,108,98,11,66,23],"0f3fb8aa3b":8,ldflag:[101,41,43,47,2,49,50,66],necessari:[92,72,94,95,4,23,71,65,41,97,42,5,98,9,99,10,51,84,16,75,54,73,20,76,78,57,59,24,60,61,108,62,86,27,88,66,115,90],rotl:65,martin:24,profraw:[71,95],page:[],hasdelayslot:6,didn:[92,43,34,84,47,56,50,76,15,16,18,19],revert:[24,27],"04e":23,mistyp:92,notfp:116,repeat:[32,33,23,56,108,34,29,83],home:[24,35,99,10,51,16],librari:[],hannob:26,win32:[10,4,37,84,24],setmcjitmemorymanag:[75,41,47,2,49,50],broad:[45,73,20,50,12,17],createexpress:41,overlap:[42,0,84,48,76,88,23],estim:[34,31,59,0],asmstr:[6,54,116],myfunct:8,encourag:[32,40,92,24,31,62,27,11,16
],ifequ:23,nutshel:16,offset:[40,112,97,54,103,72,16,31,84,85,104,56,10,73,11,23,34,88,5,6],pi8:104,image_file_32bit_machin:109,testsuit:[66,5],bcreader:101,freedom:[23,16],viewvc:39,bodyitem:30,cocoa:23,cmake_cxx_flag:61,attrtemplateinstanti:21,pointless:108,"0x00000110":56,gcov_prefix:95,image_file_removable_run_from_swap:109,"_cuda_ftz":8,downgrad:98,dbuild_shared_lib:24,ndebug:[63,20,61],global_iter:16,interleave_count:0,pty2:23,as_float:[12,13,14,15],eax:[54,23,84,22,5,6,116],gain:[],spuriou:[92,23],overflow:[],highest:[41,43,113,47,2,49,50,78,12,13,14,15,23,18,19],eat:[41,45,43,113,20,47,2,49,50,12,13,14,15,17,18,19],liblto:[],dmb:86,displac:84,displai:[71,32,92,54,35,45,58,20,1,110,114,95,27,111,38,102,29,84,17],sectiondata:109,w31:23,w30:23,cruel:115,"0xffbef174":76,llvm_enable_assert:[61,16],add_llvm_loadable_modul:61,bpf_op:84,unconditionali:23,atyp:103,isconvertibletothreeaddress:6,reciproc:[31,23],lastchar:[41,43,113,45,47,2,49,50],intregsregclassid:54,fourinarow:35,dump
abl:76,acloc:24,lattner:[40,11],arctan:67,hash_set:16,getjmp_buftyp:92,futur:[],rememb:[92,72,35,37,23,41,113,98,9,49,47,13,15,16,18,103,20,76,24,26,84,27],parse_id:[12,13,14,15,18,19],tmp2:[15,47],stat:[],cmake_build_typ:[24,61],dw_tag:56,stab:56,same_s:22,dyld:75,sphinx:[],twoaddressinstructionpass:84,indirectli:[31,92,23,86,116],portion:[71,24,54,32,44,20,84,83,50,27,108,12,29,23],image_file_machine_sh3dsp:109,callingconv:[],getpointertofunct:[75,41,47,2,49,50,16],enable_sgpr_kernarg_segment_ptr:25,secondli:41,whose:[71,92,112,54,42,111,30,56,84,47,2,83,27,23,113,14,15,16,18,116],accur:[],unaryexprast:[41,47,2],parse_var_nam:15,"0x20":56,swap:[31,23,36,78],getllvmcontext:92,preprocess:[31,62,98],aux:16,doubleword:23,downstream:[46,59],"void":[],llbuilder:15,build_stor:15,affect:[98,61,78,8,33,30,20,62,9,86,49,94,76,23,13,34,4,16,116],x86_stdcallcc:112,mybranch:24,theier:32,pinvok:31,bpf_x:84,stageselectioncat:20,image_file_machine_m32r:109,bpf_w:84,correct:[32,92,0,33,72,35,94,4,
23,65,42,98,9,50,10,12,84,16,20,56,76,78,24,60,61,31,62,85,86,64,27,114,66],scalarbitsettrait:67,vector:[],bpf_h:84,bpf_k:84,llvm_build_test:61,"0x2a":78,initialis:[20,6],bpf_b:84,whirlwind:[113,18],likeli:3,vhdl:31,aggreg:[],binop_preced:[12,13,14,15,18,19],bpf_imm:84,dw_apple_property_unsafe_unretain:56,even:[91,92,0,34,35,1,37,4,5,6,40,47,97,42,23,45,9,2,49,50,10,11,51,72,12,14,15,16,17,102,73,100,76,21,80,59,24,31,84,67,111,112,66,29,115,90,26,116],rope:16,fcur:34,addllvm:61,neg:[],s_endpgm:25,transcrib:[43,19],nex:76,libpo:20,net:[91,39,31,114],ever:[40,92,42,23,27,11,28,16],metadata:[],elimin:[],centric:23,old_bind:15,never:[91,32,92,67,34,35,95,23,71,40,97,42,102,98,50,11,12,16,54,103,73,76,78,84,86,64,90],restat:92,q15:23,met:[73,34,84,23],ccassigntostack:54,image_scn_cnt_initialized_data:109,interpret:[72,1,23,6,71,40,41,43,44,46,47,2,49,50,10,11,12,13,14,15,16,18,19,101,20,56,78,80,24,61,84,63,88,112,113,28,66,30],dcmake_crosscompil:9,gcname:112,credit:27,ebenders_test:99,
permit:[77,41,73,23,31,84,47,10,60,22,15,16,116],parlanc:[45,17],volunt:[33,114],immin:94,bpf_jset:84,machineregisterinfo:84,quickcheck:16,fcoverag:[71,95],handlerpcoffset:91,createnvvmreflectpass:8,icc_n:54,disambigu:[51,42],calm:[15,47],recommend:[92,72,1,23,8,113,47,48,50,10,12,15,18,103,73,76,24,61,26,84,63,27,66,31],icc_g:54,type:[],tell:[],esi:[84,6],"__eh_fram":84,columnend:71,warn:[],all_build:37,wari:51,dw_tag_apple_properti:56,room:[76,113,18,57],rightr:34,x8b:109,dw_apple_property_nonatom:56,setup:[],thefunct:[41,43,47,2,49,50],librarygroup:28,root:[],thesparctarget:54,clang_cc1:[10,5],defer:[12,34,75,50],give:[],dlsym:[12,66,76,50],binpath:99,subtmp5:[15,47],force_on:61,dragonegg:[39,98,27,84,94],unsign:[92,0,34,3,23,71,41,8,43,47,2,49,50,84,16,19,54,103,73,20,56,21,31,42,67,112,90,26],secidx:22,quot:[25,20,67,56,10,28,23,116],tbaa:[],targetlow:[],answer:[32,92,102,39,34,20,42,47,49,50,51,115,12,13,103,15,23,98],registerlist:54,config:[],confid:27,reloc_absolute_word:54,
attempt:[32,92,72,4,23,75,42,44,98,50,83,54,74,76,24,108,31,84,87,88,112,66],third:[92,67,34,35,94,23,71,40,41,43,11,72,16,52,19,54,103,73,20,104,56,76,24,108,84,27,88,112],"0x7fffe3e85ca8":26,maintain:[65,92,112,42,73,34,20,84,86,56,76,27,88,23,4,16,6],yourregex:5,vfp:[23,36,78],decl:[6,102],mo_registermask:84,privileg:[4,23],gcda:95,unexpetedli:10,sigplan:[73,84],better:[32,62,0,34,35,92,99,5,40,23,47,49,50,11,13,15,16,18,76,60,26,84,86,27,113],argti:23,persist:[26,16],vmcnt:25,newtoset:92,dummytargetmachin:54,promin:[10,35],overestim:23,promis:27,runtimedyldmacho:75,usertarget:66,coveragemappingdataforfunctionrecord0:71,mapsectionaddress:75,isel:[84,60,116,54,106],"instanceof":16,grammat:[113,35,18],grammar:[65,113,26,2,14,18],meat:12,build_for_websit:94,setdescript:20,getvalu:[92,16],somefancyaa:76,went:[13,49],thenv:[41,47,2,49],side:[32,92,8,43,34,42,2,49,10,73,113,23,72,13,14,84,16,18,19],bone:[88,54],mean:[32,92,67,34,1,94,102,4,5,6,40,41,97,42,43,23,45,47,48,49,50,11,72,12,
13,15,16,17,52,19,54,103,73,20,100,56,76,111,22,78,24,61,25,90,84,64,27,112,108,66,30,116],rev64:78,awri:66,add_ri:116,taught:84,f108:8,f107:8,collector:[],getsextvalu:16,unbound:[84,23,54],crucial:23,bpf_end:84,content:[],rewrit:[32,60,102,54,72,31,47,92,15],mtripl:[23,77,5,80],rare:[91,92,112,54,73,5,84,51,23,108,16,116],dfpregsregclass:54,reader:[],die_offset_bas:56,end_cond:[13,14,15],parseforexpr:[41,47,2,49],nodetyp:54,linear:[24,103,42,31,84,76,77,80,16],parse_definit:[12,13,14,15,18,19],wherea:[16,84,51,78,108,23],isv9:54,situat:[32,102,54,0,34,20,84,86,50,76,64,23,108,12,66,103,16],infin:23,ineffici:[0,84,47,112,15,16],f89:8,getfunctiontyp:[16,50],retcc_x86_32_fast:54,dw_at_rang:56,nummodulevalu:112,typesaf:23,ish:[14,2],isn:[],isl:31,isa:[],getinstrinfo:[84,54],isd:[65,84,54],cpuinfo:36,floorf:0,my_kernel:8,targetregistri:[84,54],hook:[13,84,83,52,49],unlik:[32,92,72,23,47,50,12,15,16,102,73,76,24,108,84,86,64,27,88,112,66,30],featureb:67,featurec:67,featurea:67,massiv:[66
,21,46],payload:[84,23],hood:[10,71],global_empti:16,tsc701:54,sevenkind:23,pane:107,ieee754:[31,23],sometim:[24,103,27,112,102,54,32,5,20,84,92,83,10,21,23,34,66,67,16,98],sphinx_output_html:61,arm_apcscc:112,dwell:43,filepo:20,llvm_enable_pedant:61,bodyv:[41,47],a32:78,namespac:[],build_cond_br:[13,14,15],somewhat:[39,92,42,23,35,98,2,86,27,113,72,14,16,18],buildmod:[10,66],dllvm_tablegen:9,ri_inst:116,symptom:24,nail:[13,49],r14d:6,silli:[45,92,17,98,42],r14b:6,keyword:[],mcdesc:54,r14w:6,matter:[65,92,86,76,27,88,12,23],nakatani:84,modern:[],mind:[92,113,47,27,15,16,18],stackar:73,bitfield:86,seed:[26,70],seen:[40,92,112,54,34,20,84,2,50,76,11,23,72,14,16],seem:[84,61,102,42,73,34,20,46,78,103,83],seek:[32,61,39,103,27,22,66],minu:[85,23],ty2:23,memcheck:[10,1],image_sym_class_register_param:109,rethrow:108,myset:92,myseq:67,distsourc:66,fnstrart:84,cudevic:8,regular:[24,7,92,97,35,34,20,67,40,86,95,11,23,66,5,26],ccassigntoreg:54,secrel32:22,tradit:[24,32,31,84,56,17,76,111,16,
45],simplic:[43,45,73,88,16,19],don:[],pointe:[23,112],simplif:[76,32,83],doc:[],alarm:36,obtus:103,dog:20,expandinlineasm:54,digress:[14,2],runtimedyldelf:75,dot:[],"0xffff000000000002":88,hunger:[40,11],visitor:[65,45,43,31,73,21,83,17],esoter:116,llvm_enable_werror:61,speedup:31,syntax:[],selftl:26,errstr:[41,47,2,49,50],image_sym_class_weak_extern:109,istruncatingstor:54,despit:[72,20,84,56,76,100,23,6,116],llvm_parallel_compile_job:61,explain:[39,92,61,97,107,42,34,45,84,47,76,85,78,15,16,17,98],sugar:23,regnum:88,folder:[24,61],accumulateconstantoffset:34,pinst:16,hasgc:34,stop:[24,65,92,61,73,23,46,76,27,113,108,16,98,18],bar:[92,0,72,1,23,71,8,43,5,98,48,49,10,13,84,16,19,20,104,56,22,61,67,30],sacrific:[34,23],bpf_div:84,baz:[92,0,20,56,49,13,30],reload:[41,73,26,84,47,60,15],bad:[41,33,44,56,67,2,83,92,23,34,4,14,16,98],memorysanit:23,shtest:1,newengin:50,addinstselector:54,flagpointi:67,cstdio:[41,43,113,47,2,49,50],instalias:84,datatyp:[20,84,16,17,45],"0x42":112,"0x43":
112,v8f64:23,msan:26,subject:[84,92,27,16,67],p1i8:[72,8],said:[40,92,23,56,11,108,16],double_typ:[12,13,14,15,19],simplest:[67,54,43,113,20,84,50,37,12,18],attribut:[],add_memory_to_register_promot:15,triplet:[20,23],howtousejit:101,lazi:[],diflagprototyp:[23,56],abs_fp80:6,configurescript:66,imagmag:[14,2],against:[24,101,27,61,97,102,8,5,26,67,48,10,63,3,51,23,108,32,16,35,98],fno:0,uni:8,readnon:[32,8,72,104,56,51,112,23],constantindex:88,uno:23,foobaz:92,createload:[41,47],devbufferc:8,devbufferb:8,devbuffera:8,foobar:[92,67],int32_t:[73,67],"16b":78,loader:24,parse_var_init:15,"__________________________________________________________":16,three:[32,33,34,35,5,23,98,49,10,72,83,18,54,103,113,20,104,76,21,24,16,26,84,87,110,108,112,44,66],objc_properti:56,specul:[108,86,23,51,42],succ_begin:16,trigger:[75,7,92,61,42,73,83,31,62,67,10,88,23,35],interest:[32,92,67,72,35,1,68,37,38,5,75,39,40,41,42,43,23,45,98,47,2,49,50,10,11,12,13,14,15,16,17,18,19,102,73,20,56,76,78,24,108,26,8
4,86,27,113,114],basic:[],tini:[34,102],llvmpassnam:61,build_load:15,suppress:[73,92,1,23,67],mce:54,multithread:[],lpae:86,lpad:[108,23],argumentexpr:[12,13,14,15,18,19],llvm_include_test:61,terminatorinst:[92,3,16],ugli:[16,14,98,5,2],subsequ:[75,32,103,54,0,20,84,56,88,29,23,116],intregsvt:54,itinerari:[84,6,54],noredzon:[23,112],slt:23,servic:[4,98,42],lex_id:[12,13,14,15,17,18,19],slp:[],splitdebugfilenam:23,calcul:[76,32,60,54,42,23,31,84,56,49,59,10,13,103,16,35],typeflag:56,occas:92,sle:23,spawn:26,r600:[87,25],gninja:26,xxxkind:102,disappear:[24,98,36],grown:[14,11,2,40],receiv:[75,16,31,84,6,112,108,23,26,18],make:[],bitmask:23,who:[71,24,40,92,54,39,34,62,47,63,10,27,11,28,4,15,23],isspac:[41,43,113,45,47,2,49,50],initialexec:[23,112],mrm5r:54,ssl_ctx_new:26,zlib1g:9,kib:20,overs:16,revector:[32,16],binopprototyp:[14,15],vehiclemak:92,ea_r:84,addrawvalu:57,inherit:[76,92,102,42,16,20,84,63,21,31,4,30,6,116],llvm_dir:[34,61],endif:[71,40,41,20,92,11,4],programm:[],paradigm
:[31,16,103],left:[32,41,97,54,0,43,34,35,84,92,49,83,27,112,113,13,67,23,6,18,19],projusedlib:66,identifi:[],op1:[23,112],just:[32,92,67,33,34,35,1,95,37,38,102,4,5,6,98,71,40,41,84,42,43,23,45,46,9,2,49,50,10,11,47,12,13,14,15,16,17,18,19,54,103,113,20,56,76,21,22,78,80,111,59,97,24,107,72,83,26,62,85,86,87,64,27,88,52,112,108,28,66,115,31,116],op3:54,bandwidth:23,human:[93,24,92,96,82,32,34,67,76,38,89,23,6],nowadai:9,yet:[32,92,34,35,48,23,75,2,49,50,72,12,13,14,16,101,54,73,20,76,114,108,26,84,87,110,28],languag:[],uint16:[91,88],save:[84,0,48,37,38,23,75,65,41,8,47,2,49,50,12,13,14,15,16,54,20,56,78,24,61,107,108,31,62,63,88,112,26,116],vpsubusw:10,opt:[],applic:[91,92,34,35,95,23,6,75,39,40,105,97,45,2,50,10,11,51,72,12,14,16,17,101,54,73,20,76,78,61,108,26,84,27,88,112,28,66,116],segnam:20,julia:31,"0x0000000000dc8872":99,opc:[41,47,2,116],wojciech:32,fact1:34,fact0:34,getinstlist:16,negat:[14,84,23,2,112],dindex:54,llvmcreatesimplemcjitmemorymanag:88,machinepassregistrynod:
76,funcion:8,unnecessari:[],cxxflag:[101,41,43,47,2,49,50,66],www:[26,94],deal:[91,32,92,112,102,108,47,86,56,21,27,78,15,16],maxim:[80,45,17,112],dead:[],intern:[],interg:71,make_pair:[34,41,47],norman:84,insensit:42,xmm11:6,tracker:[27,107],getchar:[41,43,113,45,47,2,49,50],hatsiz:67,creatur:[14,45,2,17],burg:60,idiomat:[10,92],bold:115,identifierexpr:[41,43,113,47,2,49,50,12,13,14,15,18,19],uncompress:[24,16,61],mappingnorm:67,buri:92,strippointercast:92,promot:[],burr:80,nothrow:86,fnty:23,unsaf:[40,86,56,88,77,11,80,23],dw_tag_formal_paramet:23,movsd:5,argv0:80,culaunchkernel:8,ppcf128:23,compilecommonopt:66,simul:[84,23,78],movsx:84,commit:[],marshal:88,movsq:84,mrm7m:54,contriv:[98,116],f128:[23,54],down:[32,84,34,6,71,39,40,41,102,42,44,2,49,11,13,14,16,18,54,103,113,20,56,76,77,78,80,24,107,83,31,62,63,27,108,66,26],f3_12:54,indexreg:84,mrm7r:54,nomodref:42,insidebundl:84,subl:[84,5],parsesubtargetfeatur:54,precomput:42,perldoc:24,frameinfo:54,xpass:1,imit:[115,30],ssl_do_h
andshak:26,editor:[24,27,92,115,66],fraction:[69,26,59,102],amazingli:[13,49],"_els":[41,47,2,49],fork:[4,26],numxform:16,creation:[],form:[],sub1:5,forc:[24,92,61,25,0,23,20,67,9,48,56,76,108,88,72,66,16,80],retarget:[39,84],nounwind:[8,5,104,56,10,51,112,23],phid:92,emitbyt:54,berk:31,addmoduleflag:41,bugfix:94,writeattribut:21,llvma:66,multisourc:[10,35,27,56,62],"__i386__":[40,11],unrel:[27,16,56,54,94],classid:30,classif:[4,23],featur:[],semicolon:[24,41,61,116,43,113,47,2,49,50,12,13,14,15,18,19],classic:[31,84],visitgcroot:73,diagnost:[],glanc:[40,92,11],ship:[24,40,73,87,99,11],dwarfnumb:54,vista:31,getfunctionlist:16,excel:[24,16,54,42],image_scn_align_2048byt:109,stackrestor:[],initid:112,subdivid:35,"0fc2d20000":8,iteri:[12,13,14,15,19],libffi:63,axi:0,furthermor:[32,5,23,103],pseudo:[],dcommit:24,image_sym_type_int:109,n1720:92,skip:[92,0,72,23,71,41,43,113,45,47,2,49,50,12,13,14,15,17,18,19,54,73,56,78,84,112],"0x00000150":56,inlineasm:34,skim:92,createvirtualregist:84,
mill:20,primer:115,pldi:73,hierarch:[32,112],misread:92,libit:20,fancier:[76,115],intermedi:[39,7,98,61,82,54,33,23,74,48,73,113,112,57,72,16,18],targetinstrformat:54,hasinternallinkag:16,image_scn_align_2byt:109,letitem:30,mandlebrot:[14,2],llvmbuilder:12,aspx:92,shoot:[12,50],string:[],bpf_add:84,create_argument_alloca:15,kernel_param_2:8,kernel_param_0:8,kernel_param_1:8,print_endlin:[12,13,14,15,18,19],initializealiasanalysi:42,did:[],dif:32,dig:[45,17,116],iter:[],item:[],s_load_dword:25,div:[84,16],round:[],dir:[24,61,33,26,1,9,56,87,95,66,23,52],sparclit:54,max_len:26,run:[],nozero:80,sideeffect:23,addr:[79,23,54],addq:88,filler:31,insertbranch:54,favour:[6,100],addx:116,wors:[84,92,23,78],rephras:103,addi:[23,116],xml:112,deriv:[],oversimplifi:16,elsev:[41,47,2,49],xmo:105,imul16rmi:84,wait:[92,25,33,113,114,4,18],box:[84,56,107],lhs_val:[12,13,14,15,19],insan:92,canadian:[24,87],shift:[32,65,34,31,84,6,59,112,23,20],bot:[39,27,92],storeregtoaddr:54,extrem:[91,24,84,112,54,3
2,30,26,42,47,86,83,76,27,23,69,15,16,116,56],bob:67,else_:[13,14,15],opcstr:54,stb_local:23,elect:27,modul:[],"__jit_debug_register_cod":99,patchabl:[72,88],"0baz":16,"0x60":97,"0x800":56,sake:[76,16],allocinst:15,getsubtargetimpl:[73,31,54],visit:[73,83,65,16],tokidentifi:30,deplib:112,perl:73,everybodi:[34,27],numfaultingpc:91,zeroargfp:116,checkout:[],rpath:24,makelegalfunctionnam:50,fcomi:84,com_fir:84,appel:73,oop:72,examin:[75,54,16,20,84,83,10,95,72,94,23],effort:[75,32,65,92,43,98,56,27,88,51,4,19],fly:[113,31,84,50,12,18],reviewe:27,ulp:23,uniqu:[],imper:[92,73,47,49,13,15],sparcisellow:54,imped:23,nextvar:[41,47,2,49,13,14,15],nearest:[71,23],makefileconfigin:66,predict:[76,39,3,92,51],crazi:[20,45,11,17,40],subregion:23,flagscpu2:67,exctype1:108,strikingli:[14,2],delete_funct:[12,13,14,15,19],subnorm:[23,8],binarypreced:[41,47,2],registerasmprint:54,ping:[34,27],f32:[84,23,54,8],idiv:84,image_scn_mem_read:109,till:[114,16,99],purg:92,foreach:[],pure:[32,60,54,43,72,31,84
,27,28,30,19],ptr_is_nul:91,tile:31,doclist:67,testingconfig:1,map:[],exctypen:108,max:[71,20,1,23],tmp9:[5,103],usabl:[54,20,84,77,16,31],intrus:[23,16],mac:[24,97,99,76,94,16],mag:23,mai:[],underscor:[66,92,56],maj:33,grow:[23,20,84,48,49,13,29,16],man:[10,24,20,61,39],noun:92,openssl_add_all_algorithm:26,"0x00001023":56,myglob:56,targetframeinfo:54,purifi:62,containingtyp:23,talk:[40,92,43,113,45,47,65,49,50,76,11,12,13,15,16,17,18,19],image_sym_class_automat:109,abbrevop0:112,abbrevop1:112,lsb:84,shield:[4,84],iptr:23,comdat:[],cppbackend:24,recoup:112,nbsp:84,gcmetadata:73,entiti:[],group:[],thank:62,polici:[],build_shared_lib:61,report_fatal_error:50,mail:[],inlinehint:[23,112],main:[],irbuild:[41,43,47,2,49,50,12,13,16,19],recoveri:[41,43,113,47,2,49,50,12,13,14,15,18,19],parseunari:[14,41,47,2],prime:[41,43,113,47,2,49,50,12,13,14,15,18,19],remateri:86,sooner:114,initv:[41,47],possess:[71,16],lo16:84,ancestor:[23,102],xlc:24,careless:92,x11:16,myflag:67,misbehav:33,loopunswi
tch:32,llvm_dylib_compon:24,continu:[],redistribut:[],libgcc:85,tmp8:103,bpf_or:84,arcp:23,tmp7:[5,103],tmp6:103,tmp1:[92,5],tmp3:5,baselin:[84,94],getbinarypreced:[41,47,2],"3rd":23,createfil:41,bespok:73,numval:[41,43,113,45,47,2,49,50,112],dw_tag_unspecified_typ:[23,56],arminstrinfo:54,uint32:[91,88],earlier:[28,71,23,51,54],"goto":[41,0,34,47,2,49,92,15],orr:23,tmpb:[41,47],ori:84,org:[24,41,61,107,39,33,26,64,9,87,67,10,43,37,27,114,92,94,35],ord:23,orc:31,badli:51,v8deprecatedinst:54,sn_mapr:34,createasmstream:84,thing:[],sn_mapl:34,principl:[92,105,34,45,4,17],think:[92,69,4,23,71,40,8,45,49,11,13,84,16,17,102,103,73,65,60,61,107,42,27],first:[],reimplement:31,carri:[23,29,16,97,103],"long":[92,67,33,72,1,95,3,38,102,4,23,40,105,97,42,43,44,98,10,11,16,19,54,103,73,56,76,22,24,107,83,26,84,87,27,66,31],oppos:[24,60,23,20,111,13,30,52],getfoo:23,numop:[112,54],attrspellinglistindex:21,indiviu:84,indivis:48,numindic:71,averag:[13,31,49,38],daunt:61,"0f42d20000":8,broadcast:23,m
y_kei:92,attrkind:[21,57],foldingsetnod:16,getpredopcod:69,vbr6:112,vbr4:112,vbr5:112,vbr8:112,redefinit:[41,43,47,2,49,50,12,13,14,15,19],valuedisallow:20,targetsubtargetinfo:31,were:[32,92,0,34,1,95,37,5,6,71,40,23,48,11,72,84,16,55,20,74,56,78,89,24,26,62,86,27,66,31],lcpi0_0:10,mcexpr:84,mrm5m:54,dw_tag_set_typ:56,llvmlibsopt:66,dash:[20,67],mageia:24,greet:116,gettargetlow:54,r_arm_thm_movw_abs_nc:9,kevin:84,of_channel:[12,13,14,15,18,19],unadorn:23,weak_odr:[23,112],squar:[28,27,23,102,67],cumoduleloaddataex:8,llvm_target:[12,13,14,15],"_crit_edg":23,advis:[13,94,97,49,57],interior:[73,60,102],"0b1001011":116,channel:39,sparciseldagtodag:54,llvm_analysi:[12,13,14,15,19],ptrloc:[73,23],pain:[20,16,107,99],ldststoreupd:84,trace:[60,72,20,56,76,31],normal:[],track:[32,92,34,1,23,6,41,84,42,43,98,47,2,51,72,14,15,16,19,73,56,76,24,83,26,62,27,88,108,31],allroot:35,cucontext:8,pair:[32,92,72,5,23,41,42,113,47,49,34,13,84,16,18,54,78,57,25,108,67,86],r31:[84,23],isglobaladdress:54,s
ynonym:97,cumodulegetfunct:8,dw_form_:56,rev128:78,maskedbitset:67,llvmgxx:66,isphysicalregist:84,defaultconfig:16,gracefulli:16,show:[],occumul:26,shoe:67,threshold:[32,23,95],corner:88,getadjustedanalysispoint:42,emitexternalsymboladdress:54,dice:16,fenc:[],enough:[],frexp:23,adc64mi32:6,parametr:[31,30],ftest:95,hello_world:25,sourcewar:64,intptr_t:[41,0,47,2,49,50],gep:[],variou:[],get:[],mung:[32,103],secondari:[27,88],repo:24,emitlabel:84,wheezi:9,inreg:[84,23,112,54],gen:[],r10b:6,nullptr:[92,41,23],yield:[32,103,23,20,112,72,16,35],r10d:6,stupid:83,mediat:42,r10w:6,wiki:[24,61],kernel:[],setpreservesal:76,"__builtin_setjmp":108,intrinsicsnvvm:8,assumpt:[40,41,23,77,84,56,92,11,5],sean:16,testcas:[43,44,27,23,16,19],immsext16:84,infinit:[32,26,84,23,42],parsedefinit:[41,43,113,47,2,49,50],nestabl:[30,116],innov:31,getmetadata:56,datalayoutpass:[31,41],enumer:[],label:[],behind:[],enumem:54,volatil:[],across:[32,0,72,38,23,6,40,8,50,11,51,12,16,20,56,76,78,24,60,84,86,88,28],a
rm64:[24,87],august:75,parent:[24,92,43,23,1,49,108,28,13,16,59],fpregsregisterclass:54,rfunc:7,parseprototyp:[41,43,113,47,2,49,50],copyabl:16,false_branch_weight:3,llvm_enable_sphinx:[24,61],blocklen:112,audienc:[],library_nam:28,litloc:41,p0i64:5,improv:[24,40,107,54,32,73,34,26,1,42,50,76,108,11,51,72,12,94,23,31],peephol:[65,41,84,47,2,49,50,76,12,13,14,15,16],among:[32,90,92,24,34,8,42,87,21,22,51,84,16],acceler:[],undocu:92,unittest:61,tsflag:54,getnumsuccessor:92,cancel:108,iscal:[6,116],inadvert:[4,31,5],mctargetdesc:21,xadd:86,ultim:[92,33,1,50,12,66,23,6],createdatalayout:31,p0i8:[23,8],mark:[],certifi:98,"0x4004f4":79,calledcount:83,llvmbitread:52,squash:[24,78],f92:8,f93:8,f90:8,f91:8,f96:8,f97:8,f94:8,f95:8,univers:[],f98:8,f99:8,those:[32,92,67,34,1,36,95,38,4,23,6,71,39,41,97,42,5,46,47,10,72,15,16,54,103,73,20,56,76,24,61,83,84,86,27,88,108,28,66],sound:[26,42],isvararg:16,interoper:[40,73,23,11,108,16],invok:[],"0x3feb":56,"0x3fea":56,invoc:[24,61,23,84,83,76,44,66
,5],isdoubl:116,gvneedslazyptr:54,advantag:[40,92,103,73,23,20,84,47,2,86,27,11,78,57,14,15,16,90],parse_expr:[12,13,14,15,18,19],bytecode_libdir:66,destin:[41,97,54,108,84,47,10,3,51,15,23],llvm_gcc_dir:35,variable_op:116,my_function_precis:8,cudeviceget:8,liveoffset:73,same:[],ssl_library_init:26,image_file_machine_unknown:109,pad:[71,97,108,48,88,112,23],pai:[10,27,92,54],oneargfp:116,add32mi:6,exhaust:[],assist:[92,62,2,66,14,106],executionengin:[24,41,61,99,31,84,47,2,49,50,12,13,14,15,16],capabl:[23,40,105,8,43,47,2,50,11,12,14,15,16,19,54,20,65,76,24,84,42,87,90],kernel_code_entry_byte_offset:25,executeprogramandwait:4,runonmachinefunct:[],appropri:[32,92,67,33,9,1,94,69,4,23,6,65,84,8,102,113,47,2,51,72,14,15,16,18,54,73,20,56,76,78,57,24,108,31,42,86,27,114,66,90],macro:[],markup:[],spadini:32,getobjfilelow:73,asmnam:54,dllvm_include_test:24,roughli:[60,102,108,84,86,94],emitleadingf:86,release_22:24,execut:[],speccpu2000:35,mo1:54,mul_ri:116,mygcprint:73,subblock:112,aspec
t:[40,41,61,43,30,31,84,56,49,73,27,11,23,113,13,16,18,19],mul_rr:116,flavor:[23,16,56,116],runtim:[],"125000e":23,xxxtargetmachin:54,critial:94,param:[92,8,73,1,114,37,12,13,14,15,16,19],cumoduleunload:8,sparcregisterinfo:54,autoregen:54,dclang_tablegen:9,setrequiresstructuredcfg:54,mcregaliasiter:84,mov:[8,23,84,86,22,5],coverage_pc:26,mod:[],cast_or_nul:16,is_ptr64:25,ifstream:8,qnan:23,server:[26,16],bb0_4:8,bb0_5:8,prologuedata:112,either:[32,62,34,35,1,94,92,23,6,75,40,41,97,8,113,45,98,49,50,10,11,72,12,13,84,16,17,18,101,54,103,73,20,74,65,77,78,79,24,61,83,26,42,86,64,27,88,112,108,66,116],bb0_2:8,physreg:84,maybeoverridden:34,mappingnormalizationheap:67,fulfil:[4,102],exitcod:1,fastcal:[84,23],ascend:[71,23],substitu:10,llvm_enable_doxygen_qt_help:61,adequ:[73,37,61,54],confirm:92,llvmscalaropt:52,recomput:[76,16,42],ffi_library_dir:61,"__llvm_stackmap":88,inject:92,dw_op_plu:23,ret_val:[12,13,14,15,19],overli:27,broken:[39,98,54,1,10,27,78,76,116],cuinit:8,selectaddrrr:54
,cornerston:103,x32:5,x30:23,dw_ate_address:23,island:[105,25],loadinst:92,pluginfilenam:80,deopt:72,llvm_targets_to_build:[24,37,61],lcamtuf:26,livecount:73,noth:[76,32,103,73,23,45,84,47,10,66,4,15,16,17],hashtbl:[12,13,14,15,18,19],strip:[],"0x3fe9":56,ymax:[14,2],mingw32:[10,114,84],overwrit:[20,88,52],legalact:54,savethi:5,x86inst:6,source_x86_64:79,dw_ate_boolean:23,jite:[39,99,50],gori:27,buggi:62,stringmapentri:16,runtest:[33,9],reappli:27,possibl:[],optnum:20,poolalloc:42,unusu:[40,73,84,85,11,66,16],sanitize_address:23,embed:[],i32mem:116,emitpseudoexpansionlow:21,machinefunctioninfo:84,emitloc:41,threadloc:[23,112],subprogram:[41,23,56],deep:[],simpletyp:109,deem:[65,62,23,94],emitvalu:84,release_xyz:94,proport:[66,20],fill:[41,42,43,23,31,45,47,2,49,50,76,56,92,113,114,67,16,20,62],denot:[24,67,73,84,112,23],mangler:54,know:[],field:[],loadobject:75,"0xc0de":112,riinst:116,architectur:[],reextern:[41,43,47,2,49,50,12,13,14,15,19],"0th":103,sequenc:[],arrayidx:23,unload:[
76,23],descript:[],v2f64:23,version_less:61,winzip:37,getreturntyp:16,unset:[41,30],insertbefor:16,forget:[73,41,92,102],mrm3m:54,dollar:36,dw_form_ref2:56,sunk:42,llvmdummyasmprint:54,dw_form_ref1:56,regno:84,mrm3r:54,dw_form_ref8:56,children:[66,102],tag_structure_typ:56,image_sym_class_clr_token:109,at_byte_s:56,cmake_c_compil:24,daniel:56,brtarget8:54,immt:6,image_scn_lnk_comdat:109,r14:[84,6],r15:[84,23,6],r12:[23,84,22,6],r13:[84,6],r10:[84,85,6,8],r11:[85,23,6,88],fals:[32,92,47,1,36,3,69,23,41,102,42,43,44,98,9,2,49,50,34,13,16,54,20,56,76,21,80,24,83,66,90],offlin:[84,8],util:[],fall:[32,41,54,73,16,20,47,2,49,50,59,92,23,12,13,14,15,5,31],"0x629000004748":26,"__clear_cach":23,basereg:84,run_funct:[12,13,14,15],int8ti:16,gcno:95,use_end:16,stderr:[],fuzzerinterfac:26,quiet2:20,webkit_jscc:[23,112],rawfrm:[54,116],globalalia:76,lawyer:27,val3:23,val2:23,val1:23,val0:23,val7:23,excit:[31,11,40,94],abc:23,parsedattrinfo:21,excis:23,abi:[],debug_pubnam:56,abl:[],desttool:66,con
t1:108,abu:97,g0l6pw:24,cont2:108,hurdl:98,compact:[40,41,73,84,11,38,88,16],cumemcpydtoh:8,valc:8,variat:[54,42,0,84,4,115],vala:8,sophist:[73,35,84,76,115,23],analysisusag:[],memory_order_acquir:[23,86],test_exec_root:1,variad:92,xemac:[24,66],valu:[],quieta:20,search:[],unabbrevi:112,image_rel_amd64_sect:22,createfcmpon:[41,47,2,49],r12w:6,r12b:6,val_:15,r12d:6,codebas:[92,107],narrow:[24,65,92,103,42,44,62,86,83,16],iuml:84,quotient:23,primit:[],transit:[],inappropri:31,establish:[54,73,72,84,50,27,51,12,23],memor:92,initializenativetargetasmprint:[41,47,2,49,50],mylib:66,zeroiniti:23,mfloat:9,tackl:[12,15,47,98,50],two:[],x86targetasminfo:54,getbit:20,saptr:23,desir:[32,92,72,1,69,23,6,75,40,5,10,11,51,16,54,73,20,56,76,22,83,31,88],upper16:22,penultim:54,reconfigur:[],anon_func_:50,particular:[32,62,34,35,1,95,92,23,6,71,84,8,102,113,47,48,50,10,51,72,12,15,16,18,75,54,103,73,20,56,76,21,24,83,31,42,86,88,112,108,28,30],ultrasparc:[24,54],dictat:[85,92,16],none:[84,72,1,94,69,
4,23,97,12,13,14,15,16,18,19,103,73,20,76,79,80,24,108,62,66,116],dep:[12,13,14,15],elsebb:[41,47,2,49],dev:[39,40,92,107,73,16,77,9,65,86,76,27,11,51,72,80,116,30,56],remain:[71,32,92,112,97,73,5,31,47,2,94,10,27,88,23,108,14,15,16,116],paragraph:[34,92,115],deb:9,binfmt_misc:24,def:[],share:[],sln:37,loopend:[41,15,47,2,49],mcobjectstream:84,minimum:[24,65,92,61,54,44,26,62,56,27,88,113,23,31,18],explor:[16,107],dw_ate_unsign:23,strlen:16,retcc_x86_32_ss:54,calltmp1:[43,13,49,19],calltmp2:[12,50],kcc:26,awkward:[20,92,103],secur:[32,20],cse:[12,65,60,86,50],comfort:34,unittestnam:61,runhelp:92,cst:23,csv:35,bar_map:92,regener:[62,54,94],emac:[24,92,6,66],runtimedyldimpl:75,number2:34,number1:34,add32mr:6,memory_order_seq_cst:[23,86],bloom:84,ccpassbyv:54,sse4:0,binloc:41,sse2:[10,23],mislead:92,hfc:91,cs1:42,image_sym_class_end_of_funct:109,rotat:[],intermediari:16,isconstantpoolindex:54,mydoctyp:67,through:[],suffer:73,llvm_src_root:[66,35,52],patfrag:54,pch:56,ssl_free:26,good:[
],pollut:[92,87],compound:71,nor:[32,92,103,73,34,84,37,88,112,66,4,23,98],adventur:16,complain:[],cmpflag:34,mysteri:103,micro:92,token:[],distdir:66,subsystem:[],harm:84,mm5:[6,116],unequ:23,mm7:[6,116],hard:[],mm1:[6,116],idea:[],functor:92,mm2:[6,116],image_file_machine_thumb:109,connect:[114,32,60,16,107],orient:[16,40,92,11,102],sparcgenregisterinfo:54,usedlib:[66,52],dw_tag_xxx:56,isref:116,variable_nam:61,dagcombin:65,isinlin:56,cconv:23,mmx:[84,23,54],intregssubregclass:54,suspici:4,roots_iter:73,cuctxdestroi:8,dw_tag_union_typ:[23,56],omit:[32,7,84,96,93,74,49,110,76,77,88,113,38,79,13,58,111,23,18],intermingl:23,buildmast:114,testfnptr:23,llvmgccdir:35,vmov:5,perman:[98,94],"__c_specific_handl":108,callon:16,registerasmstream:84,printsth:32,exchang:[24,16],setdatalayout:[41,31,47,2,49,50],argstart:20,done:[32,92,67,33,34,35,36,94,69,4,99,23,75,65,41,97,43,113,47,2,49,50,10,72,12,13,14,15,16,18,19,102,73,90,20,74,56,76,61,107,83,84,85,86,27,108,66,30,116],dylib:[10,63],sta
bl:[90,27,16,46,94],rootnum:73,functionindex:57,image_sym_type_uint:109,somewhatspecialsquar:102,expansionregiontag:71,least:[32,92,33,47,1,36,94,23,41,97,42,43,113,9,2,49,50,72,12,13,14,15,16,18,19,54,20,21,78,24,84,86,27,88,112,116],createpromotememorytoregisterpass:[41,47,50],unalign:86,memset:[],binop:[41,43,113,47,2,49,50,12,13,14,15,18,19],power8:31,selector:[],part:[32,92,67,34,1,37,23,6,40,41,102,42,43,44,45,47,2,49,50,10,11,51,72,12,13,14,15,16,17,18,19,54,103,73,113,20,56,76,21,78,24,61,83,31,84,86,27,112,108,28,66,90,26],pars:[],toc:[31,84],contrari:84,cyclic:24,i32:[],"_tag":[12,13,14,15,18,19],horizont:5,i8mem:84,"_runtim":88,fpinst:6,constval:16,xxxtargetlow:54,uncontroversi:73,char6:112,debug_loc:89,createalloca:[41,47],xmin:[14,2],built:[],zero:[],build:[],extractel:[],distribut:[],significand:23,previou:[],chart:0,most:[],cygwin:[24,37,84],image_file_machine_i386:109,charg:84,dereferenc:[],addsdrr:116,"234000e":[43,19],resolvereloc:75,t2item:34,sector:4,visitbasicbl
ock:16,carefulli:[73,47,56,27,15,23],particularli:[92,54,5,86,76,51,23,16],fine:[],find:[],realmag:[14,2],merger:34,filesizepars:20,printmemoperand:54,hasctrldep:[6,116],unus:[],express:[],cheaper:[91,16],wrinkl:48,restart:[76,114,26,16],misnam:84,mycustomtyp:67,image_file_machine_arm:109,diloc:[],common:[],intptrsiz:73,"_frame_handler3":108,printout:[74,16],decompos:[65,27],reserv:[91,54,72,84,94,88,112,23],mrm1m:54,ccdelegateto:54,someth:[32,92,67,34,37,69,4,5,40,41,84,42,43,23,47,2,49,50,11,72,12,13,14,15,16,18,19,54,102,20,65,21,111,24,26,62,27,113,115,30,116],someti:23,debat:92,smallest:[62,23],subscript:[32,23,42],experi:[61,34,56,36,50,72,12,66,115],altern:[],dw_at_apple_property_gett:56,bourn:[24,20,98],appreci:27,complement:[23,16,103],enginevector:50,popul:[24,65,8,108,26,1,87,21],alon:[113,20,84,10,27,66,18],tempor:23,densemapinfo:16,cpufreq:36,libcrypto:26,simpli:[32,92,72,35,4,23,97,42,43,5,98,9,50,10,12,16,52,19,54,103,113,20,74,56,76,24,83,84,27,88,18,108,66,29],fldcw
w:84,point:[],instanti:[75,67,102,54,20,1,76,95,21,16,6,116],linkagenam:23,alloca:[],suppli:[],setinternallinkag:16,throughout:[71,75,112,24,78,66,4,23],backend:[],global_begin:[92,16],dovetail:[15,47],aarch64:[],linkonce_odr:[23,51,112,8],retq:72,val1l:23,globalvarnam:23,reformat:29,multiclassobject:30,debug_nam:56,image_sym_class_extern:109,lto_codegen_add_must_preserve_symbol:90,unnecessarili:[76,42],gap:[92,23],understand:[],atomicrmw:[],isstoretostackslot:54,dw_tag_string_typ:56,unifi:[],fun:[40,45,22,11,66,12,13,14,15,17,19],everyon:[40,27,11,92],subsect:[],propag:[],lto_codegen_add_modul:90,mystic:[40,11],semispac:73,itself:[92,67,33,34,1,48,95,23,40,41,84,42,43,44,98,9,2,49,50,10,11,51,47,12,13,14,15,16,18,19,102,55,73,113,20,65,56,76,78,103,24,61,72,90,31,62,87,27,88,112,108,28,66,30,26,116],codegen_func:[12,13,14,15,19],"0x00007ffff7ed40a9":99,case_branch_weight:3,myseqel:67,incarn:65,benign:35,getlin:41,flag2:34,flag1:34,nameflag:56,keyr:24,"0x3fed":56,sym:[33,111,22],key
t:16,moment:[73,72,23,86,19],travers:[],task:[],n_bucket:56,entri:[],"16mib":22,uint32_t:[67,56],apply_token:26,spend:1,instr_begin:15,explan:[61,102,25,34,31,98,23],ldm:23,shape:[56,16,6,102,94],at_decl_lin:56,depriv:16,stwu:84,cut:[20,59,54],shiftinst:92,snan:23,singlesourc:[10,35],"0b000000":54,restructuredtext:[115,87],objectbodi:30,largeconst:88,realloc:42,rgm:76,bin:[24,95,33,44,20,9,87,10,64,37,26,6,52],bio:26,xcodebuild:61,llvm_tarball_nam:66,judgement:27,transmit:23,fucomip:84,phinod:[92,41,47,2,49],ccassigntoregwithshadow:54,knock:92,writealia:34,semi:[28,73,40,11],sema:21,adc32mr:6,aliasset:[54,42],often:[],steensgaard:42,weakodrlinkag:16,dllimport:[23,112],bach:4,"0x00002000":56,mirror:[],sizeof:[],sparcreg:54,arcmt:36,per:[67,72,35,38,23,71,97,8,50,12,16,102,73,20,56,76,21,59,61,90,31,84,86,111,88,112,108,28,66,30,26],pem:26,substitut:[],mathemat:[8,34,98,113,23,18],larg:[],chandlerc:107,cmake_instal:61,reproduc:[26,62,47,10,27,15,83],createentryblockalloca:[41,47],bb0_
1:8,intial:16,browsabl:61,patient:76,dw_tag_template_value_paramet:23,initialse:70,oeq:23,adc64rr:6,s15:23,llvm_definit:61,adc64rm:6,addpdrm:116,float_of_str:[12,13,14,15,17,18,19],selp:8,impos:[23,27,16,84,88],constraint:[],preclud:[72,78],createfadd:[41,43,47,2,49,50],litconfig:1,"0x00001c00":84,disclosur:27,timberwolfmc:35,fmin:23,add32mi8:6,ostream:[92,41,16],nsz:23,frames:73,n2242:92,"0x1c2":22,inclus:[],errno:[23,42],megabyt:[44,87],x86_fastcallcc:112,subst:[30,6,116],includ:[],cptmp0:54,cptmp1:54,forward:[32,92,72,4,23,65,42,43,113,45,49,16,17,18,19,73,56,57,108,84,112,30,116],image_scn_align_1byt:109,llvm_build_doc:61,reorgan:67,dwarfdump:[],int8_t:67,translat:[32,92,23,71,40,41,96,42,98,11,84,16,54,103,20,56,21,24,31,67,86,106],llvmfoldingbuild:12,sdk:[24,37],concaten:[24,78,30,10,23,16,116],internaltarget:66,mfenc:86,exported_symbol_fil:66,regconstraint:84,movnt:23,v8i16:54,glibcxx_3:24,curs:[44,1],attrinfomap:21,metal:23,somemap:92,image_file_machine_amd64:109,functioninf
o:91,codgen:19,isdigit:[41,43,113,45,47,2,49,50],prevail:97,singli:73,cmake:[],crypt:27,sequenti:[],abbrev:[89,112],llvm_target_arch:61,bpf_rsh:84,vg_leak:1,asymmetr:103,deseri:21,image_scn_lnk_remov:109,functionnod:34,mismatch:[],globalvar:112,formatt:23,tok_numb:[41,43,113,45,47,2,49,50],libtool:[24,98,66],mymodul:31,deserv:[23,51],image_sym_type_float:109,image_comdat_select_associ:23,machine_version_step:25,debugloc:41,downcast:102,i16:[84,23,54,8],tradeoff:[12,73,86,50],required_librari:28,dwarfregnum:54,"0fb5bfbe8e":8,queri:[],strex:86,regallocregistri:76,demangl:[79,111,56],privat:[],antisymmetr:34,sensit:[76,67,46,61,42],elsewher:[66,54,72],createtargetasminfo:54,granular:4,saga:[13,49],exit:[],priority_queu:16,loopinfowrapperpass:76,bpf_sub:84,immsubreg:54,vla:[],named_valu:[12,13,14,15,19],cudeviceptr:8,volum:[39,16,66],implicitli:[92,0,23,40,43,113,45,2,49,50,11,12,13,14,15,16,17,18,19,20,76,84,67,27,88,112,66,30,116],postord:60,refer:[],pbqp:[84,77],"0x9":84,"0x8":84,for
tun:[40,92,47,49,50,11,12,13,15,16],veli:84,"0x3":[88,84,16],segmentreg:84,"0x1":[88,84,16,56],"0x0":[84,16,112,25],"0x7":84,"0x6":84,"0x5":[84,88],"0x4":[84,88],append:[61,97,23,96,10,95,112,44,13,16,52,116],"0x1f84":79,resembl:103,unwound:23,access:[],agg1:23,agg3:23,agg2:23,deduc:[],camlp4:[17,18],sint:23,bodi:[],"0xh":23,sink:[],"0xm":23,jonathan2251:53,"0xc":[84,112],"0xb":84,getsourc:24,sine:[23,54],"0xf":116,llvm_abi_breaking_check:61,"0xd":[84,112],remark:[83,0],libc:[24,40,92,23,31,27,11,108,16],fpregsregclass:54,cerr:8,foundat:76,mov64ri:54,tool_nam:24,quickstart:[],toshio:84,seamless:64,faddr:50,advoc:92,projlibspath:66,select_isd_stor:54,"_regoffset":6,at_encod:56,int32ti:16,bpf_jne:84,trait:[92,16,67],attrspel:21,image_scn_align_512byt:109,trail:[71,92,103,67,16,20,1,23],account:[24,107,102,73,34,27,114],dcmake_c_compil:26,komatsu:84,createlocalvari:41,rdynam:[14,15,2,50],obvious:[32,65,92,103,42,33,34,20,45,50,76,27,23,113,84,16,17,18,116],ch8:41,unread:[92,86],fetch:[
24,3,23,84],aliv:[76,32,84,16,34],n2657:92,abcd:112,tarbal:[39,94,9,66],virtualindex:23,msvc:[22,92,16,84],formmask:54,predicate_stor:54,everywher:[10,12,67,50,34],add32ri:6,rootcount:73,dw_at_apple_property_attribut:56,add32rm:6,inteldialect:23,gcn:25,ssl_ctx_use_privatekey_fil:26,smovq:84,add64mr:6,powerpc64:105,getehframesect:75,inst:[32,26,16,54,116],getsigjmp_buftyp:92,llvm_include_dir:61,redund:[],bind:[92,23,39,41,43,113,98,47,2,49,50,12,13,14,15,18,19,54,31,67,30,116],correspond:[32,92,67,34,37,69,5,6,71,65,41,102,8,43,23,46,49,72,13,84,16,98,18,19,101,54,103,73,113,20,104,56,76,77,22,78,79,24,60,61,83,62,86,87,27,112,108,30],afterloop:[41,47,2,49,13,14,15],region1:71,region0:71,noitin:80,fallback:112,loopendbb:[41,47,2,49],writethunkoralia:34,jithelp:50,declet:23,machineconstantpool:84,symbolt:16,cpu_x86_64:67,bunch:[45,35,98,2,50,12,14,16,17],tok1:26,acycl:[84,60,54,106],outputdebuginfo:20,ilp32:[40,11],labor:20,i1942652:23,typemap:65,objmakefil:66,basic_ss:116,greater:[32
,92,112,54,8,73,34,84,95,3,78,38,103,23],passnam:74,dbgopt:56,spell:[27,21,92],dai:[39,40,61,24,94,27,11,16],mention:[112,39,92,61,78,25,102,34,20,84,85,56,23,72,28,16,116],symbol1:22,nval:23,mylist:67,isimplicitdef:6,strive:[10,92],createfcmpult:[41,43,47,2,49,50],parseexpress:[41,43,113,47,2,49,50],mem2reg:[],destarchivelib:66,dwo:89,dllvm_libdir_suffix:61,add16ri8:6,lie:20,getloopinfo:76,intellig:[23,16],cmake_module_path:61,addtypenam:16,llvmsupport:[24,52,66],usernam:[24,27],fluctuat:42,rex:23,paramattr:112,start_val:[13,14,15],dlibcxxabi_use_llvm_unwind:31,createmyregisteralloc:76,dllvm_enable_backtrac:24,rev:[78,12,13,14,15,18,19],ret:[],stub:[34,84,16,105,54],typenam:16,stuf:5,rel:[92,33,35,1,94,38,23,39,41,5,98,49,13,16,52,73,20,22,59,24,26,84,85,88,112,29],rem:84,image_file_machine_powerpc:109,rec:[12,13,14,15,17,18,19],dw_apple_property_assign:56,ref:[],reg:[54,8,84,88,29,5,116],red:23,clarifi:[86,56],insid:[32,92,67,33,34,35,1,23,71,39,9,99,10,72,16,102,55,73,56,76,21,26
,84,87,112,30,116],workflow:26,qux:23,standalon:[40,41,31,84,51,28,45],invas:[27,67],afterward:32,setinsertpoint:[41,43,47,2,49,50],i128:31,retain:[60,16,20,98,76,27,78,66,23],ud2:84,suffix:[76,65,92,61,54,25,43,23,20,1,97,10,95,96,77,93,66,16,19],createcompileunit:41,pgo:110,targetregsterinfo:84,pgr:39,ualpha:30,secondlastinst:54,facil:[92,42,73,20,1,56,37,66,4,31,52,98],misoptim:3,llvm_enable_eh:61,stencil:31,target_data:[12,13,14,15],messag:[],sadli:107,dw_apple_property_sett:56,llvmusedlib:66,comparefp:116,ogt:23,mytool:66,s31:23,s32:8,pg0:34,pg1:34,"__objc_imageinfo":23,nontempor:23,image_file_aggressive_ws_trim:109,source_i386:79,rpass:0,structur:[],ssl_ctx_use_certificate_fil:26,"123mb":20,then_val:[13,14,15],plaintext:87,thereaft:88,subclassoptionaldata:34,ehobj:108,ispack:112,have:[],tidi:76,llvm_build_dir:24,bpf_jsge:84,min:[33,26,23],mib:22,mid:[23,48],in64bitmod:84,sspreq:[23,112],mix:[],builtin:[],bpf_jsgt:84,mip:[],parsetypetyp:65,mit:[31,27],isloc:[23,56],poison_yet_a
gain:23,unless:[32,92,72,35,94,95,23,7,5,98,47,49,10,51,13,15,16,54,103,73,20,76,77,61,82,25,83,26,87,27,88,108,66,115],setpreservescfg:76,eight:[84,23,97],transcript:[12,50],v8i32:23,arm_aapcs_vfpcc:112,gather:[],thunderbird:27,image_file_machine_mipsfpu16:109,getdirectori:[41,56],institer:16,instantiatetemplateattribut:21,occasion:[73,112],addpassestoemitmc:75,addtmp:[41,43,47,2,49,50,12,13,14,15,19],dllexport:[23,112],retainedtyp:[23,56],ifconvers:54,text:[],ifconvert:54,sanitize_thread:23,llvm_map_components_to_libnam:61,setter:[23,21,16,56],dw_tag_pointer_typ:[23,56],textual:[60,77,84,50,10,95,21,27,12,29,116,23,6,98],loweroper:54,src_root:24,"__morestack":85,cpunam:[80,77],inferior:99,data64bitsdirect:54,print_newlin:[12,13,14,15],lower_bound:16,litvalu:112,sysv:111,disagre:23,bear:5,is_base_of:102,image_sym_class_member_of_struct:109,increas:[32,92,0,43,31,62,27,51,100,80,90,6,19],organ:[],at_end:[12,13,14,15,19],callpcrel32:116,blogspot:26,integr:[],printlabel:54,conform:[24
,92,67,73,23,1,16,98],project_nam:52,emitfnstart:84,ssl_ctx:26,dw_tag_file_typ:56,reform:92,pattern:[],boundari:[32,78,23,84,112,16],progress:[60,61,73,108,45,1,94,27,105,84,16,17],"0b100":116,"0b101":116,switchtosect:84,nvptx64:8,phase3:33,plugin:[],equal:[92,34,3,23,41,102,42,113,98,47,2,49,51,13,14,15,16,18,54,20,59,25,108,84,112,116],instanc:[],freeli:[27,86],comment:[],guidelin:[],vend:48,functionnam:[73,23],v2i32:23,gc_transit:72,defini:69,addresssanit:[26,23],autovector:0,component_1:28,component_0:28,tranform:23,createmul:16,bulk:[47,15,16,84],determinist:[83,21,16,84,42],multi:[],plain:[76,115,16],defin:[],rpo:60,operandtyp:54,ill:97,func_typ:72,helper:[92,34,1,75,41,42,43,113,47,2,49,50,10,14,15,16,17,18,19,54,20,56,21],almost:[24,65,60,73,31,84,92,27,78,4,16],irreduc:[32,54],maystor:6,isreturn:[6,116],build_alloca:15,substanti:[92,42,73,50,12,23],fiddl:[16,115,9],unneed:[15,47],llvm_enable_zlib:61,japanes:24,"__cxxframehandler3":108,codepath:86,infer:[92,102,55,72,84,67,7
7,51,78,80,66],backtrac:[84,41],cmakecach:61,valueopt:20,dealloc:[73,23,16],default_branch_weight:3,sm_30:84,image_scn_align_32byt:109,sm_35:84,center:41,neural:35,nevertheless:23,getopcod:[16,54],builder:[],col:41,thought:[],setp:8,choos:[84,69,23,43,44,45,49,50,12,13,16,17,18,19,54,73,20,56,76,78,80,61,62,27,113,114,66],latest:[33,24,31,5],test1:[10,72,115],tarjan:76,test5:5,listconcat:[30,116],numberexprast:[41,43,113,47,2,49,50],p18:8,settabl:66,tough:[113,18],kwd:[12,13,14,15,17,18,19],adt:[],lako:92,add_cfg_simplif:[12,13,14,15],onward:61,uwtabl:[23,56],add:[],cleanup:[],voila:26,ada:108,dced:16,c11:86,createbasictyp:41,polybench:31,smart:[92,23],apple_typ:56,hypersparc:54,fnscopemap:41,pcre2posix:26,image_file_net_run_from_swap:109,punctuat:[23,92,30],realiz:[12,14,65,2,50],positionaleatsarg:20,canlosslesslybitcastto:34,insert:[],like:[],success:[67,92,23,41,43,113,47,2,49,50,12,13,14,15,18,19,54,55,76,24,62,27],sstream:92,registeranalysisgroup:[],inferenc:84,c1x:23,stlextra:
[41,47,2,49],soft:[],crawler:73,unreach:[],vec01:23,convei:[73,108,27,23,51],registermcobjectstream:84,"_m4enum":23,proper:[71,92,102,54,16,31,1,86,23],getparamtyp:16,release_1:24,tmp:[61,103,73,23,84,47,50,10,79,12,15,5,52,16],nvcc:84,llvmrock:92,esp:[84,5,6],nvcl:8,"__internal_accurate_powf":8,dw_tag_structure_typ:[23,56],prose:92,image_scn_lnk_nreloc_ovfl:109,dce:[],noisi:[32,27,16],host:[],"0xffff":[88,23],geometr:[40,11],simpler:[32,65,84,47,2,56,14,15,23],about:[],actual:[91,32,92,67,33,34,35,1,102,4,5,75,40,41,97,42,43,23,45,98,47,2,49,50,10,11,51,72,12,13,14,15,16,17,18,19,54,103,73,113,20,56,76,114,78,24,60,83,26,84,27,52,112,108,28,66,116],endcod:92,discard:[24,20,84,22,23],addendum:39,vocabulari:23,guard:[92,23,21,22,51,66,16],getglobalcontext:[41,43,47,2,49,50,16],ifexpr:[41,47,2,49,13,14,15],leverag:[73,31,16],mm0:[84,6,116],rcx:[84,6],eh_fram:[108,31],naveen:32,rcn:33,getelementptrinst:16,"__cxxthrowexcept":108,gene:31,biggest:[84,48],calltwo:16,mm3:[6,116],functionlis
ttyp:16,unexpect:[92,34,35,47,37,27,15],f4rc:84,bur:60,brand:76,machinefunctionpass:[],bui:36,bug:[],wise:23,mcpu:[25,54,8,9,10,77,80],wish:[24,65,62,61,54,103,72,23,20,1,87,94,51,34,66,16,116],srcarglist:23,flip:92,rc2:[33,94],emitjumptableinfo:54,pin:23,hashfunctiontyp:56,dure:[],pic:[84,54,31,62,9,56,80],int64_t:[31,67,16],llvm_append_vc_rev:61,guidanc:[92,51],detail:[],virtual:[],dw_apple_property_strong:56,argumentlisttyp:16,apple_objc:56,gcc:[],zeroormor:20,escap:[24,42,73,30,2,10,90,23,14,5,29],ksdbginfo:41,al_aliasset:54,afterbb:[41,47,2,49],binoprh:[41,43,113,47,2,49,50,12,13,14,15,18,19],predsens:69,"_zfoov":23,old_c:50,unshadow:[41,47,2,49,13,14,15],"_ztv3foo":5,eliminateframeindex:54,liveout:[72,88],n2756:92,poorli:[92,59],bpf_arsh:84,getreginfo:84,undef:[],patcher:88,isvi:54,spec:[67,16,35,62,56,94,10,23,30,116],add_incom:[13,14],concret:[],under:[92,72,1,23,6,71,40,8,44,98,48,10,11,18,53,54,20,76,114,24,61,31,84,87,64,27,113,28,66],emitloadlink:86,testabl:[31,107],play
ground:[45,17],everi:[],risk:[23,94],f934:54,rise:92,risc:[84,86,54],implicit:[],upstream:24,printfunctionpass:32,llvm_yaml_strong_typedef:67,z13:31,mygc:73,verif:[],isdefinit:[23,56],x86_64:[],properti:[],dw_form_ref4:56,xxxinstrinfo:[69,54],naiv:32,enjoi:114,xor32rr:84,llvm_yaml_is_document_list_vector:67,blue:31,hide:[],introspect:[72,29,90,57],foundfoo:92,hi16:84,conduct:27,asymmetri:[91,34],functiontyp:[41,43,47,2,49,50,16],studio:[],path:[91,32,92,9,35,1,95,37,23,97,8,44,98,47,10,51,72,15,16,52,101,55,73,76,77,79,80,24,61,108,26,42,86,87,64,66,106,31],dlopen:[76,66],forum:[39,23],parallel_dir:[66,52],mypassopt:76,anymor:[76,31,16,50],pointcount:73,precis:[],portabl:[],nontempl:20,bitset2:104,winehprepar:108,distalwai:66,printd:[40,41,47,2,11,14,15],strai:10,printf:[71,24,41,83,98,47,2,56,64,37,90,14,15,23],cont:[23,48],ymin:[14,2],short_enum:23,describ:[91,32,92,67,34,35,1,68,94,69,5,6,71,39,40,41,97,8,43,23,45,103,2,49,50,11,51,72,12,13,14,84,16,17,18,19,75,54,55,73,102,20,65
,56,76,77,22,78,59,24,60,25,108,31,62,27,88,52,112,113,28,66,90,116],would:[],gcstrategi:73,addincom:[41,47,2,49],llvm_doxygen_qhp_cust_filter_nam:61,autogen:26,include_directori:61,must:[],llvmdummycodegen:54,join:[76,23,16,80],getnumoperand:16,"0x4db504":26,image_file_machine_mipsfpu:109,runfunct:[16,99],introduc:[32,72,48,23,6,54,42,5,47,2,49,34,13,14,15,16,102,94,84,86,88,116],localrecov:[],"__data":23,helpingmemorymanag:50,virtreg2indexfunctor:84,inadvis:103,registerehfram:75,attract:[73,27],makellvm:24,uselistord:23,straightforward:[102,54,43,56,98,47,2,49,50,76,11,78,12,13,14,15,16,19],pipefail:1,concis:[84,20,27,92,103],hasnam:16,env:33,frameless:84,subproject:[24,31,27,94,39],collaps:23,dialect:[29,23],memorydependencyanalysi:86,mess:[24,32],befor:[],getreservedreg:54,const_iter:16,parallel:[24,60,61,0,26,1,87,63,114,66,84,23,31,52],bootstrap:24,exclud:[44,84,27,23,69,66,5],parserclass:20,includedir:[66,101],environ:[],incorpor:[84,16,102],enter:[24,84,107,108,1,56,87,50,11
2,113,12,83,18],exclus:[72,20,84,23,86],hasexternallinkag:16,frontend:[],wavefront_sgpr_count:25,over:[],commasepar:20,imul:84,blatent:[15,47],optional_dir:[66,52],str_offset:56,modref:[116,86,42],parseparenexpr:[41,43,113,47,2,49,50],align32bit:112,imm:[29,84,54,116],baseinstrinfo:21,image_sym_type_dword:109,tramp:23,replaceinstwithinst:16,getorinsertfunct:16,fadd:[],comprehens:[],llvmbc:112,settruncstoreact:54,cfgsimplifi:16,getlazyresolverfunct:54,flaground:67,const_global_iter:16,choic:[93,24,40,92,72,23,26,36,49,88,77,11,65,13,16,45],cmake_cxx_flags_releas:24,alex:71,exampletest:1,modrefresult:42,each:[],use_begin:[92,16],complet:[32,92,67,34,1,68,94,95,37,4,23,75,39,41,84,8,43,44,45,47,2,49,50,10,51,72,12,13,14,15,17,18,19,54,73,20,74,56,76,89,59,60,108,31,42,27,112,113,66,90,116],prohibit:[90,86],abbrevwidth:112,gprc:84,tag_pointer_typ:56,goe:[41,61,84,54,8,73,23,26,62,47,86,67,108,66,29,15,16,98,56],llvm_optimized_tablegen:24,newli:[32,41,43,72,2,49,50,64,12,13,14,16,19],lai
d:[16,84,50,78,12,23],adjust:[],rs2:54,got:[],unimagin:72,worthwhil:16,precaut:16,threadidx:8,free:[92,72,94,40,105,42,43,45,50,10,11,12,16,17,19,73,76,60,107,31,84,86,66],getfilenam:[41,56],rangelist:30,precompil:8,puzzl:62,astdump:21,r9d:6,r9b:6,openssl:26,filter:[],addrspac:[72,23,8],rais:[32,73,23,83,108,12,13,14,15,16,17,18,19],"0x0000000000000002":99,r9w:6,onto:[24,73,23,84,56,94,27,34,16],rang:[],becaus:[91,32,92,0,34,35,1,48,37,69,4,5,6,71,40,41,97,42,43,23,45,98,9,2,49,50,11,51,47,12,13,14,15,16,17,18,19,75,54,103,73,102,20,56,76,111,78,57,94,24,107,72,83,84,86,87,67,27,88,113,112,108,66,90,116],xnorrr:54,wordsiz:73,rank:32,restrict:[],datastructur:16,alreadi:[92,67,34,48,102,23,6,65,41,84,42,43,45,98,47,2,49,50,10,72,12,13,14,15,16,17,52,19,54,73,20,56,76,24,61,31,62,85,27,88,115,26],hackabl:[45,17],createcfgsimplificationpass:[41,47,2,49,50],consecut:[78,0,5,26,104,56,76,23,30],primari:[23,39,41,42,43,113,45,47,2,49,50,12,13,14,15,16,17,18,19,73,84,27],rewritten:[31,84],t
op:[],seq_cst:[23,86],downsid:16,tok:41,ton:[45,17],too:[91,92,67,34,36,37,4,23,40,41,113,47,10,11,15,83,18,20,76,24,16,26,84,64,27,66,116],tom:67,toolset:[31,61],corpus:26,initialize_native_target:[12,13,14,15],consol:[12,39,84,115,50],tool:[],usesmetadata:73,took:[41,43,47,2,49,50,12,13,14,15,19],conserv:[92,42,73,72,86,94,76,90,88,23,59],dw_tag_gnu_template_template_param:23,reinterpret_cast:26,expr:[7,41,113,47,2,49,106,12,13,14,15,18,19],atomtyp:56,fashion:[24,65,22,54,23],ran:[76,95],ram:114,raw:[71,75,7,84,96,82,93,20,74,95,21,57,29,35],lbd:53,further:[],unreloc:72,rax:[54,72,84,88,23,6],adc32mi:6,unresolv:[66,40,1,11],thorough:92,sk_somewhatspecialsquar:102,xfail:[10,35,1],expr0lh:71,thoroughli:[13,49],has_jit:28,atom_count0:56,though:[32,92,34,35,23,65,41,43,113,47,49,10,12,15,16,18,19,102,103,73,20,56,76,59,108,31,84,86,90],visitfab:65,glob:7,"__apple_typ":56,bss:80,sethi:54,bsd:[24,27,97,31,111,66],"0x00000002":56,"0x00000003":56,"0x00000000":56,"0x00000004":56,"0x0000000
9":56,flow:[],roots_begin:73,getorcreatefoo:16,declas:23,declar:[],radix:[84,92],pred_begin:16,shouldexpandatomicstoreinir:86,cumoduleloaddata:8,"0x70b298":76,random:[],radiu:102,smallvectorhead:16,rst:[84,21,115],popq:[72,88],radic:84,dfapacket:[],lit_config:1,absolut:[],package_str:61,bitcoderead:65,nextprec:[41,43,113,47,2,49,50],multiclassid:30,getreg:[84,54],llvm_yaml_is_sequence_vector:67,label0:23,twiddl:[41,47,2,49,50,12,13,14,15,23],watch:[27,92],image_scn_type_no_pad:109,pointertyp:[31,16],report:[],mybuilddir:61,sparclet:54,aliasanalysisdebugg:42,twice:[24,33,34,50,76,37,23,12,66,16],sunit:84,isoper:[41,47,2],basicblock:[],stringwithcstr:56,lto_module_is_object_file_for_target:90,habit:[32,92],nuw:[23,51],memory_order_releas:[23,86],storesdnod:54,richer:88,nul:[14,16,2],num:[73,72,23,54],libsampl:52,corrupt:[108,26,11,40,97],dumpattr:21,hopefulli:[],databas:[40,67,11],image_file_machine_mips16:109,valb:8,tolmach94:73,mul:[],approach:[],weak:[112,34,31,47,86,90,51,23,111,1
5,16],protect:[92,54,26,84,86,112,4,23],critedge1:8,fault:[],lgkmcnt:25,r7xx:105,"4gib":22,mybarflag:67,lto_module_cr:90,gendfapacket:84,callseq_end:72,coldcc:[72,23,112],max_int_bit:16,trust:[27,92],nake:[23,112],nonsens:[15,47,115],been:[32,92,78,67,33,34,1,94,38,4,99,5,6,75,40,97,8,43,44,98,2,49,50,11,100,72,12,13,14,16,18,19,54,103,73,113,20,74,65,56,76,23,24,107,83,31,84,86,87,27,88,52,108,66,115,30,116],accumul:[32,0,26,12,13,14,15,18,19],fnloc:41,oldbind:[15,47,41],quickli:[],getsymbolt:16,"0x000003bd":56,msec:0,xxx:[35,92,5,54],uncommon:108,expected_v:23,testcaselength:16,craft:16,"catch":[],upcast:102,image_sym_class_undefined_stat:109,simplevalu:30,bpf_exit:84,basic_p:116,basic_r:116,lesser:78,weren:27,curvar:[15,47,41],cumemalloc:8,cdecl:23,p_reg:84,image_sym_type_mo:109,svr4:97,vk_argument:92,exterior:72,registermypass:76,tediou:67,list_property_nam:28,suggest:[76,24,92,42,23,100,9,63,27,72,16,6,52],armasmprint:21,complex:[],disableencod:6,dooneiter:83,sk_lastsquar:102,a
san_opt:26,sched:[80,84,54],ind4:23,darwin9:5,xyzzi:92,binaryexprast:[41,43,113,47,2,49,50],build_ret:[12,13,14,15,19],"0x08":56,introductori:39,property_nam:28,redefin:[116,43,47,2,14,15,19],sethiddenflag:20,image_scn_mem_not_pag:109,bugzilla:[39,33,72,94,10,27],shortli:41,memarg:48,everyth:[94,37,23,39,8,43,113,45,2,49,10,13,14,17,18,19,103,20,76,24,84,86,87,64,66],spencer:4,addend:23,makevehicl:92,setcurrentdebugloc:41,finalizememori:75,createreassociatepass:[41,47,2,49,50],meta:[73,16,31,84,56,88,23,6],numliveout:88,shorthand:116,"0x03":88,expos:[],interfer:[108,51,103],patchpoint:[],elf:[],"0x7fffffffe018":99,els:[],at_artifici:56,explanatori:[35,27],elt:23,gave:34,xnor:54,setloadxact:54,disposit:27,howtosubmitabug:24,"______________________":16,thumb2:[84,23,57],thumb1:23,gr64:84,end_:[13,14,15],apart:[61,16,78,42],unindex:54,arbitrari:[92,72,1,23,40,42,43,113,45,103,47,50,11,12,15,16,17,18,19,54,55,73,20,56,76,108,31,84,27,88,112,28,116],loadlal:23,contradict:27,build_add:[12
,13,14,15,19],unstabl:[33,36],entry_block:15,hung:16,ifexprast:[13,41,47,2,49],scopelin:[41,23,56],llvm_use_sanit:61,excerpt:8,"000000e":[43,47,49,50,12,13,15,19],enumcas:67,indirect:[],successfulli:[42,0,72,62,9,2,94,114,89,14],live_end:73,"0x401000":79,icc:[24,56,0],attrparsedattrimpl:21,guaranteedtailcallopt:23,armv7:[24,23,36,78,94],armv6:36,armv8:[105,6],registerclass:[84,21,6,54],core:[],clase:16,tour:[113,18],subtmp:[41,43,47,2,49,50,12,13,14,15,19],cast210:23,"0x2":[88,84,16],meyer:92,chapter:[],min_int_bit:16,canreserveresourc:84,surround:[32,103,23,86,88,5,6],unfortun:[40,92,34,48,49,50,76,11,12,13,16],distinct:[32,112,103,42,43,5,84,56,10,23,28,66,16,19],g_inlined_into_f:79,algo:76,bitsetcas:67,approxim:[3,37,1],produc:[32,92,78,0,34,1,38,4,5,71,41,84,43,44,46,9,48,49,50,11,47,12,13,15,16,98,19,54,103,73,77,74,56,76,21,23,97,24,61,72,83,26,62,86,87,67,64,27,108,28,66,29,31],addpsrr:116,ppa:24,instcombin:[],regist:[],encod:[],othervt:54,parse_bin_rh:[12,13,14,15,18,19],cre
atefmul:[41,43,47,2,49,50],objectso:66,storag:[],addpsrm:116,git:[],closur:[28,40,11],readattribut:21,stuck:[40,11],reli:[92,108,103,0,33,23,26,84,47,56,10,73,27,90,78,72,66,15,16,59,98],gid:97,image_sym_type_enum:109,synthesiz:31,hassideeffect:6,synthesis:26,head:[24,92,73,23,115,30,116],medium:80,tokens_fil:26,heal:91,unconvinc:26,modulepass:[],p0i32:5,add_definit:61,heap:[],icmp:[],n2541:92,counsel:27,attr:[21,23,56,112],lsan:26,fundament:[],autoconf:[24,61,54,98,87,94,16],loadregfromstackslot:[84,54],adorn:[115,23],uncoop:73,trig:54,eieio:23,"_ztv3bar":5,trip:[],readonli:[32,72,56,88,51,112,23],tirefactori:92,add_execut:61,when:[],tid:8,tie:23,node:[],v_mul_i32_i24_e64:25,uint8:[91,88],consid:[],idx3:103,cooper:[73,64],idx1:[23,103],src:[101,54,33,35,84,94,23,52],uniformli:92,"0x0f":88,libcuda:8,faster:[24,92,97,34,26,36,83,23,108,114,66,16,31,56],bullet:[98,102],freebench:35,seciton:22,backward:[],impli:[54,42,73,30,84,87,27,88,23,66,79,4,103,16],focus:[84,54,73,72,46,10,16],ca
tagor:32,movabsq:[88,85],signific:[65,92,112,78,42,73,34,26,45,2,49,76,27,90,23,72,108,14,16,17],computation:60,llc:[],setindexedstoreact:54,n32:[31,23],lld:[24,92,61],addregisterclass:[84,54],readabl:[],getorcreatetypearrai:41,pop_back:[20,41,16],sourc:[],t1item:34,fnaddr:50,feasibl:[23,9],cool:[41,43,20,47,2,49,76,12,13,14,15,19],cuctxcreat:8,curop:54,level:[],quick:[],release_26:24,release_27:24,release_24:24,release_25:24,"__builtin_longjmp":108,release_23:24,release_20:24,release_21:24,release_28:24,release_29:24,hsa:25,magnif:[14,45,2,17],endcond:[41,15,47,2,49],port:[24,40,98,0,31,84,37,11,114,4],llvmlib:[66,52],repli:27,"64bit":[33,23],exitcond:23,sgi:16,alphajitinfo:54,eckel:16,pratik:31,u32:[84,8],llvmld:66,negeightkind:23,declare_funct:[12,13,14,15,19],fmax:23,memory_order_relax:[23,86],testsut:66,fmag:97,dw_tag_restrict_typ:[23,56],preorder:102,createbasicaliasanalysispass:[41,47,2,49,50],writethunk:34,switchsect:[73,84],preserve_allcc:[23,112],r6xx:105,legalizedag:65,do
rit:0,weird:84,automaton:[84,21],machine_version_minor:25,semant:[],inlinedat:[23,5],builder_at:15,globallayoutbuild:104,tweak:[63,24,20,102],visibl:[],memori:[],camlp4of:[12,13,14,15,18,19],pred:[8,23,47,49,13,15,16],preg:[26,84],pref:[23,16],todai:[92,86,103],handler:[91,108,84,23,86],upheld:72,instalia:84,diflagvector:23,msg:23,andw:5,prev:16,msb:84,reorder:[23,56,5,86,72],plug:[43,19],capit:[27,92],drown:35,prototyp:[],build_br:[13,14,15],registerinfo:[],function_typ:[12,13,14,15,19],purpos:[32,92,33,34,4,23,6,41,8,43,50,51,72,16,103,20,100,76,21,78,24,108,84,87,27,66],image_file_executable_imag:109,stream:[92,0,93,5,23,71,7,96,44,12,13,14,15,16,17,18,19,54,74,65,76,111,24,82,84,67,112,113],sidelength:102,parse_binary_preced:[14,15],add8rr:84,critic:[],gettyp:[92,16],alwai:[],differenti:[28,4,22,107,66],localescap:[],stepval:[41,47,2,49],twoargfp:116,anyon:[27,86,54,56],fourth:[54,20,76,88,13,23],llvmvalueref:31,cstptr:23,"__nv_isinff":8,no_switch:0,xzr:23,clone:[24,26,1,47,76,6
4,21,15,16],mcdisassembl:84,"4th":84,interconnect:31,geforc:8,testresult:39,colfield:69,practic:[91,32,92,72,23,43,45,98,49,50,12,13,16,17,19,102,103,73,20,56,60,26,86,27,88],firstlett:99,calltmp6:[15,47],predic:[],the_fpm:[12,13,14,15],programmat:[73,67,8],destmodul:66,preced:[32,92,1,23,41,42,43,113,45,47,2,49,50,12,13,14,15,16,17,18,19,55,56,111,88,30],combin:[],practis:59,nextindvar:23,sphinx_execut:61,blocker:33,ymmv:92,size_t:[73,26,67,90,50],synthesizedcd:78,canari:23,fsanit:26,foo_dtor:48,gte:23,branch_weight:[3,59],passag:92,pinsrd:5,platform:[],gtu:8,getsymboladdress:[51,50],ymm0:88,underneath:[10,24,87,52],maskedbitsetcas:67,flagspointi:67,inoperandlist:[6,54],sourceleveldebug:41,term:[32,92,34,4,23,39,42,98,10,72,73,56,78,60,107,108,84,86,27,88,30,116],name:[],getoperatornam:[41,47,2],realist:[73,113,18,116],selectcod:54,varexprast:[41,47],the_execution_engin:[12,13,14,15],individu:[],otherspecialsquar:102,const0:112,getdoubleti:[41,43,47,2,49,50],x86call:116,profit:[91,
32,84,51,0],decimalinteg:30,hasloadlinkedstorecondit:86,profil:[],sctx:26,roundp:0,iscxxclass:56,factori:[32,92,16],aliase:[34,23,112],numberofcpucor:26,"\u03c6":23,migrat:[73,31,27],write_escap:76,integertyp:16,theori:[34,40,67,11],getvalueid:34,boehm:73,synchron:[90,26,23,86],refus:[24,7,61,82,32,93,74,96],motion:[],turn:[],place:[32,92,0,33,34,1,23,6,71,40,97,43,113,45,47,2,50,10,11,72,12,14,15,16,17,52,19,54,103,73,20,65,56,76,114,78,80,24,25,83,31,84,87,67,64,27,88,108,28,66,116],ture:[12,113,18,50],imposs:[40,54,42,86,27,11,78],str1:116,origin:[24,41,97,103,55,72,16,31,84,56,87,95,27,100,23,66,4,108,5,6],suspend:73,sanitize_memori:23,dw_apple_property_copi:56,arrai:[],bou_fals:20,rodata:[31,54],predefin:[76,84,14,1,2],unrecogn:20,"0x00003550":56,given:[32,92,67,72,1,95,37,38,102,4,23,75,65,97,42,43,113,46,2,51,14,16,98,18,19,54,55,20,74,104,56,76,21,79,59,24,61,108,26,84,86,110,64,88,112,28,66,30,116],frameindex:54,image_sym_class_external_def:109,associ:[32,92,72,3,4,23,71,97
,113,50,34,16,18,75,54,73,20,77,22,78,57,59,60,108,84,88,112,28,116],assort:41,necessarili:[24,92,103,33,72,98,56,41,23],llvm_int_ti:65,circl:102,white:105,cope:[20,16],copi:[],specifi:[],image_scn_mem_execut:109,enclos:[92,5,10,88,112,16,116],grunt:20,releasei:33,serv:[39,103,32,16,1,56,10,88,78,108,66,30],wide:[36,86,23,39,40,8,49,50,11,12,13,16,103,73,56,24,31,84,42,112,66,30,116],image_sym_type_doubl:109,subexpress:[41,42,113,47,2,49,50,76,60,12,13,14,15,18],getoperationnam:65,posix:[111,61,97],balanc:[27,86],posit:[],bahtu:31,xxxgenasmwrit:54,seri:[],pre:[],pro:78,ani:[],subroutin:[73,23],doiniti:[],bitwis:[],techniqu:[0,34,23,42,113,45,47,2,49,50,12,13,14,15,83,17,18,54,73,76,16,26,84],moreov:[32,84,23],datapath:31,codegen_proto:[12,13,14,15,19],ideal:[28,72,92,16,54],sure:[92,0,33,9,36,94,95,4,6,40,41,84,42,43,113,98,47,2,49,50,10,11,51,100,15,16,19,102,20,65,56,76,78,24,61,107,26,62,86,63,64,27,114,66],multipli:[32,65,60,23,84,16,59],"__asan_memcpi":26,clearer:92,fca:60,npro
c:24,llvm_build_llvm_dylib:24,gunzip:[24,37],icon:107,bb0_30:8,adopt:[4,27,92,84],quantiti:23,mybison:35,cortex:[9,36,57],readjust:84,"0x90":72,xxxasmprint:54,cs2:42,cmakelist:[24,61,55],apple_namespac:56,build_cal:[12,13,14,15,19],uncondit:[32,54,72,84,49,95,13,14,15,23],painlessli:20,permiss:[75,24,27,97,114],culinkst:8,tend:[91,24,92,103,33,46,56,27,28,16],explicitli:[32,92,0,72,35,5,75,40,42,43,23,98,48,11,51,16,19,103,73,20,24,61,107,31,84,87,116],lua:73,derivedtyp:[65,41,43,47,2,49,50,16],state:[],sk_circl:102,analyz:[],abs_fp32:6,analys:[24,65,84,42,39,31,74,56,76,23,32,16,59],llvm_scalar_opt:[12,13,14,15],mcsectionmacho:84,motohiro:84,ssp:[23,56,112],allocat:[84,23,54],ssl:26,dyn:58,tailor:36,image_comdat_select_largest:23,operand_type_list_end:54,sse:[84,23,54,57],regtyp:54,dw_tag_packed_typ:56,reveal:103,"0x00002023":56,dramat:[24,92,20,50,77,12,23],intrins:[],irrespect:61,fastcc:[84,23,98,112],bison:35,scott:92,backedg:[32,72,2,49,13,14,59],drawback:[20,27,16],n16:8,rmw:8
6,lnt:[10,33,31,9,35],maximum:[61,42,34,20,84,59,23,38,16,26],labori:16,atomic_:86,detect:[],mov32ri:84,review:[],get_register_match:21,image_scn_cnt_uninitialized_data:109,abs_f:6,cycl:[90,23],isatleastacquir:86,collect2:64,come:[92,67,34,95,69,23,40,97,8,43,44,45,47,48,49,50,10,11,12,13,15,16,17,52,19,103,73,65,56,76,24,61,26,84,27,112,116],latch:23,at_apple_runtime_class:56,region:[],quiet:[66,20,1,23,99],nocaptur:[32,23,112],mapopt:67,image_scn_mem_purg:109,imgrel:22,image_file_machine_powerpcfp:109,nnn:97,color:[95,84,16],rescan:34,inspir:[32,31,23],period:[73,83,26,10,27,23,31],pop:[41,73,23,84,47,49,112,13,15,16],hblcnsviw:20,image_file_machine_sh4:109,image_file_machine_sh5:109,colon:[61,67,10,28,5,116],image_file_machine_sh3:109,pod:92,poll:[73,72],spcc:54,coupl:[40,41,23,2,49,86,76,27,11,13,14,16,90,116],pend:[24,41,99,43,113,47,2,49,50,12,13,14,15,18,19],test_source_root:1,sectionnumb:109,debug_str:56,hexinteg:30,savesomewher:92,variableexprast:[41,43,113,47,2,49,50],myty
pe1:67,andrew:73,mytype2:67,mrmdestmem:54,compactli:116,intertwin:60,"case":[],addimm:84,push_back:[41,54,43,113,67,47,2,49,50,92,16],mount:24,registerwithsubreg:54,dw_apple_property_weak:56,cast:[],tblgen:[],anytim:98,emittrailingf:86,isextern:56,clutter:27,image_file_up_system_onli:109,rangepiec:30,loophead:[23,2,49],d15:54,addedcomplex:6,value_desc:20,d10:54,d11:54,d12:[104,54],author:[],alphabet:66,ubsan:[26,31],check:[],html:[24,65,41,61,33,44,26,9,87,94,21,92,35],intreg:[69,54],eventu:[32,102,23,35,48,49,72,13,5],hasadsizeprefix:6,week:27,image_sym_class_label:109,nest:[],confidenti:27,driver:[],devoid:84,viewgraph:16,moder:[92,16,107],justifi:[90,97],iterat:16,without:[],model:[],unimpl:76,tip:[],"0x000003f3":56,redwin:84,kill:[76,44,84,83],xxxbranchselector:54,dynamic_cast:[47,92,41,16,102],blow:26,miscellan:[],widest:27,hint:[],except:[],cxx:[24,33,98,9,87,64,66],blob:[33,112],notori:4,disrupt:[115,23],processrelocationref:75,predrel:69,subtargetfeatur:[6,54],createbr:[41,4
7,2,49],predreg:69,"0x000003ff":84,earlycs:51,whitespac:[24,41,43,30,45,47,2,49,50,27,92,113,12,13,14,15,5,17,18,19],image_scn_align_256byt:109,evergreen:105,at_apple_property_attribut:56,libsfgcc1:9,slice:[30,16,116],easili:[76,24,62,32,73,34,20,55,9,56,67,10,92,88,51,72,28,4,84,16,31],benefici:0,legal:[],gridsizex:8,encodecompactunwindregisterswithoutfram:84,gridsizez:8,derferenc:16,freea:48,complic:[24,65,92,102,54,0,73,26,48,86,10,37],freed:[85,16,42],llvm_doxygen_svg:61,garbag:[],inspect:[],boolordefault:20,bpf_mul:84,debug_with_typ:16,immut:[76,23,16,57],execv:4,mergabl:32,cmptmp:[41,43,47,2,49,50,12,13,14,15,19],stanc:92,stand:[76,92,16,84,10,27,113,23,18],image_scn_align_16byt:109,onon:23,routin:[],llvmsetdisasmopt:29,dw_at_nam:56,tbcc:54,lastli:[10,76,41,57],overrod:116,idx2:103,cpu_powerpc:67,myregalloc:76,unconvent:[40,11],idx0:23,classess:54,"0xk":23,fcc_g:54,getbuff:67,strict:[43,34,56,5,51,78,100,28,16,6,19],again:[34,35,94,23,40,43,5,47,49,50,11,12,13,15,16,20,76,78,1
08,26,62,85,115],v_mul_i32_i24:25,mm4:[6,116],strictli:[24,8,72,5,66,56,49,23,13,4,16],blocklen_32:112,machin:[],arg_end:16,setfoo:23,mm6:[6,116],tupl:23,regard:[39,92,98,48,94,21,23],ocaml_lib:[12,13,14,15,19],ffi_include_dir:61,setjmp_buf:108,type_info:108,getdata:92,longer:[32,92,97,73,31,84,47,115,76,27,57,15,16,98,52],notat:[],nmake:61,parsetoplevelexpr:[41,43,113,47,2,49,50],handletoplevelexpress:[41,43,113,47,2,49,50],make_uniqu:[41,47,2,49],compute_factori:99,x86_stdcall:84,clrq:84,clrw:84,cbe:62,frighten:26,strongli:[40,60,73,9,47,49,92,11,13,15,116],clrb:84,intro:[39,15,47,105],enginebuild:[75,41,47,2,49,50],umax:23,encompass:[36,57],rearrang:60,intra:42,tok_eof:[41,43,113,45,47,2,49,50],clrl:84,call2:5,idiom:[43,20,16,19],"0xabcdef00":72,symbol:[],briefli:[71,34,76],mrmsrcreg:54,lexicalblock:41,llvmcreatedisasm:29,serious:37,buildmi:84,llvm_include_exampl:61,unbalanc:31,callq:[72,85,88],directori:[],invest:65,calle:[],defaultlib:37,degrad:73,rabfik:97,"0xl":23,metatada:3,
all:[],replacealluseswith:[34,60,16],dist:[],fp_to_sint:54,lack:[103,73,30,84,63,100,12,23,6,116],ala:31,scalar:[],basicblockutil:16,abil:[65,84,99,45,73,23,20,74,47,2,49,67,29,13,14,15,16,17,52,56],ptx:[],follow:[],disk:[92,90,26,1,56,28,4,23],ptr:[],uint8_t:[26,67],doe:[],getaddressingmod:54,init:[],program:[],neglig:[91,26],liter:[91,92,23,41,97,43,113,45,47,2,49,50,12,13,14,15,16,17,18,19,20,67,112,29,30,116],lsbit:16,far:[40,42,43,23,20,47,2,56,76,11,113,65,28,14,15,16,18,19],urem:[],getbasicblock:84,worst:[16,40,11,85,72],toolbuildpath:66,failur:[76,24,62,67,33,5,35,1,36,87,83,10,37,27,23,44,94,16,17,18,56],unoffici:103,experimental_dir:66,induct:[],basicaliasanalysi:[76,32,42],lisp:[73,40,11],sectionnam:112,list:[],lli:[],snapshot:42,ten:103,use_llvm_analysi:[12,13,14,15,19],tee:83,hashdata:56,rate:[27,97,112,38],pressur:[84,92,0],design:[],storageclass:109,hasard:73,attrdump:21,what:[],namedindex:54,sub:[],sun:[10,76],sum:[0,16,95,112,23,59],brief:[24,92,61,42,73,34,20,62],o
verload:[65,102,54,8,16,2,76,72,66,14,23],asmprint:[73,84,21,54],version:[],intersect:92,row:69,themselv:[84,112,34,20,1,56,27,23,113,28,66,16,6,18],memorybuff:92,xmm3:[6,116],xmm0:[10,88,5,6,116],xmm1:[6,116],themself:27,committ:27,solari:24,xmm5:[6,116],build_config:37,goodby:115,xmm9:6,asmpars:[24,65,21],misinterpret:[92,83],instrsdrm:116,observ:[40,92,72,84,86,11,23],xmm2:[6,116],magnitud:23,"0x0000006e":56,pr22262:31,deprec:[61,54,31,10,112,16,35],heurist:[32,15,23,84,47],sparcasmprint:[84,54],dump_modul:[12,13,14,15,19],hexadecim:[],proceed:[73,24,84],normalizedpolar:67,coverag:[],imath:31,qch:61,forcefulli:103,llvmtargetmachin:54,at_apple_property_sett:56,cxa_demangl:56,isload:84,"80x86":114,flag:[],stick:[92,16,36],"0x00000067":56,known:[],ensu:54,valuabl:[35,27],"_e64":25,outlin:[76,84,27,108,67],outliv:[32,26,23],faultingpcoffset:91,relocationtyp:54,dmpqrtx:97,debug_abbrev:89,image_scn_align_8192byt:109,ppc64:84,reevalu:30,pong:34,bjarn:16,invokeinst:16,dinstinguish:23,new
lin:[92,97,1,2,112,14,5],divid:[32,65,23,35,84,10,38,4,5,59],rather:[32,92,33,1,36,37,23,41,42,113,98,51,16,18,54,103,73,56,76,59,24,84,27,112,30],anxiou:61,hash_map:16,divis:[14,84,23,2],targetasminfo:[73,54],goat:92,resourc:[],algebra:[32,23],ranlib:[24,66,64],reflect:[],okai:[41,103,43,113,47,2,49,50,60,92,13,12,4,14,15,23,18,19],ptxstring:8,"short":[92,67,72,1,37,23,71,41,8,98,47,2,49,13,14,15,54,78,79,24,84,42,27,88,106],postfix:92,unhid:20,stash:102,ambigu:[102,113,20,2,10,14,30,18],caus:[32,62,0,84,1,5,95,92,38,4,23,75,65,41,97,8,44,46,47,2,49,10,15,16,98,18,73,20,74,104,76,78,80,24,83,42,86,67,64,27,52,113,66],callback:[54,42,73,84,88,16],prepass:84,classllvm_1_1dibuild:41,fslp:0,gprof:[66,87],reachabl:[73,61,60,23,72],s_load_dwordx2:25,geomean:0,next_var:[13,14,15],dso_path:77,typedef:[67,31,92,16,50],lai:[41,103,23,84,47,2,49,50,92,60,104,12,13,14,15,16],d31:23,harmless:32,anachronist:112,retti:112,scop:31,might:[92,67,34,94,37,3,4,23,40,97,42,102,5,98,9,49,11,72,13,14,15,
16,52,54,73,20,100,56,21,24,60,61,107,83,26,84,86,27,28,66,29,115],alter:[16,20,98,76,66,23],wouldn:[92,15,47,41],"return":[],no_instal:66,setgraphattr:16,var_nam:[13,14,15],framework:[32,65,47,84,35,39,43,23,31,42,45,2,56,76,73,14,15,16,17,19],preheaderbb:[2,49],somebodi:27,bigger:[92,67],strr:54,complexpattern:[84,54],sourcebas:39,blockdim:8,"__dwarf":56,refresh:90,const_float:[12,13,14,15,19],hasjit:54,truncat:[23,54,116],compriz:38,dcmake_cxx_compil:26,"2x3x4":23,colder:59,compute_20:8,linkag:[],regmapping_f:84,asmparsernum:106,expect:[],atom_count:56,constindex:88,resulttyp:23,foolproof:76,ccifinreg:54,lineno:41,image_file_line_nums_strip:109,benjamin:73,isempti:16,uncommit:24,advanc:[],"0xxxxxxxxx":56,teach:[43,45,65,17,19],pre_stor:84,flagflat:67,thrown:[91,108,23],targetinfo:[27,54],putchar:[41,43,47,2,49,50,12,13,14,15],thread:[],vararg:[43,16,84,112,23,19],toolnam:[66,52],perhap:[92,42,73,34,23,16],machineframeinfo:84,ccifnotvararg:54,circuit:[14,2],precal:73,libclc:27,fee
d:[13,56,49,42],notifi:[27,94,42,0],ystep:[14,2],feel:[40,92,42,43,83,31,45,27,11,51,23,17,19],cuda_success:8,add16mi8:6,summaris:78,cond_val:[13,14,15],construct:[],stdlib:24,blank:[40,92,97,107,113,45,27,11,115,17,18],slower:[92,73,34,84,108,16,98],fanci:35,gpl:[27,98],superpos:16,script:[],interact:[],gpg:24,stori:[71,24,37],gpu:[39,105,25,54,8,21,23],store:[],luckili:73,option:[],syncthread:8,wswitch:92,st_gid:97,cmake_c_flag:61,inc4:5,secondcondit:16,albeit:[15,47],kind:[32,92,34,3,38,23,6,71,65,41,97,98,47,2,14,15,16,102,73,20,56,21,57,77,60,108,31,84,86,27,88,28,66,115,90,26],assert_valid_funct:[12,13,14,15,19],doubli:[85,16],whenev:[92,42,5,20,99,10,69,88,23,44,28,66,16,45],remot:[75,24],remov:[],pictur:[43,34,103,19],get_subtarget_feature_nam:21,empty_subregsset:54,dinkumwar:16,cleaner:[20,92,16],body_v:15,nnan:23,peculiar:30,ysvn:94,astwrit:21,aspir:[14,2],dedic:[84,54],"0b000100":54,violat:[92,103,73,49,27,13,23],arm_aapcscc:112,supercomput:31,paramidx1:112,paramidx0:112,
exec:[44,26,31],unsur:30,getrawpoint:57,reach:[91,32,92,54,73,34,88,108,28,23],flagsround:67,assignvirt2phi:84,shouldexpandatomicloadinir:86,image_rel_amd64_addr32nb:22,cmakefil:24,amaz:[14,2],dw_tag_enumeration_typ:[23,56],xmm7:[6,116],blockid:112,destruct:[88,40,11,48],libopag:63,sandybridg:0,arg_empti:16,rtl:84,getcol:41,area:[60,33,108,31,84,47,10,73,27,78,4,92,15,23,98],intti:23,optimizationlevel:20,inapplic:36,brtarget:54,penalti:[23,16],dw_apple_property_retain:56,bfd:64,create_add:19,image_file_large_address_awar:109,hash_funct:56,stackoffset:73,shlibext:[10,66],address_s:8,blockscalartrait:67,pushfq:84,"0x0001023":56,hit:[92,59],aliasopt:20,spurious:10,aliasanalysiscount:42,mydoclisttyp:67,fastest:114,sizabl:16,stdcall:[84,23],pushfl:84,him:34,exactmatch:23,llvmdummi:54,sk_otherspecialsquar:102,armhf:9,ssl_set_accept_st:26,"0x1234":56,wrote:[65,41,23,103],arr:[23,16,103],art:73,dump:[41,112,67,43,83,26,84,47,2,49,50,76,56,21,89,38,12,13,16,19],cleverli:78,shared_librari:[66
,52],proactiv:[27,83],mutabl:[],arc:[95,107],bare:[23,101,16,54,88],arg:[92,34,1,95,99,23,41,43,44,45,47,2,49,50,72,12,13,14,15,17,18,19,20,80,62,110,113,30],disadvantag:[90,20,16,57],icc_:54,unqualifi:84,arm:[],property_valu:28,setupmachinefunct:54,inconveni:[15,47,98],inst_end:16,old_valu:15,maprequir:67,pubtyp:56,condv:[41,47,2,49],extensioan:33,syntact:[12,23,5,50],unabbrev:112,sole:[27,16],gcfunctioninfo:73,setbid:112,succeed:[76,1,23,59],outfil:70,solv:[40,103,42,56,84,47,2,94,27,11,14,15],classnam:106,v128:[23,8],isdopcod:[65,84],interprocedur:[],fragement:72,blissfulli:20,isomorph:98,available_extern:[23,112],context:[],cvf:94,subclassref:30,internallinkag:16,tgt:106,getsrc:24,libxxx:9,sweep:73,zchf:9,arbitrarili:[13,23,102,49,56],mistak:92,java:[91,32,40,73,23,86,11,16],due:[24,60,84,42,33,30,31,62,92,36,99,73,3,90,51,23,34,108,72,5],whom:34,brick:34,whoa:[12,50],strategi:[],thunk:[32,84,23,34],dw_tag_imported_modul:23,flight:23,append_block:[12,13,14,15,19],llvm_map_compon
ents_to_librari:61,demand:[24,15,47,84,112],instructor:54,asmmatcheremitt:21,echocmd:66,eatomtypedietag:56,frozen:99,batch:37,dagtodagisel:65,abov:[91,32,92,78,67,33,34,35,69,5,6,75,40,41,84,42,43,44,45,98,9,2,49,50,10,11,51,47,12,13,14,15,16,17,18,19,54,103,73,102,20,65,56,76,23,79,59,97,24,61,72,108,31,62,85,88,52,112,113,29,115,90,26,116],cmp32ri:84,getlinenumb:56,int32:88,runonfunct:[],image_file_machine_am33:109,rip:[10,23,6],floattyp:16,rid:34,illinoi:[],mioperandinfo:54,dw_lang_c:41,minim:[],getnumel:16,dominatortreebas:16,higher:[],x83:109,x87:23,x86:[],mytyp:23,robust:[10,29],wherev:[92,41,16],obit:23,lower:[],n2429:92,machineri:[35,102],discourag:[4,20,16,66],find_packag:61,emitjumptableaddress:54,searchabl:66,openmodul:50,chees:92,propos:[],stripwarnmsg:66,targets_to_build:[9,54],succ_end:16,bpf_call:84,theoret:[4,16],xxxisellow:54,circumv:20,exposit:[45,17,50],getbinarycodeforinstr:54,lmalloc:20,filename1:71,finder:39,view_function_cfg_onli:13,complaint:[40,11],erasefrom
par:[41,54,43,47,2,49,50,16],int32x4_t:78,v64:[23,8],ispoint:34,mypassnam:16,preexist:32,awaken:108,image_sym_class_bit_field:109,fbb:54,confront:[51,103],llvm_yaml_is_flow_sequence_vector:67,short_wchar:23,xmm10:6,collect:[],xmm12:6,xmm13:6,xmm14:6,xmm15:6,cst_code_wide_integ:112,autoinsert:16,understood:[84,92,11],litter:27,unspecifi:[25,8,72,35,84,23],consciou:24,llvmgettypekind:65,surpris:[16,40,11,23,34],condition_vari:24,multmp:[41,43,47,2,49,50,12,13,14,15,19],henderson2002:73,prof:[3,59],patchset:24,proc:[24,36,54],studi:52,kernel_code_version_major:25,n3206:92,emitinstruct:[84,54],assignvirt2stackslot:84,runtimedyld:75,lose:[76,40,11,56],mustquot:67,jumpi:31,ispointertyp:92,"_unwind_resum":108,testfunc:[12,50],arg_begin:[41,43,47,2,49,50,16],image_file_machine_wcemipsv2:109,"0x000034f0":56,getdatalayout:[41,54,73,31,47,2,49,50],threadid:8,tok_then:[41,47,2,49],plethora:[24,98,16],branchfold:54,prec:[41,14,15,47,2],operandmap:54,question:[],fast:[],adjac:[30,16,23],"__cxa_ca
ll_unexpect":108,files:70,lto_codegen_set_pic_model:90,repeatedli:[91,23],gcca:96,"0x7fffe3e864f0":26,yrc1:94,delta:62,libclang:31,consist:[],caller:[32,98,54,43,34,84,85,2,49,83,76,73,78,13,14,23,19],cmpnumber:34,expandatomicrmwinir:86,mflop:0,msa:[31,23],tdrr:80,highlight:[71,24,41,84,21,115,16],worklist:[32,16,34],tooldir:66,src_reg:84,icc_val:54,cleargraphattr:16,phieliminationid:84,cover:[],delinear:31,o32:31,composit:[23,16],numconst:88,simm13:54,cciftyp:54,bpf_neg:84,mytargetmachin:31,pat:[84,6,54],sdvalu:[84,54],remove_if:16,registerdescriptor:54,nice:[32,92,5,40,43,113,45,47,2,49,50,11,12,13,14,15,16,17,18,19,20,76,24,116],ecosystem:[28,16],at_decl_fil:56,storeregtostackslot:[84,54],parseprimari:[41,43,113,47,2,49,50,14],add64ri32:6,ccpromotetotyp:54,breviti:[78,8],meaning:[103,73,16,74,21,72,80,115,23],makelight:92,ccifcc:54,dllvm_default_target_tripl:9,ternari:[31,84],gr1:23,elementtyp:23,gr8:[84,54],spillsiz:54,scroll:107,cmpq:85,pervert:[6,100],edg:[],edi:[84,5,6],numfi
lenam:71,block_begin:[12,13,14,15,19],gmake:[76,35,98,87],dispel:103,dereferenceable_or_nul:23,edx:[84,23,6,116],"2darrai":31,uphold:23,xxxiseldagtodag:54,else_bb:[13,14,15],vptr:[23,16],needstub:54,outgo:[23,59],attributerefer:21,formbit:6,fpformbit:6,templateparam:23,whichev:56,vadv:35,emitconstantpool:54,relev:[],sk_buff:84,mandelhelp:[14,2],sk_specialsquar:102,"0x0002023":56,maxsiz:92,loop_end_bb:[13,14,15],h_inlined_into_g:79,pleas:[92,33,72,36,86,37,69,23,40,8,43,9,10,11,51,84,16,19,53,54,73,114,94,24,81,106,107,31,62,42,87,27,28,115,30,116],smaller:[32,92,107,73,23,31,84,27,51,16,35],dsym:79,cfi:60,lcuda:8,cfe:[24,27,107,94],hardcod:[69,54],dllvm_binutils_incdir:64,fold:[],numstr:[41,43,113,45,47,2,49,50],folk:[26,107],compat:[],pointer_offset:72,undetect:26,compar:[],mainlin:[27,94],smallconst:88,err_load_bio_str:26,dllvm_enable_doxygen_qt_help:61,proj_obj_root:[66,52],finishassembl:73,dllvm_targets_to_build:[61,9],chose:[12,33,50],sexi:[45,17],ocamlbuild_plugin:[12,13,14,15
,19],destbitcodelib:66,libltdl:66,sse41:5,llvmbuilderref:31,larger:[7,92,54,23,31,84,65,56,27,22,112,38,16],shader:[84,92,105],n2927:92,nsstring:56,unattend:83,typic:[91,32,92,94,95,38,23,75,40,97,42,102,5,10,11,16,52,54,103,73,56,76,111,24,60,61,82,108,26,84,87,88,28,66,29,90],n2928:92,apr:4,appli:[32,92,67,33,94,95,4,23,75,40,97,42,47,2,50,11,51,12,14,15,16,54,103,90,20,74,56,76,22,78,24,25,83,31,84,86,87,27,114,30,26,116],app:[63,92,16],inequ:84,loopcond:[41,47,2,49,13,14,15],api:[],duck:16,opcod:[41,102,54,43,34,84,47,2,86,92,23,113,69,14,116,16,6,18,19],transformutil:28,gnuwin32:[37,61],sourcefil:95,emitconstpooladdress:54,fed:84,from:[],usb:36,ineg:84,few:[32,92,0,72,94,4,23,40,41,97,8,43,113,2,50,10,11,12,14,16,52,19,54,73,74,56,76,24,83,84,86,27,18,112,28,66],usr:[24,61,8,20,9,87,64,66],movsx16rr8w:84,my_addit:56,sort:[],clever:[40,11,102],ap2:23,cimag:[14,2],adc64mi8:6,llvmtooldir:66,tok_identifi:[41,43,113,45,47,2,49,50],is_zero_undef:23,localdynam:[23,112],dllc:10,augment
:[14,16,2],lbb0_2:85,corpus_dir:26,annot:[],annoi:92,no_dead_strip:23,getregclass:84,proof:3,modulevector:50,expr1lh:71,tar:[24,33,26,9,94,37,66],isindirectbranch:6,movapd:5,tag:[],proprietari:27,mips32:31,tag_apple_properti:56,serial:[65,34,67,21,66,52],featurefparmv8:6,six:[84,1,86],linaro:36,sig:24,subdirectori:[],instead:[],constantfp:[41,43,47,2,49,50,16,19],sin:[],chri:[40,92,84,94,76,27,11],sil:6,tension:[15,47],msdn:[108,92],vehicletyp:92,hazard:60,singlethread:23,printdens:[14,2],attent:[10,27,23,54],hasiniti:16,xarch:24,mynewpass:44,light:[92,23],llvm_build_exampl:61,freebsd:[24,31,84,94],elid:[73,48,116],deoptim:72,elig:32,ouput:23,desrib:71,elim:[77,56],dw_tag_memb:[23,56],attrparsedattrlist:21,build_fsub:19,projlibsopt:66,reilli:16,"80x87":84,in32bitmod:84,attrpchread:21,nonneg:23,guess:61,devel:33,successor:[],nfc:60,trac:114,dbuilder:41,edit:[24,16,61,97],trap:[],instsp:54,forcibl:23,image_scn_align_8byt:109,mylistel:67,virtregmap:84,"__chkstk":22,our:[92,0,34,40,41,8
4,8,43,113,45,47,2,49,50,11,72,12,13,14,15,16,17,18,19,73,20,56,76,24,61,31,62,63,27,90],out:[],const_use_iter:16,llvm_compiler_job:61,m_func:16,distnam:66,categori:[],sectalign:20,stroustrup:16,llvmbb:39,llvmconfig:61,dive:[45,17,102],proviso:27,powerpc:[],bitset1:104,dictionari:[1,23],anyhow:23,promptli:27,my86_64flag:67,image_sym_class_undefined_label:109,tailcalle:84,lto:[],libcxxabi:31,isdef:84,mrm1r:54,echo:[24,115,66],isfoo:92,ptrtoreplacedint:16,prioriti:[23,56,103],"0x580be3":26,unknown:[],ntohl:84,"__nv_isnanf":8,printoperand:54,boil:[102,2,49,27,78,13,14],misunderstood:[],tidbit:[],shell:[24,41,61,20,1,10,115,83,98],unabridg:[15,47],juli:73,mantain:94,protocol:[72,92,23],lea:[84,6],svnup:24,probe:[],utf:[24,21],ssl_new:26,bitcodewrit:[65,16],clip:99,favorit:[13,60,49],cohen:4,linker:[],appel89:73,peform:78,coher:[28,23],lowerfp_to_sint:54,disjoint:[42,23,0],inform:[],diverg:[14,23,2,103],rout:42,"__unwind_info":84,anyregcc:[88,23,112],which:[],newabbrevlen:112,ncsa:27,syn
c_timeout:26,llvmtarget:52,clash:[92,23],machine_version_major:25,safepointaddress:73,compiler_rt:27,sunwspro:24,image_file_machine_ia64:109,codegen_expr:[12,13,14,15,19],why:[],"_build":87,attributelist:[21,57],dens:[23,16,112],addregfrm:54,pipe:[4,1,5],osuosl:114,determin:[],targetgroup:28,const_arg_iter:16,mips64el:87,"30pm":67,mainloop:[41,43,113,47,2,49,50],filetyp:[37,77],arm_neon:[21,78],liveinterv:[80,84],eas:36,strtol:20,locat:[],strtod:[41,43,113,20,47,2,49,50,45],much:[32,62,67,33,47,92,38,102,4,23,6,40,84,8,43,113,98,9,48,50,10,11,72,12,15,16,18,19,54,90,20,65,56,76,97,24,107,83,26,42,86,63,64,27,88,52,114,115,30],mymaptyp:67,eatomtypetypeflag:56,multmp4:[12,50],local:[],multmp1:[43,19],multmp2:[43,19],multmp3:[43,19],contribut:[32,53,23,84,76,27,39,16],pypi:98,succe:[93,7,41,96,97,102,108,44,74,47,101,106,10,77,113,38,114,15,5,82,18],buildtool:28,blarg:16,operating_system:23,localtarget:66,v1i128:31,regalloclinearscan:84,image_rel_i386_sect:22,partit:[],view:[],modulo:[
31,84,23,56,25],knowledg:[71,32,40,92,73,84,10,27,11,112,66,29,115,23],maketir:92,objectcach:75,dw_form_xxx:56,ebp:[84,6],p20:8,image_sym_class_enum_tag:109,ebx:[84,22,6],gmail:[24,107],closer:[60,103],asynchron:[23,86],entranc:23,framemap:73,mainli:[34,21,23,52],below:[32,92,0,33,34,35,36,48,37,3,5,71,7,84,8,102,23,47,2,10,72,12,14,15,16,18,54,20,56,76,21,94,97,24,61,25,108,77,42,85,87,67,27,88,52,112,113,28,66],dll:[],favor:[35,27],structtyp:16,beginassembl:73,"__apple_nam":56,rppassmanag:76,image_sym_dtype_funct:109,ptrreg:84,amen:84,cudamodul:8,sprinkl:16,job:[61,102,26,87,76,4],entir:[32,62,0,35,1,95,92,38,23,40,97,8,43,98,50,10,11,12,84,16,19,54,103,73,20,56,76,78,24,42,67,27,112,28,66],noalia:[],targetdescript:54,exclam:23,addit:[],"0x00000120":56,thenbb:[13,41,47,2,49],constantint:[92,16],tgtm:24,subregclasslist:54,mlimit:44,progbit:22,"__nv_truncf":8,committe:16,libtinfo:9,uint16_t:[69,67,56,54],unclear:[15,47,42],galina:114,wonder:[92,102,103,98,50,27,12],arriv:103,chmod:2
4,walk:[32,60,34,67,76,16],respect:[92,72,94,23,6,54,42,44,98,47,10,15,83,52,102,103,73,79,24,16,84,27,108,29],externallinkag:[41,43,47,2,49,50,19],decent:[65,41,45,36,94,76,16],xxxcallingconv:54,compos:[71,66,37,23,97],compon:[],besid:[92,54,113,20,2,10,14,23,18],safepoint_token1:72,unregist:76,inbound:[71,23,51,103],presenc:[102,54,5,31,84,86,23,108,16,35],gtx:8,llparser:65,present:[],xorrr:54,align:[],dfpregsclass:54,create_entry_block_alloca:15,wili:103,wild:[14,20,2],xorri:54,bb3:23,bb2:[23,112],bb1:[23,112],d_ctor_bas:5,layer:[],avx:[10,23,0],new_str:50,instrinfo:[],cctype:[41,43,113,47,2,49,50],eptr:23,avl:16,dual:27,add64mi32:6,foreign:[98,61],incq:5,getattributespellinglistindex:21,uint16x4_t:78,headlight:92,xxxschedul:54,member:[],binary_preced:[14,15],largest:[23,84,22,51],f64:[84,23,54,8],expcnt:25,"0x1b":112,difficult:[41,42,23,20,92,2,86,27,90,14,115,16],slave:114,ssecal:54,hardcodedsmalls:16,bcpl:30,decoupl:116,iftru:23,extra_dist:66,mcasmpars:84,minsizerel:[24,61],fi
rstli:23,"0x10":[88,56],faultingload:91,linkagetyp:16,english:[24,92],my_function_fast:8,getoffset:54,camel:92,obtain:[],corei7:[10,0],heavili:[39,40,73,31,98,11],simultan:[0,26,87,10,78,16],tcb:85,expr1rh:71,rapid:27,methodproto:54,amd64:24,eatomtypenul:56,smith:92,waypoint:83,emitobject:75,llvm_on_win32:4,agnost:[4,84,23,56,78],strconcat:[30,54,116],intregsregisterclass:54,lightweight:[92,1,16],destreg:84,denser:[14,2],librarynam:[73,66,76,54,52],"7e15":20,hostc:8,hostb:8,hosta:8,incred:[27,92],bpf_class:84,repurpos:56,"0xff":[23,116],createphi:[41,47,2,49],growth:[23,84,16],"export":[24,61,42,90,31,84,2,94,64,66,23,20],superclass:[54,42,76,16,6,116],xxxsubtarget:54,containsfoo:92,not_found:[12,13,14,15,18,19],leaf:[108,56],image_sym_class_struct_tag:109,lead:[32,41,103,67,23,20,84,86,64,92,113,66,16,26,18,116],leak:[73,45,1,85,48,10,17],boolean_property_nam:28,leaq:85,leav:[32,62,107,54,24,73,34,20,1,56,64,27,8,23,98],prehead:[13,49,32],leader:92,getnam:[41,43,98,47,2,49,50,76,16
],investig:[35,11,40],acronym:39,dosometh:92,tdfile:66,xxxgencallingconv:54,obei:23,eatomtypenameflag:56,toolchain:[],add64mi8:6,column:[71,24,41,0,23,35,67,56,92,69,5],vset_lan:78,constructor:[],spiller:[80,77,84],disabl:[],stackentri:73,isnul:92,own:[],automat:[],warranti:[76,27],automak:[24,66],build_mod:37,val:[41,108,54,8,43,23,20,47,2,49,50,92,88,113,112,57,16,116],transfer:[85,23,48,78,108],threadsanit:23,intention:[76,113,92,23,18],appl:[39,23,84,56,99,27,5],arg1:[45,23,17],incorr:3,varexpr:[15,47,41],mailer:27,"0x7fffffff":23,callgraphscc:76,lazyresolverfn:54,"__cxa_throw":108,made:[91,32,92,67,34,94,23,6,39,40,41,42,43,98,47,2,49,50,11,72,13,15,16,52,102,103,100,56,76,21,78,108,31,84,85,27,112,66,115],temp:62,whether:[],distract:27,divisionbyzero:23,libsystem:92,disttargzip:66,lvm:41,fldcw:84,llvmasmpars:52,numberexpr:[41,43,113,47,2,49,50,12,13,14,15,18,19],significantli:[91,92,16,49,76,90,113,112,38,13,23,18],entiteti:72,link_libs_in_shar:66,meaningless:16,rl5:8,constpro
p:[],"8bit":26,rl7:8,mutual:[43,72,20,17,45,19],targetfunc:16,immateri:34,the_modul:[12,13,14,15,19],percent:42,constantfold:65,book:[76,39,92,60,16],bool:[92,67,34,23,65,41,102,42,43,47,2,49,50,12,13,14,15,16,19,54,20,76,61,84],llvmdisassembler_option_usemarkup:29,gline:0,neelakantam:32,inst_iter:16,auxiliari:54,hacker:[39,27],junk:[12,13,14,15,18,19],package_vers:61,indexedmap:[],add_subdirectori:61,tok_extern:[41,43,113,45,47,2,49,50],debian:[63,24,9],stringmap:[],experienc:83,sass:8,reliabl:[],space:[],pdata:22,emerg:99,keep_symbol:66,invari:[],istermin:[6,116]},objtypes:{"0":"std:option"},objnames:{"0":["std","option","option"]},filenames:["Vectorizers","CommandGuide/lit","tutorial/LangImpl6","BranchWeightMetadata","SystemLibrary","CommandGuide/FileCheck","TableGen/index","CommandGuide/llvm-extract","NVPTXUsage","HowToCrossCompileLLVM","TestingGuide","tutorial/OCamlLangImpl8","tutorial/OCamlLangImpl4","tutorial/OCamlLangImpl5","tutorial/OCamlLangImpl6","tutorial/OCamlLangImpl7"
,"ProgrammersManual","tutorial/OCamlLangImpl1","tutorial/OCamlLangImpl2","tutorial/OCamlLangImpl3","CommandLine","TableGen/BackEnds","Extensions","LangRef","GettingStarted","AMDGPUUsage","LibFuzzer","DeveloperPolicy","LLVMBuild","MarkedUpDisassembly","TableGen/LangRef","ReleaseNotes","Passes","ReleaseProcess","MergeFunctions","TestSuiteMakefileGuide","HowToBuildOnARM","GettingStartedVS","CommandGuide/llvm-bcanalyzer","index","tutorial/LangImpl9","tutorial/LangImpl8","AliasAnalysis","tutorial/LangImpl3","CommandGuide/bugpoint","tutorial/LangImpl1","CommandGuide/llvm-diff","tutorial/LangImpl7","InAlloca","tutorial/LangImpl5","tutorial/LangImpl4","Frontend/PerformanceTips","Projects","tutorial/index","WritingAnLLVMBackend","CommandGuide/llvm-build","SourceLevelDebugging","HowToUseAttributes","CommandGuide/llvm-readobj","BlockFrequencyTerminology","Lexicon","CMake","HowToSubmitABug","Packaging","GoldPlugin","ExtendingLLVM","MakefileGuide","YamlIO","CommandGuide/index","HowToUseInstrMapp
ings","CommandGuide/llvm-stress","CoverageMappingFormat","Statepoints","GarbageCollection","CommandGuide/opt","MCJITDesignAndImplementation","WritingAnLLVMPass","CommandGuide/llc","BigEndianNEON","CommandGuide/llvm-symbolizer","CommandGuide/lli","TableGenFundamentals","CommandGuide/llvm-link","Bugpoint","CodeGenerator","SegmentedStacks","Atomics","BuildingLLVMWithAutotools","StackMaps","CommandGuide/llvm-dwarfdump","LinkTimeOptimization","FaultMaps","CodingStandards","CommandGuide/llvm-dis","HowToReleaseLLVM","CommandGuide/llvm-cov","CommandGuide/llvm-as","CommandGuide/llvm-ar","FAQ","DebuggingJITedCode","TableGen/Deficiencies","CommandGuide/llvm-config","HowToSetUpLLVMStyleRTTI","GetElementPtr","BitSets","CompilerWriterInfo","CommandGuide/tblgen","Phabricator","ExceptionHandling","yaml2obj","CommandGuide/llvm-profdata","CommandGuide/llvm-nm","BitCodeFormat","tutorial/LangImpl2","HowToAddABuilder","SphinxQuickstartTemplate","TableGen/LangIntro"],titles:["Auto-Vectorization in LLVM",
"lit - LLVM Integrated Tester","6. Kaleidoscope: Extending the Language: User-defined Operators","LLVM Branch Weight Metadata","System Library","FileCheck - Flexible pattern matching file verifier","TableGen","llvm-extract - extract a function from an LLVM module","User Guide for NVPTX Back-end","How To Cross-Compile Clang/LLVM using Clang/LLVM","LLVM Testing Infrastructure Guide","8. Kaleidoscope: Conclusion and other useful LLVM tidbits","4. Kaleidoscope: Adding JIT and Optimizer Support","5. Kaleidoscope: Extending the Language: Control Flow","6. Kaleidoscope: Extending the Language: User-defined Operators","7. Kaleidoscope: Extending the Language: Mutable Variables","LLVM Programmer’s Manual","1. Kaleidoscope: Tutorial Introduction and the Lexer","2. Kaleidoscope: Implementing a Parser and AST","3. Kaleidoscope: Code generation to LLVM IR","CommandLine 2.0 Library Manual","TableGen BackEnds","LLVM Extensions","LLVM Language Reference Manual","Getting Started with the LLVM
System","User Guide for AMDGPU Back-end","LibFuzzer – a library for coverage-guided fuzz testing.","LLVM Developer Policy","LLVMBuild Guide","LLVM’s Optional Rich Disassembly Output","TableGen Language Reference","LLVM 3.7 Release Notes","LLVM’s Analysis and Transform Passes","How To Validate a New Release","MergeFunctions pass, how it works","LLVM test-suite Makefile Guide","How To Build On ARM","Getting Started with the LLVM System using Microsoft Visual Studio","llvm-bcanalyzer - LLVM bitcode analyzer","Overview","9. Kaleidoscope: Conclusion and other useful LLVM tidbits","8. Kaleidoscope: Adding Debug Information","LLVM Alias Analysis Infrastructure","3. Kaleidoscope: Code generation to LLVM IR","bugpoint - automatic test case reduction tool","1. Kaleidoscope: Tutorial Introduction and the Lexer","llvm-diff - LLVM structural ‘diff’","7. Kaleidoscope: Extending the Language: Mutable Variables","Design and Usage of the InAlloca Attribute","5. Kaleidos
cope: Extending the Language: Control Flow","4. Kaleidoscope: Adding JIT and Optimizer Support","Performance Tips for Frontend Authors","Creating an LLVM Project","LLVM Tutorial: Table of Contents","Writing an LLVM Backend","llvm-build - LLVM Project Build Utility","Source Level Debugging with LLVM","How To Use Attributes","llvm-readobj - LLVM Object Reader","LLVM Block Frequency Terminology","The LLVM Lexicon","Building LLVM with CMake","How to submit an LLVM bug report","Advice on Packaging LLVM","The LLVM gold plugin","Extending LLVM: Adding instructions, intrinsics, types, etc.","LLVM Makefile Guide","YAML I/O","LLVM Command Guide","How To Use Instruction Mappings","llvm-stress - generate random .ll files","LLVM Code Coverage Mapping Format","Garbage Collection Safepoints in LLVM","Garbage Collection with LLVM","opt - LLVM optimizer","MCJIT Design and Implementation","Writing an LLVM Pass","llc - LLVM static compiler","Using ARM NEON instructions in big endian mode","llvm-symbol
izer - convert addresses into source code locations","lli - directly execute programs from LLVM bitcode","TableGen Fundamentals","llvm-link - LLVM bitcode linker","LLVM bugpoint tool: design and usage","The LLVM Target-Independent Code Generator","Segmented Stacks in LLVM","LLVM Atomic Instructions and Concurrency Guide","Building LLVM With Autotools","Stack maps and patch points in LLVM","llvm-dwarfdump - print contents of DWARF sections","LLVM Link Time Optimization: Design and Implementation","FaultMaps and implicit checks","LLVM Coding Standards","llvm-dis - LLVM disassembler","How To Release LLVM To The Public","llvm-cov - emit coverage information","llvm-as - LLVM assembler","llvm-ar - LLVM archiver","Frequently Asked Questions (FAQ)","Debugging JIT-ed Code With GDB","TableGen Deficiencies","llvm-config - Print LLVM compilation options","How to set up LLVM-style RTTI for your class hierarchy","The Often Misunderstood GEP Instruction","Bitsets","Architecture & Platform Info
rmation for Compiler Writers","tblgen - Target Description To C++ Code Generator","Code Reviews with Phabricator","Exception Handling in LLVM","yaml2obj","llvm-profdata - Profile data tool","llvm-nm - list LLVM bitcode and object file’s symbol table","LLVM Bitcode File Format","2. Kaleidoscope: Implementing a Parser and AST","How To Add Your Build Configuration To LLVM Buildbot Infrastructure","Sphinx Quickstart Template","TableGen Language Introduction"],objects:{"":{"--stats":[77,0,1,"cmdoption--stats"],"-D":[111,0,1,"cmdoption-llvm-nm-D"],"-A":[111,0,1,"cmdoption-llvm-nm-A"],"-name-regex":[95,0,1,"cmdoption-llvm-cov-show-name-regex"],"-B":[111,0,1,"cmdoption-llvm-nm-B"],"-":[74,0,1,"cmdoption-"],"-O":[77,0,1,"cmdoption-O"],"-seed":[70,0,1,"cmdoption-seed"],"-I":[106,0,1,"cmdoption-tblgen-I"],"-gen-register-info":[106,0,1,"cmdoption-tblgen-gen-register-info"],"-gen-subtarget":[106,0,1,"cmdoption-tblgen-gen-subtarget"],"-S":[111,0,1,"cmdoption-llvm-nm-S"],"-binary":[110,0,1,"
cmdoption-llvm-profdata-merge-binary"],"-mattr":[77,0,1,"cmdoption-mattr"],"-counts":[110,0,1,"cmdoption-llvm-profdata-show-counts"],"-region-coverage-gt":[95,0,1,"cmdoption-llvm-cov-show-region-coverage-gt"],"-d":[82,0,1,"cmdoption-d"],"-g":[111,0,1,"cmdoption-llvm-nm-g"],"--object-directory":[95,0,1,"cmdoption-llvm-cov-gcov--object-directory"],"-a":[111,0,1,"cmdoption-llvm-nm-a"],"-c":[95,0,1,"cmdoption-llvm-cov-gcov-c"],"-b":[95,0,1,"cmdoption-llvm-cov-gcov-b"],"--no-progress-bar":[1,0,1,"cmdoption--no-progress-bar"],"-l":[95,0,1,"cmdoption-llvm-cov-gcov-l"],"-o":[111,0,1,"cmdoption-llvm-nm-o"],"-n":[111,0,1,"cmdoption-llvm-nm-n"],"--long-file-names":[95,0,1,"cmdoption-llvm-cov-gcov--long-file-names"],"--defined-only":[111,0,1,"cmdoption-llvm-nm--defined-only"],"-j":[1,0,1,"cmdoption-j"],"-u":[111,0,1,"cmdoption-llvm-nm-u"],"-t":[58,0,1,"cmdoption-t"],"-v":[82,0,1,"cmdoption-v"],"-q":[1,0,1,"cmdoption-q"],"-p":[95,0,1,"cmdoption-llvm-cov-gcov-p"],"-s":[58,0,1,"cmdoption-s"],"-r":
[58,0,1,"cmdoption-r"],"-gen-dag-isel":[106,0,1,"cmdoption-tblgen-gen-dag-isel"],"-show-line-counts-or-regions":[95,0,1,"cmdoption-llvm-cov-show-show-line-counts-or-regions"],"-show-instantiations":[95,0,1,"cmdoption-llvm-cov-show-show-instantiations"],"-version":[95,0,1,"cmdoption-llvm-cov-gcov-version"],"-class":[106,0,1,"cmdoption-tblgen-class"],"--max-time":[1,0,1,"cmdoption--max-time"],"-line-coverage-gt":[95,0,1,"cmdoption-llvm-cov-show-line-coverage-gt"],"-instr":[110,0,1,"cmdoption-llvm-profdata-show-instr"],"-all-functions":[110,0,1,"cmdoption-llvm-profdata-show-all-functions"],"-use-color":[95,0,1,"cmdoption-llvm-cov-report-use-color"],"--vg-leak":[1,0,1,"cmdoption--vg-leak"],"--branch-probabilities":[95,0,1,"cmdoption-llvm-cov-gcov--branch-probabilities"],"--all-blocks":[95,0,1,"cmdoption-llvm-cov-gcov--all-blocks"],"-P":[111,0,1,"cmdoption-llvm-nm-P"],"--print-file-name":[111,0,1,"cmdoption-llvm-nm--print-file-name"],"-stats":[74,0,1,"cmdoption-stats"],"-name":[95,0,1,"c
mdoption-llvm-cov-show-name"],"-gen-asm-writer":[106,0,1,"cmdoption-tblgen-gen-asm-writer"],"-symbols":[58,0,1,"cmdoption-symbols"],"-print-sets":[106,0,1,"cmdoption-tblgen-print-sets"],"-program-headers":[58,0,1,"cmdoption-program-headers"],"-dyn-symbols":[58,0,1,"cmdoption-dyn-symbols"],"--show-xfail":[1,0,1,"cmdoption--show-xfail"],"-obj":[79,0,1,"cmdoption-obj"],"--check-prefix":[5,0,1,"cmdoption--check-prefix"],"--succinct":[1,0,1,"cmdoption--succinct"],"--x86-asm-syntax":[77,0,1,"cmdoption--x86-asm-syntax"],"--show-suites":[1,0,1,"cmdoption--show-suites"],"-relocations":[58,0,1,"cmdoption-relocations"],"-gcc":[110,0,1,"cmdoption-llvm-profdata-merge-gcc"],"-show-line-counts":[95,0,1,"cmdoption-llvm-cov-show-show-line-counts"],"-needed-libs":[58,0,1,"cmdoption-needed-libs"],"-line-coverage-lt":[95,0,1,"cmdoption-llvm-cov-show-line-coverage-lt"],"-nodetails":[38,0,1,"cmdoption-llvm-bcanalyzer-nodetails"],"--enable-no-nans-fp-math":[77,0,1,"cmdoption--enable-no-nans-fp-math"],"-as
mwriternum":[106,0,1,"cmdoption-tblgen-asmwriternum"],"-debug-dump":[89,0,1,"cmdoption-debug-dump"],"--print-machineinstrs":[77,0,1,"cmdoption--print-machineinstrs"],"-asmparsernum":[106,0,1,"cmdoption-tblgen-asmparsernum"],"-section-symbols":[58,0,1,"cmdoption-section-symbols"],"--print-size":[111,0,1,"cmdoption-llvm-nm--print-size"],"-h":[58,0,1,"cmdoption-h"],"--config-prefix":[1,0,1,"cmdoption--config-prefix"],"-sections":[58,0,1,"cmdoption-sections"],"-f":[95,0,1,"cmdoption-llvm-cov-gcov-f"],"-function":[110,0,1,"cmdoption-llvm-profdata-show-function"],"-print-records":[106,0,1,"cmdoption-tblgen-print-records"],"-gen-dfa-packetizer":[106,0,1,"cmdoption-tblgen-gen-dfa-packetizer"],"--load":[77,0,1,"cmdoption--load"],"-dump":[38,0,1,"cmdoption-llvm-bcanalyzer-dump"],"--dynamic":[111,0,1,"cmdoption-llvm-nm--dynamic"],"--quiet":[1,0,1,"cmdoption--quiet"],"-demangle":[79,0,1,"cmdoption-demangle"],"--spiller":[77,0,1,"cmdoption--spiller"],"-gen-instr-info":[106,0,1,"cmdoption-tblgen-
gen-instr-info"],"-gen-intrinsic":[106,0,1,"cmdoption-tblgen-gen-intrinsic"],"--enable-unsafe-fp-math":[77,0,1,"cmdoption--enable-unsafe-fp-math"],"-arch":[95,0,1,"cmdoption-llvm-cov-report-arch"],"--unconditional-branches":[95,0,1,"cmdoption-llvm-cov-gcov--unconditional-branches"],"-strip-debug":[74,0,1,"cmdoption-strip-debug"],"--size-sort":[111,0,1,"cmdoption-llvm-nm--size-sort"],"--max-tests":[1,0,1,"cmdoption--max-tests"],"-size":[70,0,1,"cmdoption-size"],"--enable-no-infs-fp-math":[77,0,1,"cmdoption--enable-no-infs-fp-math"],"--path":[1,0,1,"cmdoption--path"],"-text":[110,0,1,"cmdoption-llvm-profdata-merge-text"],"-time-passes":[74,0,1,"cmdoption-time-passes"],"-march":[77,0,1,"cmdoption-march"],"--show-unsupported":[1,0,1,"cmdoption--show-unsupported"],"-disable-inlining":[74,0,1,"cmdoption-disable-inlining"],"--time-passes":[77,0,1,"cmdoption--time-passes"],"-region-coverage-lt":[95,0,1,"cmdoption-llvm-cov-show-region-coverage-lt"],"--vg":[1,0,1,"cmdoption--vg"],"--show-test
s":[1,0,1,"cmdoption--show-tests"],"--no-output":[95,0,1,"cmdoption-llvm-cov-gcov--no-output"],"-help":[110,0,1,"cmdoption-llvm-profdata-merge-help"],"--undefined-only":[111,0,1,"cmdoption-llvm-nm--undefined-only"],"-show-regions":[95,0,1,"cmdoption-llvm-cov-show-show-regions"],"--shuffle":[1,0,1,"cmdoption--shuffle"],"--extern-only":[111,0,1,"cmdoption-llvm-nm--extern-only"],"-verify-each":[74,0,1,"cmdoption-verify-each"],"--preserve-paths":[95,0,1,"cmdoption-llvm-cov-gcov--preserve-paths"],"--branch-counts":[95,0,1,"cmdoption-llvm-cov-gcov--branch-counts"],"-load":[74,0,1,"cmdoption-load"],"-expand-relocs":[58,0,1,"cmdoption-expand-relocs"],"--disable-excess-fp-precision":[77,0,1,"cmdoption--disable-excess-fp-precision"],"--format":[111,0,1,"cmdoption-llvm-nm--format"],"-print-enums":[106,0,1,"cmdoption-tblgen-print-enums"],"-use-symbol-table":[79,0,1,"cmdoption-use-symbol-table"],"-filetype":[77,0,1,"cmdoption-filetype"],"-gen-emitter":[106,0,1,"cmdoption-tblgen-gen-emitter"],"-u
nwind":[58,0,1,"cmdoption-unwind"],"-gen-pseudo-lowering":[106,0,1,"cmdoption-tblgen-gen-pseudo-lowering"],"-verify":[38,0,1,"cmdoption-llvm-bcanalyzer-verify"],"-gen-tgt-intrinsic":[106,0,1,"cmdoption-tblgen-gen-tgt-intrinsic"],"--help":[95,0,1,"cmdoption-llvm-cov-gcov--help"],"--implicit-check-not":[5,0,1,"cmdoption--implicit-check-not"],"-section-data":[58,0,1,"cmdoption-section-data"],"-disable-opt":[74,0,1,"cmdoption-disable-opt"],"-mcpu":[77,0,1,"cmdoption-mcpu"],"-file-headers":[58,0,1,"cmdoption-file-headers"],"--verbose":[1,0,1,"cmdoption--verbose"],"-debug":[74,0,1,"cmdoption-debug"],"--function-summaries":[95,0,1,"cmdoption-llvm-cov-gcov--function-summaries"],"-sample":[110,0,1,"cmdoption-llvm-profdata-show-sample"],"--param":[1,0,1,"cmdoption--param"],"-dynamic-table":[58,0,1,"cmdoption-dynamic-table"],"-inlining":[79,0,1,"cmdoption-inlining"],"--vg-arg":[1,0,1,"cmdoption--vg-arg"],"-functions":[79,0,1,"cmdoption-functions"],"-section-relocations":[58,0,1,"cmdoption-sect
ion-relocations"],"--debug":[1,0,1,"cmdoption--debug"],"--disable-fp-elim":[77,0,1,"cmdoption--disable-fp-elim"],"-mtriple":[77,0,1,"cmdoption-mtriple"],"--numeric-sort":[111,0,1,"cmdoption-llvm-nm--numeric-sort"],"--threads":[1,0,1,"cmdoption--threads"],"--strict-whitespace":[5,0,1,"cmdoption--strict-whitespace"],"-gen-fast-isel":[106,0,1,"cmdoption-tblgen-gen-fast-isel"],"-gen-disassembler":[106,0,1,"cmdoption-tblgen-gen-disassembler"],"-gen-asm-matcher":[106,0,1,"cmdoption-tblgen-gen-asm-matcher"],"-show-expansions":[95,0,1,"cmdoption-llvm-cov-show-show-expansions"],"--time-tests":[1,0,1,"cmdoption--time-tests"],"--no-sort":[111,0,1,"cmdoption-llvm-nm--no-sort"],"--object-file":[95,0,1,"cmdoption-llvm-cov-gcov--object-file"],"-dsym-hint":[79,0,1,"cmdoption-dsym-hint"],"--input-file":[5,0,1,"cmdoption--input-file"],"-st":[58,0,1,"cmdoption-st"],"--debug-syms":[111,0,1,"cmdoption-llvm-nm--debug-syms"],"-sr":[58,0,1,"cmdoption-sr"],"-gen-enhanced-disassembly-info":[106,0,1,"cmdoptio
n-tblgen-gen-enhanced-disassembly-info"],"--regalloc":[77,0,1,"cmdoption--regalloc"],"-output":[110,0,1,"cmdoption-llvm-profdata-show-output"],"-sd":[58,0,1,"cmdoption-sd"],"-default-arch":[79,0,1,"cmdoption-default-arch"]}},titleterms:{callingconv:21,prefix:[23,5],undef:98,"const":34,lsda:108,globalvari:16,concret:102,everi:92,"void":[34,23],module_code_funct:112,clangattrclass:21,type_code_numentri:112,vector:[32,103,16,23,0],verif:72,x86_64:9,paramattr_block:112,bitstream:112,mcstreamer:84,direct:[25,0,5,84,22,88,23],getposit:20,ilist:16,aggreg:[32,23,51],llvmbuild:28,blockinfo:112,scalarenumerationtrait:67,hide:20,neg:103,poison:23,"new":[76,32,65,42,33,98,47,56,10,15,16],postdomin:32,hasglobalalias:34,metadata:[91,3,23,8],elimin:32,amdgpu:[105,25],mem:23,copysign:23,lowerswitch:32,accur:23,studio:37,debugg:[32,23,56,83],valuemap:16,precis:[32,23],portabl:[40,92,31,98,11,4],fsub:23,unit:[84,41],tst_code_entri:112,would:34,init:23,call:[32,92,54,42,23,0,48,84,16,98],callgraph:[76
,32],simplifycfg:[32,98],type:[71,32,65,92,54,0,16,67,51,23,103,30,98,116],tell:103,relat:54,warn:[65,92],unpack:24,must:[20,42],word:112,setup:[43,41,102,19],work:[24,103,34],targetframelow:84,root:73,overrid:[66,42],phabric:107,give:98,coreclr:73,indic:[39,51,103],want:34,motion:32,end:[92,25,8,16,77,62,56,21,103,23,98],turn:[92,16,98],how:[84,114,102,103,33,34,26,62,9,36,94,64,21,57,69,16,98],tbaa:23,type_symtab_block:112,verifi:[32,98,5],config:[66,101],updat:[31,94,98,42],attrdoc:21,after:[92,90,98],befor:92,wrong:98,arch:25,domin:32,opaqu:23,alias:[34,20,84,23],environ:[76,24,31],reloc:[72,22],lambda:92,order:[67,23,86,78],frontend:51,over:[92,16,51],type_code_opaqu:112,fab:23,flexibl:5,clangstmtnod:21,fix:[34,84,16,56,112],strang:98,fadd:23,comprehens:31,erlang:73,safe:73,"break":[32,16],itanium:[108,105],spotless:66,each:32,debug:[32,41,42,56,68,99,10,16],foldingset:16,resum:23,extract:[32,7],content:[53,112,56,102,89],reader:58,got:62,dse:[32,42],umul:23,log2:23,barrier:[73
,8],written:98,standard:[24,92,97,23,56,112,4,16],reconfigur:66,filter:[108,84],pointstoconstantmemori:42,fptoui:23,regress:10,cmpvalu:34,isa:16,size:[85,16],rang:[71,23],neededsafepoint:73,independ:[40,84,11,98],restrict:108,lto_code_gen_t:90,instruct:[32,65,98,54,25,103,23,84,86,3,78,69,29,16],wrapper:112,exp2:23,top:[20,30],type_code_struct:112,evolut:32,toi:26,namespac:92,tool:[24,44,98,68,110,37,66,83],lower:[73,32,103],bpf_ind:84,removeus:34,mergereturn:32,target:[32,40,98,54,8,31,84,94,22,66,11,103,106,23,80],keyword:92,provid:92,tree:[32,98,52,18,113],project:[24,61,55,31,64,28,66,52],aapc:78,consumeaft:20,modern:24,increment:27,strength:32,aliassettrack:42,preincrement:92,simplifi:[32,92],object:[75,24,53,23,103,56,87,111,112,58,16,52],lexic:30,breakpoint:76,phase:[84,90,54],tinyptrvector:16,don:[4,92,98,103],dom:32,doc:105,flow:[13,67,49],doe:[76,26,98,103],declar:[32,30,56],caml:53,dot:32,ldc:31,random:[34,70],syntax:[8,5,109,22,113,23,72,88,30,6,18,116],freeform:20,build
bot:[114,26],dfapacket:21,getanalysisusag:76,absolut:20,layout:[32,84,24,23,8,56,16,52],acquir:86,machineinstr:84,configur:[24,98,35,1,9,87,77,114],ditemplatetypeparamet:23,rich:29,predecessor:16,ceil:23,smul:23,report:[33,95,62],x86_mmx:23,"public":[92,16,94],basicblock:[34,16],commandlin:20,attributeset:57,bitvector:16,result:[72,1,98,42],miscompil:[62,83],respons:[32,20,42],fail:98,awar:102,hopefulli:115,discoveri:1,dicompileunit:23,diderivedtyp:23,mul:23,irc:39,approach:90,attribut:[32,20,48,56,27,57,23],extend:[65,84,47,2,49,13,14,15],extens:[20,56,49,76,22,13],lazi:[32,16],rtti:[92,102],notatom:86,cov:95,fault:91,diff:46,guid:[32,25,8,39,20,86,68,10,35,28,66,26],assum:23,duplic:[4,32],"__nvvm_reflect":8,basic:[32,61,102,54,34,45,112,68,17,76,23,113,16,6,18],quickli:24,deeper:102,type_code_x86_fp80:112,ani:26,multithread:76,"catch":108,smallbitvector:16,read_regist:23,bitcod:[82,98,111,112,38,80,90],dissect:[71,8],properti:[40,11,56],slp:0,scalarrepl:32,anchor:92,mcsymbol:84,dw
arfdump:89,globaldc:32,perform:[98,51,0],make:[91,92,27,16,98],complex:[23,16],codeemitt:21,disubroutinetyp:23,fragil:10,reassoci:32,tune:77,libcal:32,qualif:94,bewar:92,client:42,thi:[41,103,34,26,98,47,115,51,15],programm:16,identifi:[73,23],languag:[53,40,92,45,23,31,98,47,2,49,56,11,13,14,15,30,17,116],expos:4,patchpoint:88,elf:22,els:[13,92,49],opt:[76,20,74],background:[102,99],shadow:73,linux:105,specif:[40,61,97,105,84,56,94,10,77,11,22,4],bpf:31,manual:[23,20,105,16],unnecessari:92,underli:103,right:[98,16],old:98,global_ctor:[98,23],interv:[32,84],argpromot:[32,42],type_code_fp128:112,intern:[32,20,92,66],indirect:23,global_dtor:23,functioncompar:34,subclass:[16,54],optparserdef:21,condit:32,core:16,aggress:32,memdep:32,tablegen:[81,84,21,100,30,6,116],promot:[32,54],post:32,chapter:[41,43,113,47,2,49,50,12,13,14,15,18,19],timelin:94,slightli:16,localescap:23,canonic:[32,23],commit:[27,107],looppass:76,instcombin:[32,98],"float":[23,22,80],encod:[71,84,112],bound:103,stora
g:[23,20,16],git:[24,26],wai:[16,103],support:[92,54,26,84,50,3,12,66,23,98],transform:[32,42],type_code_half:112,why:[41,103,34,26,98,47,15],avail:[73,42],width:[92,23,51,112],instrprof_incr:23,sitofp:23,analysi:[32,103,42,0,84,76,30],creation:75,form:[32,84],raw_ostream:92,modulepass:76,dead:32,heap:[73,16],icmp:23,profdata:110,inttoptr:[23,103],type_code_ppc_fp128:112,fundament:[65,81],lowerinvok:32,emit:[73,95],featur:[63,92,0,73,26,84,10],yaml2obj:109,"abstract":[73,113,51,112,4,23,18],diagnost:0,exist:[76,15,47,98,42],nvvmreflect:8,check:[91,32,0,5,66,16],bswap:23,assembl:[96,25,54,73,84,22,78,23],floor:23,tip:[40,11,51],test:[24,98,61,33,44,26,1,94,10,27,23,35],node:[32,65,23],stackrestor:23,intend:48,smallset:16,addpreserv:76,consid:51,setjmp:108,pseudo:71,time:[64,90,41,92,62],offsetof:[40,11],backward:27,concept:[71,66,76,6],nearbyint:23,chain:[24,37,16,42],ptrtoint:[23,103],global:[34,32,23,56,0],lli:80,llc:77,middl:98,depend:[63,32,22,42],graph:[32,16],readabl:[66,92],ua
dd:23,sourc:[71,24,41,61,31,98,56,87,92,79,52],string:[71,23,16],administr:94,level:[71,32,92,23,20,84,56,78,4,30,98],did:98,die:32,iter:[16,0],item:24,quick:[71,76,61,73,20,87,10],round:23,paramattr_code_entri:112,sign:[112,107],scev:[32,42],defici:[6,100],deriv:[65,16],gener:[32,84,35,1,23,16,75,97,43,70,98,49,13,83,19,73,22,80,108,62,66,106,116],globalsmodref:[32,42],modif:3,address:[75,103,84,79,8,23],along:34,tire:[14,2],safepoint:72,basiccg:32,localrecov:23,semant:[72,4,23,88,8],maxnum:23,extra:[10,103],modul:[32,7,92,23,76,66,16],prefer:[92,51],visibl:23,marker:23,instal:[66,9],type_code_void:112,dagisel:21,emitt:54,memori:[32,42,23,47,15,16],univers:98,subvers:[24,98],live:84,criteria:94,scope:[23,56,116],checkout:24,share:63,enhanc:72,visual:[37,61],prototyp:32,logarithm:34,ibm:105,registerinfo:21,prepar:75,uniqu:67,can:[98,103],topic:[53,16,61],critic:32,fp16:23,alwai:[32,103],multipl:16,targetsubtarget:84,write:[76,92,54,42,73,20,84,10,21,103,35,52,98],legalizetyp:84,fore
ach:30,map:[71,91,67,54,73,72,84,88,69,23,16],remap:75,armneonsema:21,memcpi:[32,23],smallstr:16,module_code_gcnam:112,mai:[32,42,34],data:[71,32,67,8,23,84,110,112,4,16],stress:70,autotool:[64,87],assici:34,ebpf:84,predic:92,inform:[32,41,105,31,92,56,10,95,27,16],"switch":[92,3,23],combin:[32,84],runonbasicblock:76,mapvector:16,callabl:16,comdat:23,microscop:92,tta:31,pointer:[23,42,16,103,0],dynam:[76,84,98],entiti:116,armneontest:21,group:[76,20,23],thumb:102,fastisel:21,polici:27,precondit:66,gen:8,platform:[10,105,98,61],jit:[54,31,84,50,12,66,99,16],cmptype:34,mail:39,main:34,non:[73,32,31],synopsi:[93,1,5,95,38,70,7,96,97,44,46,101,55,74,77,79,80,58,82,110,111,89,106],initi:[73,84,92,16,42],half:23,now:98,introduct:[32,62,67,33,34,92,36,48,3,69,23,6,71,65,41,84,8,43,113,45,9,2,49,50,47,12,13,14,15,16,17,18,19,75,54,103,73,20,100,56,76,114,21,22,78,57,94,59,61,25,108,26,42,85,86,64,27,28,66,29,115,30,31,116],name:[32,92,54,20,84,56,23],getanalysi:76,revers:0,sequentiallyconsi
st:86,sjlj:108,callsit:[32,108],compil:[24,101,41,61,31,62,9,77,50,63,92,87,12,105,23,98],replac:[32,16],individu:16,continu:92,releasememori:76,redistribut:98,operand:[72,88,54],happen:[98,103],switchinst:[32,3],armneon:21,space:[84,92,103,8],profil:[32,110],pocl:31,rational:[23,103],state:34,clangattrvisitor:21,frequenc:59,ocaml:73,codegen:86,thing:[98,51],gcmetadataprint:73,frequent:[98,61],first:[23,103],oper:[97,16,47,2,14,15,23],directli:[80,42],rint:23,arrai:[71,22,16,23,103],stringref:16,submit:[27,62],crit:32,open:[31,98],module_code_datalayout:112,convent:[84,54,8,98,48,23],type_block:112,fma:23,clangsacheck:21,copi:[92,48],specifi:[73,76,20,42],pragma:0,than:103,xcore:105,posit:20,seri:59,pre:[33,26],loweratom:32,licm:[32,42],argument:[32,20,16,23,116],doiniti:76,bitcast:23,bitwis:23,engin:75,readcyclecount:23,advic:[63,83],note:[31,84,105,36],printer:[32,54],normal:67,c99:22,insertel:23,"_global__i_a":98,cmpoper:34,runtim:[24,108,23,0],mcjit:[75,99],lexicon:60,show:[95,9
8,110],atom:[32,23,86],concurr:[23,86],hack:[32,9],runonscc:76,slot:32,onli:[32,16],mergefunct:34,fenc:23,behind:56,analyz:38,customwritebarri:73,offici:105,gep:[51,103],variou:32,get:[24,37,98,59],clang:[24,26,9,36,94,21],ssa:[32,84,98],targetjitinfo:84,requir:[24,103,42,73,20,84,10,37,76,52],intrins:[32,65,8,73,72,56,21,88,78,108,23],cmpconstant:34,where:98,summari:[24,103,87,78,38],kernel:8,gcwrite:[73,23],postdom:32,deadargelim:32,detect:32,review:[27,107],enumer:92,label:[23,92,5],clangcommenthtmltagsproperti:21,enough:83,clangattrpchread:21,volatil:23,between:[76,90,16,103],"import":16,spars:32,sparc:105,bitset:[23,104],region:[71,32,76],contract:102,audienc:54,tutori:[53,40,8,45,11,66,5,17],doesnotaccessmemori:42,frameaddress:23,acceler:56,pow:23,exploit:20,sccp:32,sentinel:16,rebuild:98,altern:[20,90],mark:8,basicaa:[32,42],fptrunc:23,"case":[44,27],module_code_vers:112,module_code_alia:112,type_code_point:112,cast:[16,103],invok:[32,16,23,8],tblgen:106,onlyreadsmemori:42,me
rgefunc:32,develop:[24,27,61,68,39],author:51,same:[16,5],rgpassmanag:76,binari:[113,98,2,94,14,23,18],document:[39,92,105,34,67,94,51],immutableset:16,exhaust:32,srem:23,ssub:23,preassign:84,nest:48,driver:[43,113,18,19],sreg:8,driven:42,value_symtab_block:112,setversionprint:20,extern:[32,20,31,35,53],defm:30,runonmachinefunct:76,macro:[67,16],markup:29,clobber:[84,23],without:98,model:23,dereferenc:103,customreadbarri:73,execut:[61,1,16,80,8],when:[26,92,83,51,98],s_waitcnt:25,neon:78,rest:[113,18],gdb:[76,99],smallvector:16,asmmatch:21,miscellan:[76,20,105,52],hint:[16,0],filecheck:5,except:[32,92,23,48,108],littl:92,versa:16,overview:[71,24,92,112,8,33,39,35,42,63,87,10,69,37,108,88,73,72,28,23,52],disubprogram:23,endcatch:108,earli:92,read:[73,34,90,54,8],amd:105,va_start:23,world:76,mod:32,intel:[77,105],integ:[23,112,103],dilexicalblockfil:23,output:[67,20,1,38,29,23,35],targetinstrinfo:[84,54],deduct:92,trampolin:23,freez:98,gvn:[32,42],definit:[88,60,92,116,38],achiev:16,l
egal:[84,51,54],exit:[32,92,93,1,5,95,38,70,7,96,97,44,46,101,55,74,77,79,80,58,82,110,111,89,106],refer:[32,73,16,20,23,28,30],garbag:[73,23,40,11,72],inspect:16,fpmath:23,clangattrimpl:21,"throw":[4,108],comparison:34,patent:27,stacklet:85,faultmap:91,routin:16,clangdiagsdef:21,effici:[48,42],bpf_ab:84,terminolog:[24,59],strip:32,your:[76,24,61,114,102],va_arg:23,log:[34,23],hex:67,nvvm:8,start:[71,24,61,73,20,84,76,10,37,23],interfac:[4,98,16,107,42],low:92,clear_cach:23,kaleidoscop:[53,40,41,43,113,45,47,2,49,50,11,12,13,14,15,17,18,19],resolut:90,addrequiredtransit:76,hard:[15,47,41],bundl:84,stackmap:88,epilog:84,conclus:[113,40,11,18],notat:[24,30],tripl:[84,23,8],possibl:[34,20,92],"default":[66,92,67],embed:61,loadabl:66,creat:[76,98,16,52,94],deep:115,deletevalu:42,file:[71,24,92,97,32,70,20,1,56,87,10,90,112,111,84,5,98,116],incorrect:62,collector:[73,23],multiclass:[30,116],field:34,valid:[33,67],copyright:27,you:115,architectur:105,formed:23,registri:76,sequenc:67,symbo
l:[79,32,111,90],ilist_trait:16,amd_kernel_code_t:25,ilist_nod:16,reduc:32,ipsccp:32,hsa_code_object_vers:25,directori:98,type_code_float:112,smrd:25,mask:23,hello:76,calle:48,mass:59,represent:[71,98,42],all:[32,98,66],dist:66,consider:[16,48,78],forbidden:92,scc:32,scalar:[32,67],ptx:8,follow:[34,103],ptr:[23,8],clangattrspellinglistindex:21,module_code_globalvar:112,tail:[32,84],program:[24,39,84,80,6,52],datalayout:84,type_code_funct:112,consum:56,faq:[26,98],urem:23,util:[72,24,67,55,32],candid:94,mechan:92,inteqclass:16,ia64:105,type_code_integ:112,induct:[32,0],list:[92,23,39,41,105,43,113,47,2,49,50,12,13,14,15,16,18,19,20,111,31,67],managedstat:16,adjust:[47,15,23],stderr:32,zero:108,design:[75,39,103,83,31,84,48,90,16],pass:[91,32,61,42,34,50,76,72,12,16],further:52,enter_subblock:112,heartble:26,trick:[40,11],what:[103,73,34,26,98,76,83],xor:23,sub:[71,31,23],polli:31,abi:[105,84,16,108],section:[91,88,115,22,89],ast:[13,49,18,113],abl:34,delet:[32,16],abbrevi:112,version
:[71,99,92,98,94],subtarget:[21,54],ctpop:23,method:[76,4,92,16,42],full:[41,43,113,47,2,49,50,12,13,14,15,23,18,19],hash:56,berkelei:84,behaviour:22,analysisusag:76,prologu:23,lto_module_t:90,modifi:[20,98,23,97],valu:[32,98,103,34,20,67,56,23,66,116,30,16],trunc:23,search:34,ahead:41,shufflevector:23,pick:16,action:108,via:107,primit:[112,116],transit:72,instrmap:69,select:[83,20,1,23,84],replacedirectcal:34,hexadecim:22,liber:92,regist:[32,98,54,8,84,76,51],two:[84,103],coverag:[71,95,26],unwindless:32,va_end:23,asm:[108,84,23],metadata_block:112,minor:25,more:[92,16],flat:25,tester:1,type_code_metadata:112,site:16,statepoint:[73,72,23],flag:[63,20,23,26,0],known:100,histori:[],minnum:23,abandon:107,def:[30,16],indirectbr:23,registr:[76,54],emiss:[84,41,22],addrspacecast:23,templat:[23,115,16,116],dicompositetyp:23,readobj:58,goal:73,anoth:16,immutablemap:16,phi:23,reject:98,unswitch:32,simpl:[32,16,23,8],isn:83,replacewithnewvalu:42,resourc:105,mccontext:84,reflect:8,help:[20,98
,16,52],through:92,constants_block:112,hierarchi:[16,102],paramet:[23,8],style:[92,102,42,22,23,52],late:84,clangcommenthtmltag:21,gcov:95,systemz:[31,105],good:26,"return":[32,92],frem:23,complain:8,module_code_sectionnam:112,diglobalvari:23,globalvalu:16,token:26,scalarevolut:32,fulli:92,subsystem:39,nightli:33,interleav:23,clangattrparsedattrimpl:21,weight:[3,59],branchinst:3,monoton:86,idea:[14,2],realli:98,linkag:23,expect:[3,23],longjmp:108,reduct:[32,44,0],safeti:[40,11],print:[76,32,101,89,42],subsubsect:115,occurr:20,qualifi:[98,94],advanc:[71,53,26,16],base:[32,98,102,103,31,84],ask:98,begincatch:108,thread:[32,16,23],bitconvert:78,clangattrparsedattrkind:21,postdomtre:32,clangcommenthtmlnamedcharacterrefer:21,lifetim:[23,48,56],assign:[32,15,47],major:[31,27,25],number:[32,20,112],smallptrset:16,module_block:112,differ:[35,98,103,42],script:[33,98],interact:[76,16],construct:[32,84,98],statement:3,natur:32,store:[32,84,23,51,98],option:[93,1,95,38,5,7,96,97,70,10,16,101,5
5,20,74,77,79,80,58,24,61,82,110,111,44,89,29,106],relationship:16,selector:54,libunwind:31,pars:[113,20,84,18],std:[92,16],i32:103,remov:32,cost:108,valuesymbolt:16,tailcallelim:32,comput:[73,31,103,8],packag:63,"null":[73,103],built:[73,84,3,98,67],lib:24,trip:0,self:98,lit:1,also:[93,7,92,96,97,44,1,77,38,80,111],exampl:[79,24,101,73,23,26,1,99,76,64,37,90,78,69,115,16,6],build:[61,114,55,26,98,9,36,87,94,76,64,28,52],extractvalu:23,extractel:23,brace:92,coff:[109,22],distribut:94,previou:98,machinebasicblock:84,most:32,plan:76,mach:56,cover:92,sibl:84,exp:23,rewritestatepointsforgc:72,microsoft:[37,61],ctag:21,runonmodul:[76,34],gold:64,clangattrparsedattrlist:21,stackprotectorcheck:23,fine:16,find:[32,98,16],write_regist:23,writer:105,solut:[34,26],unus:[4,32],express:[71,32,43,23,49,113,13,116,5,18,19],nativ:[84,112],externalfnconst:32,diloc:23,statist:[76,16],immutablepass:76,set:[24,102,54,42,20,76,32,16],clangattrpchwrit:21,mutabl:[15,47],see:[93,7,92,96,97,44,1,77,38,80,11
1],close:[43,32,19],arm:[22,105,9,36,78],dwarf:[89,41,56],module_code_tripl:112,vop1:25,vop3:25,won:115,end_block:112,unrol:[32,23,0],struct:[92,23,103],both:24,vopc:25,interprocedur:32,inalloca:48,debug_typ:16,context:67,let:[30,116],machinefunct:[76,84],load:[75,76,84,23,51],point:[73,23,22,88,80],schedul:[84,54],header:[71,4,92,56],alloca:[85,23],classof:102,functionpass:76,backend:[54,103,84,21,6,116],aarch64:105,diimportedent:23,strategi:[73,23],understand:98,atomicrmw:23,dequ:16,fptosi:23,passmanag:76,"while":16,unifi:32,kick:[14,2],behavior:42,error:[4,92,98,67],anonym:[32,92],loop:[32,92,0,31,49,76,13,23,59,116],prolog:84,subsect:115,propag:32,reg2mem:32,runonfunct:76,demot:32,illinoi:98,targetlow:84,minim:4,clangdiagsindexnam:21,decod:32,higher:98,x86:[105,84,22],diobjcproperti:23,optim:[32,40,74,31,62,86,50,64,11,12,84,90,98,56],va_copi:23,user:[32,25,8,39,26,67,47,2,77,14,15,16],function_block:112,specialis:23,stack:[32,40,73,72,84,85,88,22,11,23],stateless:32,travers:16,
task:[16,94],entri:[32,3,88],parenthes:92,person:23,propos:56,always_inlin:32,functionattr:32,module_code_asm:112,ipconstprop:32,ldr:78,mubuf:25,waymark:16,input:[26,67,23],type_code_label:112,vendor:25,format:[71,92,97,72,20,1,56,88,112,108,28,84,26],big:78,bia:59,ld1:78,bit:[23,20,16,112],pcre2:26,pcmarker:23,collect:[40,105,73,72,20,11,23,31],constmerg:32,clangdeclnod:21,often:103,cttz:23,back:[21,98,25,8],sampl:[69,71],mirror:24,densemap:16,sizeof:[40,11],instcount:32,cmpgep:34,scale:59,glibc:98,substitut:10,larg:51,bcanalyz:38,machin:[84,22,51,54],run:[98,8,35,1,9,76,6],step:[114,54,25],prerequisit:54,copyvalu:42,deadtypeelim:32,bugpoint:[44,83,32],constraint:23,indirectbrinst:3,dofin:76,runonloop:76,block:[32,92,23,67,112,16,59],gcroot:23,gcread:[73,23],chang:[107,43,31,56,27,16,19],announc:94,inclus:116,question:98,fast:23,custom:[54,103,73,20,67,35],arithmet:[84,23,103],includ:[4,66,92,98,24],suit:[24,61,33,35,1,87,10],fmuladd:23,aliasanalysi:42,properli:92,lint:32,link:[24,
82,8,64,37,90],cmpxchg:23,line:[107,0],info:[32,16,54,116],clangattrspel:21,consist:[4,92],fcmp:23,fdiv:23,impl:32,constant:[32,23,56,50,22,12,16],debugtrap:23,parser:[113,20,84,49,13,18],doesn:98,repres:84,clangattrlist:21,cmake:[61,9],sequenti:16,llvm:[32,62,108,0,47,35,1,92,36,68,94,95,37,3,38,102,4,23,71,39,7,96,84,8,43,70,46,9,49,50,10,11,72,12,13,15,16,98,52,19,53,101,54,55,73,77,74,40,56,76,21,22,78,89,79,80,58,111,59,97,93,24,103,60,61,82,83,26,42,85,86,87,110,63,64,27,88,112,65,114,66,29,90,31],clean:66,mismatch:98,domfronti:32,eval:[32,42],parseenvironmentopt:20,extrahelp:20,difil:23,svn:24,typeid:108,lane:78,algorithm:[84,16],vice:16,intervalmap:16,llvm_shutdown:16,llvmcontext:16,code:[32,92,84,4,99,23,71,41,43,113,98,47,2,49,50,12,13,14,15,16,52,19,75,54,73,56,76,79,80,24,107,83,26,62,87,27,18,108,106,116],partial:[32,0],edg:32,addescapingus:42,queri:32,privat:92,polyhedr:31,send:24,dienumer:23,mcinst:84,probe:22,vla:103,relev:105,magic:112,"try":[108,98],udiv:23,cfg:[32
,3],memset:23,jump:[32,84],fold:[12,84,54,50],instnam:32,compat:[26,27],index:103,twine:16,memcpyopt:[32,42],compar:[34,103],asmwrit:21,access:[34,27,23,84],experiment:[72,23,88],deduc:32,targetregisterinfo:[84,54],bodi:[32,30],objects:23,sext:[23,51],sink:32,implicit:91,convert:[79,23],convers:[8,23,54,0],vbr:112,implement:[75,53,40,78,54,42,73,34,84,85,76,90,11,23,113,4,16,59,18],domtre:32,dyn_cast:16,api:[29,84,16,31,98],dinamespac:23,from:[24,7,98,103,32,20,84,9,80,23,59],commun:[39,90,94],upgrad:98,next:5,websit:94,sort:16,insertvalu:23,hierchari:16,landingpad:23,nvptx:[84,105,8],alia:[32,103,42,0,20,84,23],annot:[29,23],endian:78,scatter:[23,0],control:[13,20,49,66],quickstart:[10,64,115],process:[33,34,84,94,39],optioncategori:20,high:[71,4,92,23,84],tag:[71,67,56,94,66,16],tab:92,afl:26,gcc:98,getregisteredopt:20,usub:23,subdirectori:52,instead:92,sin:23,fpext:23,overridden:34,constructor:92,targetdata:32,redund:32,philosophi:[90,83,56],physic:84,alloc:[85,84,16],sdiv:23,cou
nter:71,element:103,issu:[42,92,8],pseudolow:21,allow:20,move:81,stacksav:23,getanalysisifavail:76,elis:48,narr:34,define_abbrev:112,initroot:73,infrastructur:[10,114,1,42],dag:[84,5,59],crash:[62,83],handl:[108,32,84,23,67],auto:[92,0],front:[56,62,98,103],successor:16,module_code_purgev:112,mem2reg:32,fuzz:26,mode:[84,41,78],mnemon:84,basicblockpass:76,acquirereleas:86,denseset:16,postdomfronti:32,selectiondag:[65,84,54],clangcommentcommandlist:21,"static":[32,77,92],function_ref:16,patch:[24,27,88,94],dilexicalblock:23,special:[23,8],out:[61,103],variabl:[32,41,61,0,23,84,47,56,92,22,85,112,66,15,5,52],matrix:84,frontier:32,ret:23,categori:20,hardwar:[24,37,105],barrier0:8,ref:32,math:23,common:[24,37,66,16,8],iostream:[92,98],lcssa:32,attrbuild:57,manipul:23,powerpc:[31,84,105],deadarghax0r:32,releas:[33,31,86,94],indent:92,could:34,lexer:[13,45,17,49],keep:[4,92,98],length:22,outsid:86,lto:64,softwar:[24,37],qualiti:27,fmul:23,lshr:23,owner:27,unknown:0,licens:[64,27,98],system
:[4,37,116,23,24],messag:27,regionpass:76,termin:23,"final":[75,94],misunderstood:103,tidbit:[40,11],deconstruct:84,debuginfo:32,uitofp:23,arrayref:16,exactli:26,steen:42,prune:32,structur:[0,34,35,46,10,23,16],charact:112,bitvalu:67,clangattrparserstringswitch:21,mergetwofunct:34,linker:[90,23,82],have:103,tabl:[39,53,108,84,56,111],need:[115,103],printvar:66,disassembl:[84,29,21,93],mix:0,builtin:20,which:[103,42],mip:[31,105],singl:[32,23],preliminari:54,segment:[84,85],"class":[92,102,54,42,16,20,84,76,23,69,30,116],memorydependenceanalysi:42,placement:[32,52],returnaddress:23,gather:[23,0],request:107,getmodrefinfo:42,determin:20,linkonc:22,text:20,dbg:[32,56],findregress:33,module_code_deplib:112,trivial:[12,50],locat:[79,24,41,87],nondebug:32,getelementptr:[98,23],should:[34,98],ditemplatevalueparamet:23,vop2:25,stackprotector:23,local:[24,1,47,87,66,15,23],targetmachin:84,enabl:23,organ:[10,4,28],runonregion:76,stuff:98,integr:[28,32,1],partit:32,contain:[26,16],shl:23,view:
[32,16],type_code_arrai:112,frame:[108,40,84,11],packet:84,polymorph:16,statu:[72,1,5,95,38,70,7,96,97,44,46,93,101,55,74,77,79,80,58,82,107,31,110,111,89,106],pattern:5,dll:23,callgraphsccpass:76,kei:67,clangattrdump:21,isol:16,diexpress:23,noalia:23,endl:92,addit:[31,1],doxygen:92,plugin:[73,64],leb128:71,etc:[65,16],instanc:116,grain:16,comment:[66,92,116],parallel_loop_access:23,guidelin:115,hyphen:20,yaml:67,window:[105,26,22,108],compon:[28,26,84,101],packedvector:16,treat:[92,16],hsa_code_object_isa:25,assert:92,ptxa:8,present:34,multi:90,align:[112,78],libfuzz:26,contextu:29,defin:[92,54,47,2,14,15],sop2:25,layer:84,sop1:25,demo:[98,94],instrinfo:21,llvmbuildlandingpad:[],uglygep:103,archiv:[24,97],motiv:[91,88],mutat:[26,15,47],disubrang:23,cross:[24,9,61,87],sqrt:23,member:[16,103],clangsharp:31,donoth:23,clangdiaggroup:21,sopp:25,sadd:23,effect:103,sopc:25,expand:54,mcsection:84,sparsebitvector:16,builder:114,well:23,thought:[43,19],powi:23,command:[95,110,107,68,0],undef
in:[23,8],setvector:16,libdevic:8,unari:[14,2],distanc:103,"boolean":20,obtain:27,memmov:23,virtual:[4,92,84,98],tce:31,web:107,adt:16,makefil:[10,66,35,98,52],add:[114,23,103],cleanup:[108,48],adc:[32,42],match:[84,5],llvmsharp:31,globalopt:32,indvar:32,clangcommentnod:21,placesafepoint:72,know:34,insert:[72,84,16],like:[92,16,98],type_code_vector:112,registeranalysisgroup:76,unord:86,soft:4,page:[98,94],unreach:[98,23],unabbrev_record:112,suppli:26,guarante:[40,11],stringset:16,librari:[24,92,23,20,98,63,66,4,16,26,52],avoid:[92,51],trap:23,codegenprepar:32,dce:32,usag:[61,0,26,48,64,88,83],host:[24,98],prefetch:23,clangattrtemplateinstanti:21,about:[26,98],toolchain:24,uniquevector:16,type_code_doubl:112,lppassmanag:76,implicitnullcheck:91,zext:[23,51],disabl:23,ashr:23,metadata_attach:112,own:16,dibasictyp:23,automat:[44,23,83],merg:[32,110,34],machineinstrbuild:84,fuzzer:26,rotat:32,"var":23,dilocalvari:23,log10:23,"function":[71,32,7,41,8,43,34,20,0,92,65,56,76,3,23,4,84,16,98
,19],machinefunctionpass:76,gain:34,uninstal:66,overflow:[23,103],inlin:[32,92,23,84],bug:[62,102,33,72,46,111],liblto:90,count:[32,3,23,42,0],whether:20,record:[71,112],limit:42,problem:[24,41,26,98,47,76,37,78,100,15],evalu:[32,92,42],descript:[93,1,5,95,38,70,7,96,97,44,46,83,101,55,74,77,79,80,58,82,84,110,111,89,106,90],dure:0,constprop:32,sparseset:16,probabl:59,detail:[92,0,85,56,94,38,29],parsecommandlineopt:20,other:[40,92,105,103,8,23,20,42,10,3,11,51,16,98],lookup:56,futur:[76,84],branch:[32,3,59,54,94],iplist:16,stat:16,indexedmap:16,clangcommentcommandinfo:21,addrequir:76,ctlz:23,sparsemultiset:16,stringmap:16,stai:27,sphinx:115,reliabl:84,customroot:73,rule:[102,103,98,94,66,23],bcc:31,vliw:84,invari:[32,23]}})
\ No newline at end of file
Added: www-releases/trunk/3.7.1/docs/tutorial/LangImpl1.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/3.7.1/docs/tutorial/LangImpl1.html?rev=257950&view=auto
==============================================================================
--- www-releases/trunk/3.7.1/docs/tutorial/LangImpl1.html (added)
+++ www-releases/trunk/3.7.1/docs/tutorial/LangImpl1.html Fri Jan 15 17:13:16 2016
@@ -0,0 +1,358 @@
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+ <title>1. Kaleidoscope: Tutorial Introduction and the Lexer — LLVM 3.7 documentation</title>
+
+ <link rel="stylesheet" href="../_static/llvm-theme.css" type="text/css" />
+ <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
+
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: '../',
+ VERSION: '3.7',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true
+ };
+ </script>
+ <script type="text/javascript" src="../_static/jquery.js"></script>
+ <script type="text/javascript" src="../_static/underscore.js"></script>
+ <script type="text/javascript" src="../_static/doctools.js"></script>
+ <link rel="top" title="LLVM 3.7 documentation" href="../index.html" />
+ <link rel="up" title="LLVM Tutorial: Table of Contents" href="index.html" />
+ <link rel="next" title="2. Kaleidoscope: Implementing a Parser and AST" href="LangImpl2.html" />
+ <link rel="prev" title="LLVM Tutorial: Table of Contents" href="index.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">
+ <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="LangImpl2.html" title="2. Kaleidoscope: Implementing a Parser and AST"
+ accesskey="N">next</a> |</li>
+ <li class="right" >
+ <a href="index.html" title="LLVM Tutorial: Table of Contents"
+ accesskey="P">previous</a> |</li>
+ <li><a href="http://llvm.org/">LLVM Home</a> | </li>
+ <li><a href="../index.html">Documentation</a>»</li>
+
+ <li><a href="index.html" accesskey="U">LLVM Tutorial: Table of Contents</a> »</li>
+ </ul>
+ </div>
+
+
+ <div class="document">
+ <div class="documentwrapper">
+ <div class="body">
+
+ <div class="section" id="kaleidoscope-tutorial-introduction-and-the-lexer">
+<h1>1. Kaleidoscope: Tutorial Introduction and the Lexer<a class="headerlink" href="#kaleidoscope-tutorial-introduction-and-the-lexer" title="Permalink to this headline">¶</a></h1>
+<div class="contents local topic" id="contents">
+<ul class="simple">
+<li><a class="reference internal" href="#tutorial-introduction" id="id1">Tutorial Introduction</a></li>
+<li><a class="reference internal" href="#the-basic-language" id="id2">The Basic Language</a></li>
+<li><a class="reference internal" href="#the-lexer" id="id3">The Lexer</a></li>
+</ul>
+</div>
+<div class="section" id="tutorial-introduction">
+<h2><a class="toc-backref" href="#id1">1.1. Tutorial Introduction</a><a class="headerlink" href="#tutorial-introduction" title="Permalink to this headline">¶</a></h2>
+<p>Welcome to the “Implementing a language with LLVM” tutorial. This
+tutorial runs through the implementation of a simple language, showing
+how fun and easy it can be. This tutorial will get you up and started as
+well as help to build a framework you can extend to other languages. The
+code in this tutorial can also be used as a playground to hack on other
+LLVM specific things.</p>
+<p>The goal of this tutorial is to progressively unveil our language,
+describing how it is built up over time. This will let us cover a fairly
+broad range of language design and LLVM-specific usage issues, showing
+and explaining the code for it all along the way, without overwhelming
+you with tons of details up front.</p>
+<p>It is useful to point out ahead of time that this tutorial is really
+about teaching compiler techniques and LLVM specifically, <em>not</em> about
+teaching modern and sane software engineering principles. In practice,
+this means that we’ll take a number of shortcuts to simplify the
+exposition. For example, the code leaks memory, uses global variables
+all over the place, doesn’t use nice design patterns like
+<a class="reference external" href="http://en.wikipedia.org/wiki/Visitor_pattern">visitors</a>, etc... but
+it is very simple. If you dig in and use the code as a basis for future
+projects, fixing these deficiencies shouldn’t be hard.</p>
+<p>I’ve tried to put this tutorial together in a way that makes chapters
+easy to skip over if you are already familiar with or are uninterested
+in the various pieces. The structure of the tutorial is:</p>
+<ul class="simple">
+<li><a class="reference external" href="#language">Chapter #1</a>: Introduction to the Kaleidoscope
+language, and the definition of its Lexer - This shows where we are
+going and the basic functionality that we want it to do. In order to
+make this tutorial maximally understandable and hackable, we choose
+to implement everything in C++ instead of using lexer and parser
+generators. LLVM obviously works just fine with such tools, feel free
+to use one if you prefer.</li>
+<li><a class="reference external" href="LangImpl2.html">Chapter #2</a>: Implementing a Parser and AST -
+With the lexer in place, we can talk about parsing techniques and
+basic AST construction. This tutorial describes recursive descent
+parsing and operator precedence parsing. Nothing in Chapters 1 or 2
+is LLVM-specific, the code doesn’t even link in LLVM at this point.
+:)</li>
+<li><a class="reference external" href="LangImpl3.html">Chapter #3</a>: Code generation to LLVM IR - With
+the AST ready, we can show off how easy generation of LLVM IR really
+is.</li>
+<li><a class="reference external" href="LangImpl4.html">Chapter #4</a>: Adding JIT and Optimizer Support
+- Because a lot of people are interested in using LLVM as a JIT,
+we’ll dive right into it and show you the 3 lines it takes to add JIT
+support. LLVM is also useful in many other ways, but this is one
+simple and “sexy” way to show off its power. :)</li>
+<li><a class="reference external" href="LangImpl5.html">Chapter #5</a>: Extending the Language: Control
+Flow - With the language up and running, we show how to extend it
+with control flow operations (if/then/else and a ‘for’ loop). This
+gives us a chance to talk about simple SSA construction and control
+flow.</li>
+<li><a class="reference external" href="LangImpl6.html">Chapter #6</a>: Extending the Language:
+User-defined Operators - This is a silly but fun chapter that talks
+about extending the language to let the user program define their own
+arbitrary unary and binary operators (with assignable precedence!).
+This lets us build a significant piece of the “language” as library
+routines.</li>
+<li><a class="reference external" href="LangImpl7.html">Chapter #7</a>: Extending the Language: Mutable
+Variables - This chapter talks about adding user-defined local
+variables along with an assignment operator. The interesting part
+about this is how easy and trivial it is to construct SSA form in
+LLVM: no, LLVM does <em>not</em> require your front-end to construct SSA
+form!</li>
+<li><a class="reference external" href="LangImpl8.html">Chapter #8</a>: Extending the Language: Debug
+Information - Having built a decent little programming language with
+control flow, functions and mutable variables, we consider what it
+takes to add debug information to standalone executables. This debug
+information will allow you to set breakpoints in Kaleidoscope
+functions, print out argument variables, and call functions - all
+from within the debugger!</li>
+<li><a class="reference external" href="LangImpl8.html">Chapter #9</a>: Conclusion and other useful LLVM
+tidbits - This chapter wraps up the series by talking about
+potential ways to extend the language, but also includes a bunch of
+pointers to info about “special topics” like adding garbage
+collection support, exceptions, debugging, support for “spaghetti
+stacks”, and a bunch of other tips and tricks.</li>
+</ul>
+<p>By the end of the tutorial, we’ll have written a bit less than 1000 lines
+of non-comment, non-blank, lines of code. With this small amount of
+code, we’ll have built up a very reasonable compiler for a non-trivial
+language including a hand-written lexer, parser, AST, as well as code
+generation support with a JIT compiler. While other systems may have
+interesting “hello world” tutorials, I think the breadth of this
+tutorial is a great testament to the strengths of LLVM and why you
+should consider it if you’re interested in language or compiler design.</p>
+<p>A note about this tutorial: we expect you to extend the language and
+play with it on your own. Take the code and go crazy hacking away at it,
+compilers don’t need to be scary creatures - it can be a lot of fun to
+play with languages!</p>
+</div>
+<div class="section" id="the-basic-language">
+<h2><a class="toc-backref" href="#id2">1.2. The Basic Language</a><a class="headerlink" href="#the-basic-language" title="Permalink to this headline">¶</a></h2>
+<p>This tutorial will be illustrated with a toy language that we’ll call
+“<a class="reference external" href="http://en.wikipedia.org/wiki/Kaleidoscope">Kaleidoscope</a>” (derived
+from “meaning beautiful, form, and view”). Kaleidoscope is a procedural
+language that allows you to define functions, use conditionals, math,
+etc. Over the course of the tutorial, we’ll extend Kaleidoscope to
+support the if/then/else construct, a for loop, user defined operators,
+JIT compilation with a simple command line interface, etc.</p>
+<p>Because we want to keep things simple, the only datatype in Kaleidoscope
+is a 64-bit floating point type (aka ‘double’ in C parlance). As such,
+all values are implicitly double precision and the language doesn’t
+require type declarations. This gives the language a very nice and
+simple syntax. For example, the following simple example computes
+<a class="reference external" href="http://en.wikipedia.org/wiki/Fibonacci_number">Fibonacci numbers:</a></p>
+<div class="highlight-python"><div class="highlight"><pre># Compute the x'th fibonacci number.
+def fib(x)
+ if x < 3 then
+ 1
+ else
+ fib(x-1)+fib(x-2)
+
+# This expression will compute the 40th number.
+fib(40)
+</pre></div>
+</div>
+<p>We also allow Kaleidoscope to call into standard library functions (the
+LLVM JIT makes this completely trivial). This means that you can use the
+‘extern’ keyword to define a function before you use it (this is also
+useful for mutually recursive functions). For example:</p>
+<div class="highlight-python"><div class="highlight"><pre>extern sin(arg);
+extern cos(arg);
+extern atan2(arg1 arg2);
+
+atan2(sin(.4), cos(42))
+</pre></div>
+</div>
+<p>A more interesting example is included in Chapter 6 where we write a
+little Kaleidoscope application that <a class="reference external" href="LangImpl6.html#example">displays a Mandelbrot
+Set</a> at various levels of magnification.</p>
+<p>Lets dive into the implementation of this language!</p>
+</div>
+<div class="section" id="the-lexer">
+<h2><a class="toc-backref" href="#id3">1.3. The Lexer</a><a class="headerlink" href="#the-lexer" title="Permalink to this headline">¶</a></h2>
+<p>When it comes to implementing a language, the first thing needed is the
+ability to process a text file and recognize what it says. The
+traditional way to do this is to use a
+“<a class="reference external" href="http://en.wikipedia.org/wiki/Lexical_analysis">lexer</a>” (aka
+‘scanner’) to break the input up into “tokens”. Each token returned by
+the lexer includes a token code and potentially some metadata (e.g. the
+numeric value of a number). First, we define the possibilities:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">// The lexer returns tokens [0-255] if it is an unknown character, otherwise one</span>
+<span class="c1">// of these for known things.</span>
+<span class="k">enum</span> <span class="n">Token</span> <span class="p">{</span>
+ <span class="n">tok_eof</span> <span class="o">=</span> <span class="o">-</span><span class="mi">1</span><span class="p">,</span>
+
+ <span class="c1">// commands</span>
+ <span class="n">tok_def</span> <span class="o">=</span> <span class="o">-</span><span class="mi">2</span><span class="p">,</span> <span class="n">tok_extern</span> <span class="o">=</span> <span class="o">-</span><span class="mi">3</span><span class="p">,</span>
+
+ <span class="c1">// primary</span>
+ <span class="n">tok_identifier</span> <span class="o">=</span> <span class="o">-</span><span class="mi">4</span><span class="p">,</span> <span class="n">tok_number</span> <span class="o">=</span> <span class="o">-</span><span class="mi">5</span><span class="p">,</span>
+<span class="p">};</span>
+
+<span class="k">static</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">IdentifierStr</span><span class="p">;</span> <span class="c1">// Filled in if tok_identifier</span>
+<span class="k">static</span> <span class="kt">double</span> <span class="n">NumVal</span><span class="p">;</span> <span class="c1">// Filled in if tok_number</span>
+</pre></div>
+</div>
+<p>Each token returned by our lexer will either be one of the Token enum
+values or it will be an ‘unknown’ character like ‘+’, which is returned
+as its ASCII value. If the current token is an identifier, the
+<tt class="docutils literal"><span class="pre">IdentifierStr</span></tt> global variable holds the name of the identifier. If
+the current token is a numeric literal (like 1.0), <tt class="docutils literal"><span class="pre">NumVal</span></tt> holds its
+value. Note that we use global variables for simplicity, this is not the
+best choice for a real language implementation :).</p>
+<p>The actual implementation of the lexer is a single function named
+<tt class="docutils literal"><span class="pre">gettok</span></tt>. The <tt class="docutils literal"><span class="pre">gettok</span></tt> function is called to return the next token
+from standard input. Its definition starts as:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">/// gettok - Return the next token from standard input.</span>
+<span class="k">static</span> <span class="kt">int</span> <span class="nf">gettok</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">static</span> <span class="kt">int</span> <span class="n">LastChar</span> <span class="o">=</span> <span class="sc">' '</span><span class="p">;</span>
+
+ <span class="c1">// Skip any whitespace.</span>
+ <span class="k">while</span> <span class="p">(</span><span class="n">isspace</span><span class="p">(</span><span class="n">LastChar</span><span class="p">))</span>
+ <span class="n">LastChar</span> <span class="o">=</span> <span class="n">getchar</span><span class="p">();</span>
+</pre></div>
+</div>
+<p><tt class="docutils literal"><span class="pre">gettok</span></tt> works by calling the C <tt class="docutils literal"><span class="pre">getchar()</span></tt> function to read
+characters one at a time from standard input. It eats them as it
+recognizes them and stores the last character read, but not processed,
+in LastChar. The first thing that it has to do is ignore whitespace
+between tokens. This is accomplished with the loop above.</p>
+<p>The next thing <tt class="docutils literal"><span class="pre">gettok</span></tt> needs to do is recognize identifiers and
+specific keywords like “def”. Kaleidoscope does this with this simple
+loop:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">if</span> <span class="p">(</span><span class="n">isalpha</span><span class="p">(</span><span class="n">LastChar</span><span class="p">))</span> <span class="p">{</span> <span class="c1">// identifier: [a-zA-Z][a-zA-Z0-9]*</span>
+ <span class="n">IdentifierStr</span> <span class="o">=</span> <span class="n">LastChar</span><span class="p">;</span>
+ <span class="k">while</span> <span class="p">(</span><span class="n">isalnum</span><span class="p">((</span><span class="n">LastChar</span> <span class="o">=</span> <span class="n">getchar</span><span class="p">())))</span>
+ <span class="n">IdentifierStr</span> <span class="o">+=</span> <span class="n">LastChar</span><span class="p">;</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"def"</span><span class="p">)</span> <span class="k">return</span> <span class="n">tok_def</span><span class="p">;</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"extern"</span><span class="p">)</span> <span class="k">return</span> <span class="n">tok_extern</span><span class="p">;</span>
+ <span class="k">return</span> <span class="n">tok_identifier</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>Note that this code sets the ‘<tt class="docutils literal"><span class="pre">IdentifierStr</span></tt>‘ global whenever it
+lexes an identifier. Also, since language keywords are matched by the
+same loop, we handle them here inline. Numeric values are similar:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">if</span> <span class="p">(</span><span class="n">isdigit</span><span class="p">(</span><span class="n">LastChar</span><span class="p">)</span> <span class="o">||</span> <span class="n">LastChar</span> <span class="o">==</span> <span class="sc">'.'</span><span class="p">)</span> <span class="p">{</span> <span class="c1">// Number: [0-9.]+</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">NumStr</span><span class="p">;</span>
+ <span class="k">do</span> <span class="p">{</span>
+ <span class="n">NumStr</span> <span class="o">+=</span> <span class="n">LastChar</span><span class="p">;</span>
+ <span class="n">LastChar</span> <span class="o">=</span> <span class="n">getchar</span><span class="p">();</span>
+ <span class="p">}</span> <span class="k">while</span> <span class="p">(</span><span class="n">isdigit</span><span class="p">(</span><span class="n">LastChar</span><span class="p">)</span> <span class="o">||</span> <span class="n">LastChar</span> <span class="o">==</span> <span class="sc">'.'</span><span class="p">);</span>
+
+ <span class="n">NumVal</span> <span class="o">=</span> <span class="n">strtod</span><span class="p">(</span><span class="n">NumStr</span><span class="p">.</span><span class="n">c_str</span><span class="p">(),</span> <span class="mi">0</span><span class="p">);</span>
+ <span class="k">return</span> <span class="n">tok_number</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>This is all pretty straight-forward code for processing input. When
+reading a numeric value from input, we use the C <tt class="docutils literal"><span class="pre">strtod</span></tt> function to
+convert it to a numeric value that we store in <tt class="docutils literal"><span class="pre">NumVal</span></tt>. Note that
+this isn’t doing sufficient error checking: it will incorrectly read
+“1.23.45.67” and handle it as if you typed in “1.23”. Feel free to
+extend it :). Next we handle comments:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">if</span> <span class="p">(</span><span class="n">LastChar</span> <span class="o">==</span> <span class="sc">'#'</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">// Comment until end of line.</span>
+ <span class="k">do</span> <span class="n">LastChar</span> <span class="o">=</span> <span class="n">getchar</span><span class="p">();</span>
+ <span class="k">while</span> <span class="p">(</span><span class="n">LastChar</span> <span class="o">!=</span> <span class="n">EOF</span> <span class="o">&&</span> <span class="n">LastChar</span> <span class="o">!=</span> <span class="sc">'\n'</span> <span class="o">&&</span> <span class="n">LastChar</span> <span class="o">!=</span> <span class="sc">'\r'</span><span class="p">);</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">LastChar</span> <span class="o">!=</span> <span class="n">EOF</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">gettok</span><span class="p">();</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>We handle comments by skipping to the end of the line and then return
+the next token. Finally, if the input doesn’t match one of the above
+cases, it is either an operator character like ‘+’ or the end of the
+file. These are handled with this code:</p>
+<div class="highlight-c++"><div class="highlight"><pre> <span class="c1">// Check for end of file. Don't eat the EOF.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">LastChar</span> <span class="o">==</span> <span class="n">EOF</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">tok_eof</span><span class="p">;</span>
+
+ <span class="c1">// Otherwise, just return the character as its ascii value.</span>
+ <span class="kt">int</span> <span class="n">ThisChar</span> <span class="o">=</span> <span class="n">LastChar</span><span class="p">;</span>
+ <span class="n">LastChar</span> <span class="o">=</span> <span class="n">getchar</span><span class="p">();</span>
+ <span class="k">return</span> <span class="n">ThisChar</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>With this, we have the complete lexer for the basic Kaleidoscope
+language (the <a class="reference external" href="LangImpl2.html#code">full code listing</a> for the Lexer
+is available in the <a class="reference external" href="LangImpl2.html">next chapter</a> of the tutorial).
+Next we’ll <a class="reference external" href="LangImpl2.html">build a simple parser that uses this to build an Abstract
+Syntax Tree</a>. When we have that, we’ll include a
+driver so that you can use the lexer and parser together.</p>
+<p><a class="reference external" href="LangImpl2.html">Next: Implementing a Parser and AST</a></p>
+</div>
+</div>
+
+
+ </div>
+ </div>
+ <div class="clearer"></div>
+ </div>
+ <div class="related">
+ <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="LangImpl2.html" title="2. Kaleidoscope: Implementing a Parser and AST"
+ >next</a> |</li>
+ <li class="right" >
+ <a href="index.html" title="LLVM Tutorial: Table of Contents"
+ >previous</a> |</li>
+ <li><a href="http://llvm.org/">LLVM Home</a> | </li>
+ <li><a href="../index.html">Documentation</a>»</li>
+
+ <li><a href="index.html" >LLVM Tutorial: Table of Contents</a> »</li>
+ </ul>
+ </div>
+ <div class="footer">
+ © Copyright 2003-2016, LLVM Project.
+ Last updated on 2016-01-04.
+ Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.2.3.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/3.7.1/docs/tutorial/LangImpl2.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/3.7.1/docs/tutorial/LangImpl2.html?rev=257950&view=auto
==============================================================================
--- www-releases/trunk/3.7.1/docs/tutorial/LangImpl2.html (added)
+++ www-releases/trunk/3.7.1/docs/tutorial/LangImpl2.html Fri Jan 15 17:13:16 2016
@@ -0,0 +1,1117 @@
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+ <title>2. Kaleidoscope: Implementing a Parser and AST — LLVM 3.7 documentation</title>
+
+ <link rel="stylesheet" href="../_static/llvm-theme.css" type="text/css" />
+ <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
+
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: '../',
+ VERSION: '3.7',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true
+ };
+ </script>
+ <script type="text/javascript" src="../_static/jquery.js"></script>
+ <script type="text/javascript" src="../_static/underscore.js"></script>
+ <script type="text/javascript" src="../_static/doctools.js"></script>
+ <link rel="top" title="LLVM 3.7 documentation" href="../index.html" />
+ <link rel="up" title="LLVM Tutorial: Table of Contents" href="index.html" />
+ <link rel="next" title="3. Kaleidoscope: Code generation to LLVM IR" href="LangImpl3.html" />
+ <link rel="prev" title="1. Kaleidoscope: Tutorial Introduction and the Lexer" href="LangImpl1.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">
+ <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="LangImpl3.html" title="3. Kaleidoscope: Code generation to LLVM IR"
+ accesskey="N">next</a> |</li>
+ <li class="right" >
+ <a href="LangImpl1.html" title="1. Kaleidoscope: Tutorial Introduction and the Lexer"
+ accesskey="P">previous</a> |</li>
+ <li><a href="http://llvm.org/">LLVM Home</a> | </li>
+ <li><a href="../index.html">Documentation</a>»</li>
+
+ <li><a href="index.html" accesskey="U">LLVM Tutorial: Table of Contents</a> »</li>
+ </ul>
+ </div>
+
+
+ <div class="document">
+ <div class="documentwrapper">
+ <div class="body">
+
+ <div class="section" id="kaleidoscope-implementing-a-parser-and-ast">
+<h1>2. Kaleidoscope: Implementing a Parser and AST<a class="headerlink" href="#kaleidoscope-implementing-a-parser-and-ast" title="Permalink to this headline">¶</a></h1>
+<div class="contents local topic" id="contents">
+<ul class="simple">
+<li><a class="reference internal" href="#chapter-2-introduction" id="id2">Chapter 2 Introduction</a></li>
+<li><a class="reference internal" href="#the-abstract-syntax-tree-ast" id="id3">The Abstract Syntax Tree (AST)</a></li>
+<li><a class="reference internal" href="#parser-basics" id="id4">Parser Basics</a></li>
+<li><a class="reference internal" href="#basic-expression-parsing" id="id5">Basic Expression Parsing</a></li>
+<li><a class="reference internal" href="#binary-expression-parsing" id="id6">Binary Expression Parsing</a></li>
+<li><a class="reference internal" href="#parsing-the-rest" id="id7">Parsing the Rest</a></li>
+<li><a class="reference internal" href="#the-driver" id="id8">The Driver</a></li>
+<li><a class="reference internal" href="#conclusions" id="id9">Conclusions</a></li>
+<li><a class="reference internal" href="#full-code-listing" id="id10">Full Code Listing</a></li>
+</ul>
+</div>
+<div class="section" id="chapter-2-introduction">
+<h2><a class="toc-backref" href="#id2">2.1. Chapter 2 Introduction</a><a class="headerlink" href="#chapter-2-introduction" title="Permalink to this headline">¶</a></h2>
+<p>Welcome to Chapter 2 of the “<a class="reference external" href="index.html">Implementing a language with
+LLVM</a>” tutorial. This chapter shows you how to use the
+lexer, built in <a class="reference external" href="LangImpl1.html">Chapter 1</a>, to build a full
+<a class="reference external" href="http://en.wikipedia.org/wiki/Parsing">parser</a> for our Kaleidoscope
+language. Once we have a parser, we’ll define and build an <a class="reference external" href="http://en.wikipedia.org/wiki/Abstract_syntax_tree">Abstract
+Syntax Tree</a> (AST).</p>
+<p>The parser we will build uses a combination of <a class="reference external" href="http://en.wikipedia.org/wiki/Recursive_descent_parser">Recursive Descent
+Parsing</a> and
+<a class="reference external" href="http://en.wikipedia.org/wiki/Operator-precedence_parser">Operator-Precedence
+Parsing</a> to
+parse the Kaleidoscope language (the latter for binary expressions and
+the former for everything else). Before we get to parsing though, lets
+talk about the output of the parser: the Abstract Syntax Tree.</p>
+</div>
+<div class="section" id="the-abstract-syntax-tree-ast">
+<h2><a class="toc-backref" href="#id3">2.2. The Abstract Syntax Tree (AST)</a><a class="headerlink" href="#the-abstract-syntax-tree-ast" title="Permalink to this headline">¶</a></h2>
+<p>The AST for a program captures its behavior in such a way that it is
+easy for later stages of the compiler (e.g. code generation) to
+interpret. We basically want one object for each construct in the
+language, and the AST should closely model the language. In
+Kaleidoscope, we have expressions, a prototype, and a function object.
+We’ll start with expressions first:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">/// ExprAST - Base class for all expression nodes.</span>
+<span class="k">class</span> <span class="nc">ExprAST</span> <span class="p">{</span>
+<span class="nl">public:</span>
+ <span class="k">virtual</span> <span class="o">~</span><span class="n">ExprAST</span><span class="p">()</span> <span class="p">{}</span>
+<span class="p">};</span>
+
+<span class="c1">/// NumberExprAST - Expression class for numeric literals like "1.0".</span>
+<span class="k">class</span> <span class="nc">NumberExprAST</span> <span class="o">:</span> <span class="k">public</span> <span class="n">ExprAST</span> <span class="p">{</span>
+ <span class="kt">double</span> <span class="n">Val</span><span class="p">;</span>
+<span class="nl">public:</span>
+ <span class="n">NumberExprAST</span><span class="p">(</span><span class="kt">double</span> <span class="n">val</span><span class="p">)</span> <span class="o">:</span> <span class="n">Val</span><span class="p">(</span><span class="n">val</span><span class="p">)</span> <span class="p">{}</span>
+<span class="p">};</span>
+</pre></div>
+</div>
+<p>The code above shows the definition of the base ExprAST class and one
+subclass which we use for numeric literals. The important thing to note
+about this code is that the NumberExprAST class captures the numeric
+value of the literal as an instance variable. This allows later phases
+of the compiler to know what the stored numeric value is.</p>
+<p>Right now we only create the AST, so there are no useful accessor
+methods on them. It would be very easy to add a virtual method to pretty
+print the code, for example. Here are the other expression AST node
+definitions that we’ll use in the basic form of the Kaleidoscope
+language:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">/// VariableExprAST - Expression class for referencing a variable, like "a".</span>
+<span class="k">class</span> <span class="nc">VariableExprAST</span> <span class="o">:</span> <span class="k">public</span> <span class="n">ExprAST</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">Name</span><span class="p">;</span>
+<span class="nl">public:</span>
+ <span class="n">VariableExprAST</span><span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="o">&</span><span class="n">name</span><span class="p">)</span> <span class="o">:</span> <span class="n">Name</span><span class="p">(</span><span class="n">name</span><span class="p">)</span> <span class="p">{}</span>
+<span class="p">};</span>
+
+<span class="c1">/// BinaryExprAST - Expression class for a binary operator.</span>
+<span class="k">class</span> <span class="nc">BinaryExprAST</span> <span class="o">:</span> <span class="k">public</span> <span class="n">ExprAST</span> <span class="p">{</span>
+ <span class="kt">char</span> <span class="n">Op</span><span class="p">;</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">LHS</span><span class="p">,</span> <span class="o">*</span><span class="n">RHS</span><span class="p">;</span>
+<span class="nl">public:</span>
+ <span class="n">BinaryExprAST</span><span class="p">(</span><span class="kt">char</span> <span class="n">op</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">lhs</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">rhs</span><span class="p">)</span>
+ <span class="o">:</span> <span class="n">Op</span><span class="p">(</span><span class="n">op</span><span class="p">),</span> <span class="n">LHS</span><span class="p">(</span><span class="n">lhs</span><span class="p">),</span> <span class="n">RHS</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span> <span class="p">{}</span>
+<span class="p">};</span>
+
+<span class="c1">/// CallExprAST - Expression class for function calls.</span>
+<span class="k">class</span> <span class="nc">CallExprAST</span> <span class="o">:</span> <span class="k">public</span> <span class="n">ExprAST</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">Callee</span><span class="p">;</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">ExprAST</span><span class="o">*></span> <span class="n">Args</span><span class="p">;</span>
+<span class="nl">public:</span>
+ <span class="n">CallExprAST</span><span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="o">&</span><span class="n">callee</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">ExprAST</span><span class="o">*></span> <span class="o">&</span><span class="n">args</span><span class="p">)</span>
+ <span class="o">:</span> <span class="n">Callee</span><span class="p">(</span><span class="n">callee</span><span class="p">),</span> <span class="n">Args</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="p">{}</span>
+<span class="p">};</span>
+</pre></div>
+</div>
+<p>This is all (intentionally) rather straight-forward: variables capture
+the variable name, binary operators capture their opcode (e.g. ‘+’), and
+calls capture a function name as well as a list of any argument
+expressions. One thing that is nice about our AST is that it captures
+the language features without talking about the syntax of the language.
+Note that there is no discussion about precedence of binary operators,
+lexical structure, etc.</p>
+<p>For our basic language, these are all of the expression nodes we’ll
+define. Because it doesn’t have conditional control flow, it isn’t
+Turing-complete; we’ll fix that in a later installment. The two things
+we need next are a way to talk about the interface to a function, and a
+way to talk about functions themselves:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">/// PrototypeAST - This class represents the "prototype" for a function,</span>
+<span class="c1">/// which captures its name, and its argument names (thus implicitly the number</span>
+<span class="c1">/// of arguments the function takes).</span>
+<span class="k">class</span> <span class="nc">PrototypeAST</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">Name</span><span class="p">;</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span> <span class="n">Args</span><span class="p">;</span>
+<span class="nl">public:</span>
+ <span class="n">PrototypeAST</span><span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="o">&</span><span class="n">name</span><span class="p">,</span> <span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span> <span class="o">&</span><span class="n">args</span><span class="p">)</span>
+ <span class="o">:</span> <span class="n">Name</span><span class="p">(</span><span class="n">name</span><span class="p">),</span> <span class="n">Args</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="p">{}</span>
+<span class="p">};</span>
+
+<span class="c1">/// FunctionAST - This class represents a function definition itself.</span>
+<span class="k">class</span> <span class="nc">FunctionAST</span> <span class="p">{</span>
+ <span class="n">PrototypeAST</span> <span class="o">*</span><span class="n">Proto</span><span class="p">;</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Body</span><span class="p">;</span>
+<span class="nl">public:</span>
+ <span class="n">FunctionAST</span><span class="p">(</span><span class="n">PrototypeAST</span> <span class="o">*</span><span class="n">proto</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">body</span><span class="p">)</span>
+ <span class="o">:</span> <span class="n">Proto</span><span class="p">(</span><span class="n">proto</span><span class="p">),</span> <span class="n">Body</span><span class="p">(</span><span class="n">body</span><span class="p">)</span> <span class="p">{}</span>
+<span class="p">};</span>
+</pre></div>
+</div>
+<p>In Kaleidoscope, functions are typed with just a count of their
+arguments. Since all values are double precision floating point, the
+type of each argument doesn’t need to be stored anywhere. In a more
+aggressive and realistic language, the “ExprAST” class would probably
+have a type field.</p>
+<p>With this scaffolding, we can now talk about parsing expressions and
+function bodies in Kaleidoscope.</p>
+</div>
+<div class="section" id="parser-basics">
+<h2><a class="toc-backref" href="#id4">2.3. Parser Basics</a><a class="headerlink" href="#parser-basics" title="Permalink to this headline">¶</a></h2>
+<p>Now that we have an AST to build, we need to define the parser code to
+build it. The idea here is that we want to parse something like “x+y”
+(which is returned as three tokens by the lexer) into an AST that could
+be generated with calls like this:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">ExprAST</span> <span class="o">*</span><span class="n">X</span> <span class="o">=</span> <span class="k">new</span> <span class="n">VariableExprAST</span><span class="p">(</span><span class="s">"x"</span><span class="p">);</span>
+<span class="n">ExprAST</span> <span class="o">*</span><span class="n">Y</span> <span class="o">=</span> <span class="k">new</span> <span class="n">VariableExprAST</span><span class="p">(</span><span class="s">"y"</span><span class="p">);</span>
+<span class="n">ExprAST</span> <span class="o">*</span><span class="n">Result</span> <span class="o">=</span> <span class="k">new</span> <span class="n">BinaryExprAST</span><span class="p">(</span><span class="sc">'+'</span><span class="p">,</span> <span class="n">X</span><span class="p">,</span> <span class="n">Y</span><span class="p">);</span>
+</pre></div>
+</div>
+<p>In order to do this, we’ll start by defining some basic helper routines:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">/// CurTok/getNextToken - Provide a simple token buffer. CurTok is the current</span>
+<span class="c1">/// token the parser is looking at. getNextToken reads another token from the</span>
+<span class="c1">/// lexer and updates CurTok with its results.</span>
+<span class="k">static</span> <span class="kt">int</span> <span class="n">CurTok</span><span class="p">;</span>
+<span class="k">static</span> <span class="kt">int</span> <span class="nf">getNextToken</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="n">CurTok</span> <span class="o">=</span> <span class="n">gettok</span><span class="p">();</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>This implements a simple token buffer around the lexer. This allows us
+to look one token ahead at what the lexer is returning. Every function
+in our parser will assume that CurTok is the current token that needs to
+be parsed.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">/// Error* - These are little helper functions for error handling.</span>
+<span class="n">ExprAST</span> <span class="o">*</span><span class="nf">Error</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">Str</span><span class="p">)</span> <span class="p">{</span> <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"Error: %s</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">Str</span><span class="p">);</span><span class="k">return</span> <span class="mi">0</span><span class="p">;}</span>
+<span class="n">PrototypeAST</span> <span class="o">*</span><span class="nf">ErrorP</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">Str</span><span class="p">)</span> <span class="p">{</span> <span class="n">Error</span><span class="p">(</span><span class="n">Str</span><span class="p">);</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span> <span class="p">}</span>
+<span class="n">FunctionAST</span> <span class="o">*</span><span class="nf">ErrorF</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">Str</span><span class="p">)</span> <span class="p">{</span> <span class="n">Error</span><span class="p">(</span><span class="n">Str</span><span class="p">);</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span> <span class="p">}</span>
+</pre></div>
+</div>
+<p>The <tt class="docutils literal"><span class="pre">Error</span></tt> routines are simple helper routines that our parser will
+use to handle errors. The error recovery in our parser will not be the
+best and is not particular user-friendly, but it will be enough for our
+tutorial. These routines make it easier to handle errors in routines
+that have various return types: they always return null.</p>
+<p>With these basic helper functions, we can implement the first piece of
+our grammar: numeric literals.</p>
+</div>
+<div class="section" id="basic-expression-parsing">
+<h2><a class="toc-backref" href="#id5">2.4. Basic Expression Parsing</a><a class="headerlink" href="#basic-expression-parsing" title="Permalink to this headline">¶</a></h2>
+<p>We start with numeric literals, because they are the simplest to
+process. For each production in our grammar, we’ll define a function
+which parses that production. For numeric literals, we have:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">/// numberexpr ::= number</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseNumberExpr</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Result</span> <span class="o">=</span> <span class="k">new</span> <span class="n">NumberExprAST</span><span class="p">(</span><span class="n">NumVal</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// consume the number</span>
+ <span class="k">return</span> <span class="n">Result</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>This routine is very simple: it expects to be called when the current
+token is a <tt class="docutils literal"><span class="pre">tok_number</span></tt> token. It takes the current number value,
+creates a <tt class="docutils literal"><span class="pre">NumberExprAST</span></tt> node, advances the lexer to the next token,
+and finally returns.</p>
+<p>There are some interesting aspects to this. The most important one is
+that this routine eats all of the tokens that correspond to the
+production and returns the lexer buffer with the next token (which is
+not part of the grammar production) ready to go. This is a fairly
+standard way to go for recursive descent parsers. For a better example,
+the parenthesis operator is defined like this:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">/// parenexpr ::= '(' expression ')'</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseParenExpr</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat (.</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">V</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">V</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">')'</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"expected ')'"</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat ).</span>
+ <span class="k">return</span> <span class="n">V</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>This function illustrates a number of interesting things about the
+parser:</p>
+<p>1) It shows how we use the Error routines. When called, this function
+expects that the current token is a ‘(‘ token, but after parsing the
+subexpression, it is possible that there is no ‘)’ waiting. For example,
+if the user types in “(4 x” instead of “(4)”, the parser should emit an
+error. Because errors can occur, the parser needs a way to indicate that
+they happened: in our parser, we return null on an error.</p>
+<p>2) Another interesting aspect of this function is that it uses recursion
+by calling <tt class="docutils literal"><span class="pre">ParseExpression</span></tt> (we will soon see that
+<tt class="docutils literal"><span class="pre">ParseExpression</span></tt> can call <tt class="docutils literal"><span class="pre">ParseParenExpr</span></tt>). This is powerful
+because it allows us to handle recursive grammars, and keeps each
+production very simple. Note that parentheses do not cause construction
+of AST nodes themselves. While we could do it this way, the most
+important role of parentheses are to guide the parser and provide
+grouping. Once the parser constructs the AST, parentheses are not
+needed.</p>
+<p>The next simple production is for handling variable references and
+function calls:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">/// identifierexpr</span>
+<span class="c1">/// ::= identifier</span>
+<span class="c1">/// ::= identifier '(' expression* ')'</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseIdentifierExpr</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">IdName</span> <span class="o">=</span> <span class="n">IdentifierStr</span><span class="p">;</span>
+
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat identifier.</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">'('</span><span class="p">)</span> <span class="c1">// Simple variable ref.</span>
+ <span class="k">return</span> <span class="k">new</span> <span class="n">VariableExprAST</span><span class="p">(</span><span class="n">IdName</span><span class="p">);</span>
+
+ <span class="c1">// Call.</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat (</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">ExprAST</span><span class="o">*></span> <span class="n">Args</span><span class="p">;</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">')'</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">while</span> <span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Arg</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">Arg</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="n">Args</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">Arg</span><span class="p">);</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">==</span> <span class="sc">')'</span><span class="p">)</span> <span class="k">break</span><span class="p">;</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">','</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"Expected ')' or ',' in argument list"</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+
+ <span class="c1">// Eat the ')'.</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+
+ <span class="k">return</span> <span class="k">new</span> <span class="n">CallExprAST</span><span class="p">(</span><span class="n">IdName</span><span class="p">,</span> <span class="n">Args</span><span class="p">);</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>This routine follows the same style as the other routines. (It expects
+to be called if the current token is a <tt class="docutils literal"><span class="pre">tok_identifier</span></tt> token). It
+also has recursion and error handling. One interesting aspect of this is
+that it uses <em>look-ahead</em> to determine if the current identifier is a
+stand alone variable reference or if it is a function call expression.
+It handles this by checking to see if the token after the identifier is
+a ‘(‘ token, constructing either a <tt class="docutils literal"><span class="pre">VariableExprAST</span></tt> or
+<tt class="docutils literal"><span class="pre">CallExprAST</span></tt> node as appropriate.</p>
+<p>Now that we have all of our simple expression-parsing logic in place, we
+can define a helper function to wrap it together into one entry point.
+We call this class of expressions “primary” expressions, for reasons
+that will become more clear <a class="reference external" href="LangImpl6.html#unary">later in the
+tutorial</a>. In order to parse an arbitrary
+primary expression, we need to determine what sort of expression it is:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">/// primary</span>
+<span class="c1">/// ::= identifierexpr</span>
+<span class="c1">/// ::= numberexpr</span>
+<span class="c1">/// ::= parenexpr</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParsePrimary</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">switch</span> <span class="p">(</span><span class="n">CurTok</span><span class="p">)</span> <span class="p">{</span>
+ <span class="nl">default:</span> <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"unknown token when expecting an expression"</span><span class="p">);</span>
+ <span class="k">case</span> <span class="n">tok_identifier</span>: <span class="k">return</span> <span class="n">ParseIdentifierExpr</span><span class="p">();</span>
+ <span class="k">case</span> <span class="n">tok_number</span>: <span class="k">return</span> <span class="n">ParseNumberExpr</span><span class="p">();</span>
+ <span class="k">case</span> <span class="sc">'('</span>: <span class="k">return</span> <span class="n">ParseParenExpr</span><span class="p">();</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>Now that you see the definition of this function, it is more obvious why
+we can assume the state of CurTok in the various functions. This uses
+look-ahead to determine which sort of expression is being inspected, and
+then parses it with a function call.</p>
+<p>Now that basic expressions are handled, we need to handle binary
+expressions. They are a bit more complex.</p>
+</div>
+<div class="section" id="binary-expression-parsing">
+<h2><a class="toc-backref" href="#id6">2.5. Binary Expression Parsing</a><a class="headerlink" href="#binary-expression-parsing" title="Permalink to this headline">¶</a></h2>
+<p>Binary expressions are significantly harder to parse because they are
+often ambiguous. For example, when given the string “x+y*z”, the parser
+can choose to parse it as either “(x+y)*z” or “x+(y*z)”. With common
+definitions from mathematics, we expect the later parse, because “*”
+(multiplication) has higher <em>precedence</em> than “+” (addition).</p>
+<p>There are many ways to handle this, but an elegant and efficient way is
+to use <a class="reference external" href="http://en.wikipedia.org/wiki/Operator-precedence_parser">Operator-Precedence
+Parsing</a>.
+This parsing technique uses the precedence of binary operators to guide
+recursion. To start with, we need a table of precedences:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">/// BinopPrecedence - This holds the precedence for each binary operator that is</span>
+<span class="c1">/// defined.</span>
+<span class="k">static</span> <span class="n">std</span><span class="o">::</span><span class="n">map</span><span class="o"><</span><span class="kt">char</span><span class="p">,</span> <span class="kt">int</span><span class="o">></span> <span class="n">BinopPrecedence</span><span class="p">;</span>
+
+<span class="c1">/// GetTokPrecedence - Get the precedence of the pending binary operator token.</span>
+<span class="k">static</span> <span class="kt">int</span> <span class="nf">GetTokPrecedence</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">isascii</span><span class="p">(</span><span class="n">CurTok</span><span class="p">))</span>
+ <span class="k">return</span> <span class="o">-</span><span class="mi">1</span><span class="p">;</span>
+
+ <span class="c1">// Make sure it's a declared binop.</span>
+ <span class="kt">int</span> <span class="n">TokPrec</span> <span class="o">=</span> <span class="n">BinopPrecedence</span><span class="p">[</span><span class="n">CurTok</span><span class="p">];</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">TokPrec</span> <span class="o"><=</span> <span class="mi">0</span><span class="p">)</span> <span class="k">return</span> <span class="o">-</span><span class="mi">1</span><span class="p">;</span>
+ <span class="k">return</span> <span class="n">TokPrec</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="kt">int</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
+ <span class="c1">// Install standard binary operators.</span>
+ <span class="c1">// 1 is lowest precedence.</span>
+ <span class="n">BinopPrecedence</span><span class="p">[</span><span class="sc">'<'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">10</span><span class="p">;</span>
+ <span class="n">BinopPrecedence</span><span class="p">[</span><span class="sc">'+'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">20</span><span class="p">;</span>
+ <span class="n">BinopPrecedence</span><span class="p">[</span><span class="sc">'-'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">20</span><span class="p">;</span>
+ <span class="n">BinopPrecedence</span><span class="p">[</span><span class="sc">'*'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">40</span><span class="p">;</span> <span class="c1">// highest.</span>
+ <span class="p">...</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>For the basic form of Kaleidoscope, we will only support 4 binary
+operators (this can obviously be extended by you, our brave and intrepid
+reader). The <tt class="docutils literal"><span class="pre">GetTokPrecedence</span></tt> function returns the precedence for
+the current token, or -1 if the token is not a binary operator. Having a
+map makes it easy to add new operators and makes it clear that the
+algorithm doesn’t depend on the specific operators involved, but it
+would be easy enough to eliminate the map and do the comparisons in the
+<tt class="docutils literal"><span class="pre">GetTokPrecedence</span></tt> function. (Or just use a fixed-size array).</p>
+<p>With the helper above defined, we can now start parsing binary
+expressions. The basic idea of operator precedence parsing is to break
+down an expression with potentially ambiguous binary operators into
+pieces. Consider ,for example, the expression “a+b+(c+d)*e*f+g”.
+Operator precedence parsing considers this as a stream of primary
+expressions separated by binary operators. As such, it will first parse
+the leading primary expression “a”, then it will see the pairs [+, b]
+[+, (c+d)] [*, e] [*, f] and [+, g]. Note that because parentheses are
+primary expressions, the binary expression parser doesn’t need to worry
+about nested subexpressions like (c+d) at all.</p>
+<p>To start, an expression is a primary expression potentially followed by
+a sequence of [binop,primaryexpr] pairs:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">/// expression</span>
+<span class="c1">/// ::= primary binoprhs</span>
+<span class="c1">///</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseExpression</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">LHS</span> <span class="o">=</span> <span class="n">ParsePrimary</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">LHS</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">return</span> <span class="n">ParseBinOpRHS</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="n">LHS</span><span class="p">);</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p><tt class="docutils literal"><span class="pre">ParseBinOpRHS</span></tt> is the function that parses the sequence of pairs for
+us. It takes a precedence and a pointer to an expression for the part
+that has been parsed so far. Note that “x” is a perfectly valid
+expression: As such, “binoprhs” is allowed to be empty, in which case it
+returns the expression that is passed into it. In our example above, the
+code passes the expression for “a” into <tt class="docutils literal"><span class="pre">ParseBinOpRHS</span></tt> and the
+current token is “+”.</p>
+<p>The precedence value passed into <tt class="docutils literal"><span class="pre">ParseBinOpRHS</span></tt> indicates the
+<em>minimal operator precedence</em> that the function is allowed to eat. For
+example, if the current pair stream is [+, x] and <tt class="docutils literal"><span class="pre">ParseBinOpRHS</span></tt> is
+passed in a precedence of 40, it will not consume any tokens (because
+the precedence of ‘+’ is only 20). With this in mind, <tt class="docutils literal"><span class="pre">ParseBinOpRHS</span></tt>
+starts with:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">/// binoprhs</span>
+<span class="c1">/// ::= ('+' primary)*</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseBinOpRHS</span><span class="p">(</span><span class="kt">int</span> <span class="n">ExprPrec</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">LHS</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">// If this is a binop, find its precedence.</span>
+ <span class="k">while</span> <span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
+ <span class="kt">int</span> <span class="n">TokPrec</span> <span class="o">=</span> <span class="n">GetTokPrecedence</span><span class="p">();</span>
+
+ <span class="c1">// If this is a binop that binds at least as tightly as the current binop,</span>
+ <span class="c1">// consume it, otherwise we are done.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">TokPrec</span> <span class="o"><</span> <span class="n">ExprPrec</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">LHS</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>This code gets the precedence of the current token and checks to see if
+if is too low. Because we defined invalid tokens to have a precedence of
+-1, this check implicitly knows that the pair-stream ends when the token
+stream runs out of binary operators. If this check succeeds, we know
+that the token is a binary operator and that it will be included in this
+expression:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">// Okay, we know this is a binop.</span>
+<span class="kt">int</span> <span class="n">BinOp</span> <span class="o">=</span> <span class="n">CurTok</span><span class="p">;</span>
+<span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat binop</span>
+
+<span class="c1">// Parse the primary expression after the binary operator.</span>
+<span class="n">ExprAST</span> <span class="o">*</span><span class="n">RHS</span> <span class="o">=</span> <span class="n">ParsePrimary</span><span class="p">();</span>
+<span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">RHS</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>As such, this code eats (and remembers) the binary operator and then
+parses the primary expression that follows. This builds up the whole
+pair, the first of which is [+, b] for the running example.</p>
+<p>Now that we parsed the left-hand side of an expression and one pair of
+the RHS sequence, we have to decide which way the expression associates.
+In particular, we could have “(a+b) binop unparsed” or “a + (b binop
+unparsed)”. To determine this, we look ahead at “binop” to determine its
+precedence and compare it to BinOp’s precedence (which is ‘+’ in this
+case):</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">// If BinOp binds less tightly with RHS than the operator after RHS, let</span>
+<span class="c1">// the pending operator take RHS as its LHS.</span>
+<span class="kt">int</span> <span class="n">NextPrec</span> <span class="o">=</span> <span class="n">GetTokPrecedence</span><span class="p">();</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">TokPrec</span> <span class="o"><</span> <span class="n">NextPrec</span><span class="p">)</span> <span class="p">{</span>
+</pre></div>
+</div>
+<p>If the precedence of the binop to the right of “RHS” is lower or equal
+to the precedence of our current operator, then we know that the
+parentheses associate as “(a+b) binop ...”. In our example, the current
+operator is “+” and the next operator is “+”, we know that they have the
+same precedence. In this case we’ll create the AST node for “a+b”, and
+then continue parsing:</p>
+<div class="highlight-c++"><div class="highlight"><pre> <span class="p">...</span> <span class="k">if</span> <span class="n">body</span> <span class="n">omitted</span> <span class="p">...</span>
+ <span class="p">}</span>
+
+ <span class="c1">// Merge LHS/RHS.</span>
+ <span class="n">LHS</span> <span class="o">=</span> <span class="k">new</span> <span class="n">BinaryExprAST</span><span class="p">(</span><span class="n">BinOp</span><span class="p">,</span> <span class="n">LHS</span><span class="p">,</span> <span class="n">RHS</span><span class="p">);</span>
+ <span class="p">}</span> <span class="c1">// loop around to the top of the while loop.</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>In our example above, this will turn “a+b+” into “(a+b)” and execute the
+next iteration of the loop, with “+” as the current token. The code
+above will eat, remember, and parse “(c+d)” as the primary expression,
+which makes the current pair equal to [+, (c+d)]. It will then evaluate
+the ‘if’ conditional above with “*” as the binop to the right of the
+primary. In this case, the precedence of “*” is higher than the
+precedence of “+” so the if condition will be entered.</p>
+<p>The critical question left here is “how can the if condition parse the
+right hand side in full”? In particular, to build the AST correctly for
+our example, it needs to get all of “(c+d)*e*f” as the RHS expression
+variable. The code to do this is surprisingly simple (code from the
+above two blocks duplicated for context):</p>
+<div class="highlight-c++"><div class="highlight"><pre> <span class="c1">// If BinOp binds less tightly with RHS than the operator after RHS, let</span>
+ <span class="c1">// the pending operator take RHS as its LHS.</span>
+ <span class="kt">int</span> <span class="n">NextPrec</span> <span class="o">=</span> <span class="n">GetTokPrecedence</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">TokPrec</span> <span class="o"><</span> <span class="n">NextPrec</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">RHS</span> <span class="o">=</span> <span class="n">ParseBinOpRHS</span><span class="p">(</span><span class="n">TokPrec</span><span class="o">+</span><span class="mi">1</span><span class="p">,</span> <span class="n">RHS</span><span class="p">);</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">RHS</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="p">}</span>
+ <span class="c1">// Merge LHS/RHS.</span>
+ <span class="n">LHS</span> <span class="o">=</span> <span class="k">new</span> <span class="n">BinaryExprAST</span><span class="p">(</span><span class="n">BinOp</span><span class="p">,</span> <span class="n">LHS</span><span class="p">,</span> <span class="n">RHS</span><span class="p">);</span>
+ <span class="p">}</span> <span class="c1">// loop around to the top of the while loop.</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>At this point, we know that the binary operator to the RHS of our
+primary has higher precedence than the binop we are currently parsing.
+As such, we know that any sequence of pairs whose operators are all
+higher precedence than “+” should be parsed together and returned as
+“RHS”. To do this, we recursively invoke the <tt class="docutils literal"><span class="pre">ParseBinOpRHS</span></tt> function
+specifying “TokPrec+1” as the minimum precedence required for it to
+continue. In our example above, this will cause it to return the AST
+node for “(c+d)*e*f” as RHS, which is then set as the RHS of the ‘+’
+expression.</p>
+<p>Finally, on the next iteration of the while loop, the “+g” piece is
+parsed and added to the AST. With this little bit of code (14
+non-trivial lines), we correctly handle fully general binary expression
+parsing in a very elegant way. This was a whirlwind tour of this code,
+and it is somewhat subtle. I recommend running through it with a few
+tough examples to see how it works.</p>
+<p>This wraps up handling of expressions. At this point, we can point the
+parser at an arbitrary token stream and build an expression from it,
+stopping at the first token that is not part of the expression. Next up
+we need to handle function definitions, etc.</p>
+</div>
+<div class="section" id="parsing-the-rest">
+<h2><a class="toc-backref" href="#id7">2.6. Parsing the Rest</a><a class="headerlink" href="#parsing-the-rest" title="Permalink to this headline">¶</a></h2>
+<p>The next thing missing is handling of function prototypes. In
+Kaleidoscope, these are used both for ‘extern’ function declarations as
+well as function body definitions. The code to do this is
+straight-forward and not very interesting (once you’ve survived
+expressions):</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">/// prototype</span>
+<span class="c1">/// ::= id '(' id* ')'</span>
+<span class="k">static</span> <span class="n">PrototypeAST</span> <span class="o">*</span><span class="nf">ParsePrototype</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="n">tok_identifier</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">ErrorP</span><span class="p">(</span><span class="s">"Expected function name in prototype"</span><span class="p">);</span>
+
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">FnName</span> <span class="o">=</span> <span class="n">IdentifierStr</span><span class="p">;</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">'('</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">ErrorP</span><span class="p">(</span><span class="s">"Expected '(' in prototype"</span><span class="p">);</span>
+
+ <span class="c1">// Read the list of argument names.</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span> <span class="n">ArgNames</span><span class="p">;</span>
+ <span class="k">while</span> <span class="p">(</span><span class="n">getNextToken</span><span class="p">()</span> <span class="o">==</span> <span class="n">tok_identifier</span><span class="p">)</span>
+ <span class="n">ArgNames</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">IdentifierStr</span><span class="p">);</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">')'</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">ErrorP</span><span class="p">(</span><span class="s">"Expected ')' in prototype"</span><span class="p">);</span>
+
+ <span class="c1">// success.</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat ')'.</span>
+
+ <span class="k">return</span> <span class="k">new</span> <span class="n">PrototypeAST</span><span class="p">(</span><span class="n">FnName</span><span class="p">,</span> <span class="n">ArgNames</span><span class="p">);</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>Given this, a function definition is very simple, just a prototype plus
+an expression to implement the body:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">/// definition ::= 'def' prototype expression</span>
+<span class="k">static</span> <span class="n">FunctionAST</span> <span class="o">*</span><span class="nf">ParseDefinition</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat def.</span>
+ <span class="n">PrototypeAST</span> <span class="o">*</span><span class="n">Proto</span> <span class="o">=</span> <span class="n">ParsePrototype</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">Proto</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">ExprAST</span> <span class="o">*</span><span class="n">E</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">())</span>
+ <span class="k">return</span> <span class="k">new</span> <span class="n">FunctionAST</span><span class="p">(</span><span class="n">Proto</span><span class="p">,</span> <span class="n">E</span><span class="p">);</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>In addition, we support ‘extern’ to declare functions like ‘sin’ and
+‘cos’ as well as to support forward declaration of user functions. These
+‘extern’s are just prototypes with no body:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">/// external ::= 'extern' prototype</span>
+<span class="k">static</span> <span class="n">PrototypeAST</span> <span class="o">*</span><span class="nf">ParseExtern</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat extern.</span>
+ <span class="k">return</span> <span class="n">ParsePrototype</span><span class="p">();</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>Finally, we’ll also let the user type in arbitrary top-level expressions
+and evaluate them on the fly. We will handle this by defining anonymous
+nullary (zero argument) functions for them:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">/// toplevelexpr ::= expression</span>
+<span class="k">static</span> <span class="n">FunctionAST</span> <span class="o">*</span><span class="nf">ParseTopLevelExpr</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">ExprAST</span> <span class="o">*</span><span class="n">E</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">())</span> <span class="p">{</span>
+ <span class="c1">// Make an anonymous proto.</span>
+ <span class="n">PrototypeAST</span> <span class="o">*</span><span class="n">Proto</span> <span class="o">=</span> <span class="k">new</span> <span class="n">PrototypeAST</span><span class="p">(</span><span class="s">""</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span><span class="p">());</span>
+ <span class="k">return</span> <span class="k">new</span> <span class="n">FunctionAST</span><span class="p">(</span><span class="n">Proto</span><span class="p">,</span> <span class="n">E</span><span class="p">);</span>
+ <span class="p">}</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>Now that we have all the pieces, let’s build a little driver that will
+let us actually <em>execute</em> this code we’ve built!</p>
+</div>
+<div class="section" id="the-driver">
+<h2><a class="toc-backref" href="#id8">2.7. The Driver</a><a class="headerlink" href="#the-driver" title="Permalink to this headline">¶</a></h2>
+<p>The driver for this simply invokes all of the parsing pieces with a
+top-level dispatch loop. There isn’t much interesting here, so I’ll just
+include the top-level loop. See <a class="reference external" href="#code">below</a> for full code in the
+“Top-Level Parsing” section.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">/// top ::= definition | external | expression | ';'</span>
+<span class="k">static</span> <span class="kt">void</span> <span class="nf">MainLoop</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">while</span> <span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"ready> "</span><span class="p">);</span>
+ <span class="k">switch</span> <span class="p">(</span><span class="n">CurTok</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">case</span> <span class="n">tok_eof</span>: <span class="k">return</span><span class="p">;</span>
+ <span class="k">case</span> <span class="sc">';'</span>: <span class="n">getNextToken</span><span class="p">();</span> <span class="k">break</span><span class="p">;</span> <span class="c1">// ignore top-level semicolons.</span>
+ <span class="k">case</span> <span class="n">tok_def</span>: <span class="n">HandleDefinition</span><span class="p">();</span> <span class="k">break</span><span class="p">;</span>
+ <span class="k">case</span> <span class="n">tok_extern</span>: <span class="n">HandleExtern</span><span class="p">();</span> <span class="k">break</span><span class="p">;</span>
+ <span class="nl">default:</span> <span class="n">HandleTopLevelExpression</span><span class="p">();</span> <span class="k">break</span><span class="p">;</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>The most interesting part of this is that we ignore top-level
+semicolons. Why is this, you ask? The basic reason is that if you type
+“4 + 5” at the command line, the parser doesn’t know whether that is the
+end of what you will type or not. For example, on the next line you
+could type “def foo...” in which case 4+5 is the end of a top-level
+expression. Alternatively you could type “* 6”, which would continue
+the expression. Having top-level semicolons allows you to type “4+5;”,
+and the parser will know you are done.</p>
+</div>
+<div class="section" id="conclusions">
+<h2><a class="toc-backref" href="#id9">2.8. Conclusions</a><a class="headerlink" href="#conclusions" title="Permalink to this headline">¶</a></h2>
+<p>With just under 400 lines of commented code (240 lines of non-comment,
+non-blank code), we fully defined our minimal language, including a
+lexer, parser, and AST builder. With this done, the executable will
+validate Kaleidoscope code and tell us if it is grammatically invalid.
+For example, here is a sample interaction:</p>
+<div class="highlight-bash"><div class="highlight"><pre>$ ./a.out
+ready> def foo(x y) x+foo(y, 4.0);
+Parsed a function definition.
+ready> def foo(x y) x+y y;
+Parsed a function definition.
+Parsed a top-level expr
+ready> def foo(x y) x+y );
+Parsed a function definition.
+Error: unknown token when expecting an expression
+ready> extern sin(a);
+ready> Parsed an extern
+ready> ^D
+$
+</pre></div>
+</div>
+<p>There is a lot of room for extension here. You can define new AST nodes,
+extend the language in many ways, etc. In the <a class="reference external" href="LangImpl3.html">next
+installment</a>, we will describe how to generate LLVM
+Intermediate Representation (IR) from the AST.</p>
+</div>
+<div class="section" id="full-code-listing">
+<h2><a class="toc-backref" href="#id10">2.9. 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 this and the previous chapter.
+Note that it is fully self-contained: you don’t need LLVM or any
+external libraries at all for this. (Besides the C and C++ standard
+libraries, of course.) To build this, just compile with:</p>
+<div class="highlight-bash"><div class="highlight"><pre><span class="c"># Compile</span>
+clang++ -g -O3 toy.cpp
+<span class="c"># Run</span>
+./a.out
+</pre></div>
+</div>
+<p>Here is the code:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="cp">#include <cctype></span>
+<span class="cp">#include <cstdio></span>
+<span class="cp">#include <cstdlib></span>
+<span class="cp">#include <map></span>
+<span class="cp">#include <string></span>
+<span class="cp">#include <vector></span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// Lexer</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+
+<span class="c1">// The lexer returns tokens [0-255] if it is an unknown character, otherwise one</span>
+<span class="c1">// of these for known things.</span>
+<span class="k">enum</span> <span class="n">Token</span> <span class="p">{</span>
+ <span class="n">tok_eof</span> <span class="o">=</span> <span class="o">-</span><span class="mi">1</span><span class="p">,</span>
+
+ <span class="c1">// commands</span>
+ <span class="n">tok_def</span> <span class="o">=</span> <span class="o">-</span><span class="mi">2</span><span class="p">,</span> <span class="n">tok_extern</span> <span class="o">=</span> <span class="o">-</span><span class="mi">3</span><span class="p">,</span>
+
+ <span class="c1">// primary</span>
+ <span class="n">tok_identifier</span> <span class="o">=</span> <span class="o">-</span><span class="mi">4</span><span class="p">,</span> <span class="n">tok_number</span> <span class="o">=</span> <span class="o">-</span><span class="mi">5</span>
+<span class="p">};</span>
+
+<span class="k">static</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">IdentifierStr</span><span class="p">;</span> <span class="c1">// Filled in if tok_identifier</span>
+<span class="k">static</span> <span class="kt">double</span> <span class="n">NumVal</span><span class="p">;</span> <span class="c1">// Filled in if tok_number</span>
+
+<span class="c1">/// gettok - Return the next token from standard input.</span>
+<span class="k">static</span> <span class="kt">int</span> <span class="nf">gettok</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">static</span> <span class="kt">int</span> <span class="n">LastChar</span> <span class="o">=</span> <span class="sc">' '</span><span class="p">;</span>
+
+ <span class="c1">// Skip any whitespace.</span>
+ <span class="k">while</span> <span class="p">(</span><span class="n">isspace</span><span class="p">(</span><span class="n">LastChar</span><span class="p">))</span>
+ <span class="n">LastChar</span> <span class="o">=</span> <span class="n">getchar</span><span class="p">();</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">isalpha</span><span class="p">(</span><span class="n">LastChar</span><span class="p">))</span> <span class="p">{</span> <span class="c1">// identifier: [a-zA-Z][a-zA-Z0-9]*</span>
+ <span class="n">IdentifierStr</span> <span class="o">=</span> <span class="n">LastChar</span><span class="p">;</span>
+ <span class="k">while</span> <span class="p">(</span><span class="n">isalnum</span><span class="p">((</span><span class="n">LastChar</span> <span class="o">=</span> <span class="n">getchar</span><span class="p">())))</span>
+ <span class="n">IdentifierStr</span> <span class="o">+=</span> <span class="n">LastChar</span><span class="p">;</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"def"</span><span class="p">)</span> <span class="k">return</span> <span class="n">tok_def</span><span class="p">;</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"extern"</span><span class="p">)</span> <span class="k">return</span> <span class="n">tok_extern</span><span class="p">;</span>
+ <span class="k">return</span> <span class="n">tok_identifier</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">isdigit</span><span class="p">(</span><span class="n">LastChar</span><span class="p">)</span> <span class="o">||</span> <span class="n">LastChar</span> <span class="o">==</span> <span class="sc">'.'</span><span class="p">)</span> <span class="p">{</span> <span class="c1">// Number: [0-9.]+</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">NumStr</span><span class="p">;</span>
+ <span class="k">do</span> <span class="p">{</span>
+ <span class="n">NumStr</span> <span class="o">+=</span> <span class="n">LastChar</span><span class="p">;</span>
+ <span class="n">LastChar</span> <span class="o">=</span> <span class="n">getchar</span><span class="p">();</span>
+ <span class="p">}</span> <span class="k">while</span> <span class="p">(</span><span class="n">isdigit</span><span class="p">(</span><span class="n">LastChar</span><span class="p">)</span> <span class="o">||</span> <span class="n">LastChar</span> <span class="o">==</span> <span class="sc">'.'</span><span class="p">);</span>
+
+ <span class="n">NumVal</span> <span class="o">=</span> <span class="n">strtod</span><span class="p">(</span><span class="n">NumStr</span><span class="p">.</span><span class="n">c_str</span><span class="p">(),</span> <span class="mi">0</span><span class="p">);</span>
+ <span class="k">return</span> <span class="n">tok_number</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">LastChar</span> <span class="o">==</span> <span class="sc">'#'</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">// Comment until end of line.</span>
+ <span class="k">do</span> <span class="n">LastChar</span> <span class="o">=</span> <span class="n">getchar</span><span class="p">();</span>
+ <span class="k">while</span> <span class="p">(</span><span class="n">LastChar</span> <span class="o">!=</span> <span class="n">EOF</span> <span class="o">&&</span> <span class="n">LastChar</span> <span class="o">!=</span> <span class="sc">'\n'</span> <span class="o">&&</span> <span class="n">LastChar</span> <span class="o">!=</span> <span class="sc">'\r'</span><span class="p">);</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">LastChar</span> <span class="o">!=</span> <span class="n">EOF</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">gettok</span><span class="p">();</span>
+ <span class="p">}</span>
+
+ <span class="c1">// Check for end of file. Don't eat the EOF.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">LastChar</span> <span class="o">==</span> <span class="n">EOF</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">tok_eof</span><span class="p">;</span>
+
+ <span class="c1">// Otherwise, just return the character as its ascii value.</span>
+ <span class="kt">int</span> <span class="n">ThisChar</span> <span class="o">=</span> <span class="n">LastChar</span><span class="p">;</span>
+ <span class="n">LastChar</span> <span class="o">=</span> <span class="n">getchar</span><span class="p">();</span>
+ <span class="k">return</span> <span class="n">ThisChar</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// Abstract Syntax Tree (aka Parse Tree)</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="k">namespace</span> <span class="p">{</span>
+<span class="c1">/// ExprAST - Base class for all expression nodes.</span>
+<span class="k">class</span> <span class="nc">ExprAST</span> <span class="p">{</span>
+<span class="nl">public:</span>
+ <span class="k">virtual</span> <span class="o">~</span><span class="n">ExprAST</span><span class="p">()</span> <span class="p">{}</span>
+<span class="p">};</span>
+
+<span class="c1">/// NumberExprAST - Expression class for numeric literals like "1.0".</span>
+<span class="k">class</span> <span class="nc">NumberExprAST</span> <span class="o">:</span> <span class="k">public</span> <span class="n">ExprAST</span> <span class="p">{</span>
+<span class="nl">public:</span>
+ <span class="n">NumberExprAST</span><span class="p">(</span><span class="kt">double</span> <span class="n">val</span><span class="p">)</span> <span class="p">{}</span>
+<span class="p">};</span>
+
+<span class="c1">/// VariableExprAST - Expression class for referencing a variable, like "a".</span>
+<span class="k">class</span> <span class="nc">VariableExprAST</span> <span class="o">:</span> <span class="k">public</span> <span class="n">ExprAST</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">Name</span><span class="p">;</span>
+<span class="nl">public:</span>
+ <span class="n">VariableExprAST</span><span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="o">&</span><span class="n">name</span><span class="p">)</span> <span class="o">:</span> <span class="n">Name</span><span class="p">(</span><span class="n">name</span><span class="p">)</span> <span class="p">{}</span>
+<span class="p">};</span>
+
+<span class="c1">/// BinaryExprAST - Expression class for a binary operator.</span>
+<span class="k">class</span> <span class="nc">BinaryExprAST</span> <span class="o">:</span> <span class="k">public</span> <span class="n">ExprAST</span> <span class="p">{</span>
+<span class="nl">public:</span>
+ <span class="n">BinaryExprAST</span><span class="p">(</span><span class="kt">char</span> <span class="n">op</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">lhs</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">rhs</span><span class="p">)</span> <span class="p">{}</span>
+<span class="p">};</span>
+
+<span class="c1">/// CallExprAST - Expression class for function calls.</span>
+<span class="k">class</span> <span class="nc">CallExprAST</span> <span class="o">:</span> <span class="k">public</span> <span class="n">ExprAST</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">Callee</span><span class="p">;</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">ExprAST</span><span class="o">*></span> <span class="n">Args</span><span class="p">;</span>
+<span class="nl">public:</span>
+ <span class="n">CallExprAST</span><span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="o">&</span><span class="n">callee</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">ExprAST</span><span class="o">*></span> <span class="o">&</span><span class="n">args</span><span class="p">)</span>
+ <span class="o">:</span> <span class="n">Callee</span><span class="p">(</span><span class="n">callee</span><span class="p">),</span> <span class="n">Args</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="p">{}</span>
+<span class="p">};</span>
+
+<span class="c1">/// PrototypeAST - This class represents the "prototype" for a function,</span>
+<span class="c1">/// which captures its name, and its argument names (thus implicitly the number</span>
+<span class="c1">/// of arguments the function takes).</span>
+<span class="k">class</span> <span class="nc">PrototypeAST</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">Name</span><span class="p">;</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span> <span class="n">Args</span><span class="p">;</span>
+<span class="nl">public:</span>
+ <span class="n">PrototypeAST</span><span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="o">&</span><span class="n">name</span><span class="p">,</span> <span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span> <span class="o">&</span><span class="n">args</span><span class="p">)</span>
+ <span class="o">:</span> <span class="n">Name</span><span class="p">(</span><span class="n">name</span><span class="p">),</span> <span class="n">Args</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="p">{}</span>
+
+<span class="p">};</span>
+
+<span class="c1">/// FunctionAST - This class represents a function definition itself.</span>
+<span class="k">class</span> <span class="nc">FunctionAST</span> <span class="p">{</span>
+<span class="nl">public:</span>
+ <span class="n">FunctionAST</span><span class="p">(</span><span class="n">PrototypeAST</span> <span class="o">*</span><span class="n">proto</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">body</span><span class="p">)</span> <span class="p">{}</span>
+<span class="p">};</span>
+<span class="p">}</span> <span class="c1">// end anonymous namespace</span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// Parser</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+
+<span class="c1">/// CurTok/getNextToken - Provide a simple token buffer. CurTok is the current</span>
+<span class="c1">/// token the parser is looking at. getNextToken reads another token from the</span>
+<span class="c1">/// lexer and updates CurTok with its results.</span>
+<span class="k">static</span> <span class="kt">int</span> <span class="n">CurTok</span><span class="p">;</span>
+<span class="k">static</span> <span class="kt">int</span> <span class="nf">getNextToken</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="n">CurTok</span> <span class="o">=</span> <span class="n">gettok</span><span class="p">();</span>
+<span class="p">}</span>
+
+<span class="c1">/// BinopPrecedence - This holds the precedence for each binary operator that is</span>
+<span class="c1">/// defined.</span>
+<span class="k">static</span> <span class="n">std</span><span class="o">::</span><span class="n">map</span><span class="o"><</span><span class="kt">char</span><span class="p">,</span> <span class="kt">int</span><span class="o">></span> <span class="n">BinopPrecedence</span><span class="p">;</span>
+
+<span class="c1">/// GetTokPrecedence - Get the precedence of the pending binary operator token.</span>
+<span class="k">static</span> <span class="kt">int</span> <span class="nf">GetTokPrecedence</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">isascii</span><span class="p">(</span><span class="n">CurTok</span><span class="p">))</span>
+ <span class="k">return</span> <span class="o">-</span><span class="mi">1</span><span class="p">;</span>
+
+ <span class="c1">// Make sure it's a declared binop.</span>
+ <span class="kt">int</span> <span class="n">TokPrec</span> <span class="o">=</span> <span class="n">BinopPrecedence</span><span class="p">[</span><span class="n">CurTok</span><span class="p">];</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">TokPrec</span> <span class="o"><=</span> <span class="mi">0</span><span class="p">)</span> <span class="k">return</span> <span class="o">-</span><span class="mi">1</span><span class="p">;</span>
+ <span class="k">return</span> <span class="n">TokPrec</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">/// Error* - These are little helper functions for error handling.</span>
+<span class="n">ExprAST</span> <span class="o">*</span><span class="nf">Error</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">Str</span><span class="p">)</span> <span class="p">{</span> <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"Error: %s</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">Str</span><span class="p">);</span><span class="k">return</span> <span class="mi">0</span><span class="p">;}</span>
+<span class="n">PrototypeAST</span> <span class="o">*</span><span class="nf">ErrorP</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">Str</span><span class="p">)</span> <span class="p">{</span> <span class="n">Error</span><span class="p">(</span><span class="n">Str</span><span class="p">);</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span> <span class="p">}</span>
+
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseExpression</span><span class="p">();</span>
+
+<span class="c1">/// identifierexpr</span>
+<span class="c1">/// ::= identifier</span>
+<span class="c1">/// ::= identifier '(' expression* ')'</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseIdentifierExpr</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">IdName</span> <span class="o">=</span> <span class="n">IdentifierStr</span><span class="p">;</span>
+
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat identifier.</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">'('</span><span class="p">)</span> <span class="c1">// Simple variable ref.</span>
+ <span class="k">return</span> <span class="k">new</span> <span class="n">VariableExprAST</span><span class="p">(</span><span class="n">IdName</span><span class="p">);</span>
+
+ <span class="c1">// Call.</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat (</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">ExprAST</span><span class="o">*></span> <span class="n">Args</span><span class="p">;</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">')'</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">while</span> <span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Arg</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">Arg</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="n">Args</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">Arg</span><span class="p">);</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">==</span> <span class="sc">')'</span><span class="p">)</span> <span class="k">break</span><span class="p">;</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">','</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"Expected ')' or ',' in argument list"</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+
+ <span class="c1">// Eat the ')'.</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+
+ <span class="k">return</span> <span class="k">new</span> <span class="n">CallExprAST</span><span class="p">(</span><span class="n">IdName</span><span class="p">,</span> <span class="n">Args</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="c1">/// numberexpr ::= number</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseNumberExpr</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Result</span> <span class="o">=</span> <span class="k">new</span> <span class="n">NumberExprAST</span><span class="p">(</span><span class="n">NumVal</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// consume the number</span>
+ <span class="k">return</span> <span class="n">Result</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">/// parenexpr ::= '(' expression ')'</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseParenExpr</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat (.</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">V</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">V</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">')'</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"expected ')'"</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat ).</span>
+ <span class="k">return</span> <span class="n">V</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">/// primary</span>
+<span class="c1">/// ::= identifierexpr</span>
+<span class="c1">/// ::= numberexpr</span>
+<span class="c1">/// ::= parenexpr</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParsePrimary</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">switch</span> <span class="p">(</span><span class="n">CurTok</span><span class="p">)</span> <span class="p">{</span>
+ <span class="nl">default:</span> <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"unknown token when expecting an expression"</span><span class="p">);</span>
+ <span class="k">case</span> <span class="n">tok_identifier</span>: <span class="k">return</span> <span class="n">ParseIdentifierExpr</span><span class="p">();</span>
+ <span class="k">case</span> <span class="n">tok_number</span>: <span class="k">return</span> <span class="n">ParseNumberExpr</span><span class="p">();</span>
+ <span class="k">case</span> <span class="sc">'('</span>: <span class="k">return</span> <span class="n">ParseParenExpr</span><span class="p">();</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="c1">/// binoprhs</span>
+<span class="c1">/// ::= ('+' primary)*</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseBinOpRHS</span><span class="p">(</span><span class="kt">int</span> <span class="n">ExprPrec</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">LHS</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">// If this is a binop, find its precedence.</span>
+ <span class="k">while</span> <span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
+ <span class="kt">int</span> <span class="n">TokPrec</span> <span class="o">=</span> <span class="n">GetTokPrecedence</span><span class="p">();</span>
+
+ <span class="c1">// If this is a binop that binds at least as tightly as the current binop,</span>
+ <span class="c1">// consume it, otherwise we are done.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">TokPrec</span> <span class="o"><</span> <span class="n">ExprPrec</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">LHS</span><span class="p">;</span>
+
+ <span class="c1">// Okay, we know this is a binop.</span>
+ <span class="kt">int</span> <span class="n">BinOp</span> <span class="o">=</span> <span class="n">CurTok</span><span class="p">;</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat binop</span>
+
+ <span class="c1">// Parse the primary expression after the binary operator.</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">RHS</span> <span class="o">=</span> <span class="n">ParsePrimary</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">RHS</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="c1">// If BinOp binds less tightly with RHS than the operator after RHS, let</span>
+ <span class="c1">// the pending operator take RHS as its LHS.</span>
+ <span class="kt">int</span> <span class="n">NextPrec</span> <span class="o">=</span> <span class="n">GetTokPrecedence</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">TokPrec</span> <span class="o"><</span> <span class="n">NextPrec</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">RHS</span> <span class="o">=</span> <span class="n">ParseBinOpRHS</span><span class="p">(</span><span class="n">TokPrec</span><span class="o">+</span><span class="mi">1</span><span class="p">,</span> <span class="n">RHS</span><span class="p">);</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">RHS</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="c1">// Merge LHS/RHS.</span>
+ <span class="n">LHS</span> <span class="o">=</span> <span class="k">new</span> <span class="n">BinaryExprAST</span><span class="p">(</span><span class="n">BinOp</span><span class="p">,</span> <span class="n">LHS</span><span class="p">,</span> <span class="n">RHS</span><span class="p">);</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="c1">/// expression</span>
+<span class="c1">/// ::= primary binoprhs</span>
+<span class="c1">///</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseExpression</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">LHS</span> <span class="o">=</span> <span class="n">ParsePrimary</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">LHS</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">return</span> <span class="n">ParseBinOpRHS</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="n">LHS</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="c1">/// prototype</span>
+<span class="c1">/// ::= id '(' id* ')'</span>
+<span class="k">static</span> <span class="n">PrototypeAST</span> <span class="o">*</span><span class="nf">ParsePrototype</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="n">tok_identifier</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">ErrorP</span><span class="p">(</span><span class="s">"Expected function name in prototype"</span><span class="p">);</span>
+
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">FnName</span> <span class="o">=</span> <span class="n">IdentifierStr</span><span class="p">;</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">'('</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">ErrorP</span><span class="p">(</span><span class="s">"Expected '(' in prototype"</span><span class="p">);</span>
+
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span> <span class="n">ArgNames</span><span class="p">;</span>
+ <span class="k">while</span> <span class="p">(</span><span class="n">getNextToken</span><span class="p">()</span> <span class="o">==</span> <span class="n">tok_identifier</span><span class="p">)</span>
+ <span class="n">ArgNames</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">IdentifierStr</span><span class="p">);</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">')'</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">ErrorP</span><span class="p">(</span><span class="s">"Expected ')' in prototype"</span><span class="p">);</span>
+
+ <span class="c1">// success.</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat ')'.</span>
+
+ <span class="k">return</span> <span class="k">new</span> <span class="n">PrototypeAST</span><span class="p">(</span><span class="n">FnName</span><span class="p">,</span> <span class="n">ArgNames</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="c1">/// definition ::= 'def' prototype expression</span>
+<span class="k">static</span> <span class="n">FunctionAST</span> <span class="o">*</span><span class="nf">ParseDefinition</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat def.</span>
+ <span class="n">PrototypeAST</span> <span class="o">*</span><span class="n">Proto</span> <span class="o">=</span> <span class="n">ParsePrototype</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">Proto</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">ExprAST</span> <span class="o">*</span><span class="n">E</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">())</span>
+ <span class="k">return</span> <span class="k">new</span> <span class="n">FunctionAST</span><span class="p">(</span><span class="n">Proto</span><span class="p">,</span> <span class="n">E</span><span class="p">);</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">/// toplevelexpr ::= expression</span>
+<span class="k">static</span> <span class="n">FunctionAST</span> <span class="o">*</span><span class="nf">ParseTopLevelExpr</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">ExprAST</span> <span class="o">*</span><span class="n">E</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">())</span> <span class="p">{</span>
+ <span class="c1">// Make an anonymous proto.</span>
+ <span class="n">PrototypeAST</span> <span class="o">*</span><span class="n">Proto</span> <span class="o">=</span> <span class="k">new</span> <span class="n">PrototypeAST</span><span class="p">(</span><span class="s">""</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span><span class="p">());</span>
+ <span class="k">return</span> <span class="k">new</span> <span class="n">FunctionAST</span><span class="p">(</span><span class="n">Proto</span><span class="p">,</span> <span class="n">E</span><span class="p">);</span>
+ <span class="p">}</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">/// external ::= 'extern' prototype</span>
+<span class="k">static</span> <span class="n">PrototypeAST</span> <span class="o">*</span><span class="nf">ParseExtern</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat extern.</span>
+ <span class="k">return</span> <span class="n">ParsePrototype</span><span class="p">();</span>
+<span class="p">}</span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// Top-Level parsing</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+
+<span class="k">static</span> <span class="kt">void</span> <span class="nf">HandleDefinition</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">ParseDefinition</span><span class="p">())</span> <span class="p">{</span>
+ <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"Parsed a function definition.</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
+ <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+ <span class="c1">// Skip token for error recovery.</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="k">static</span> <span class="kt">void</span> <span class="nf">HandleExtern</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">ParseExtern</span><span class="p">())</span> <span class="p">{</span>
+ <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"Parsed an extern</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
+ <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+ <span class="c1">// Skip token for error recovery.</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="k">static</span> <span class="kt">void</span> <span class="nf">HandleTopLevelExpression</span><span class="p">()</span> <span class="p">{</span>
+ <span class="c1">// Evaluate a top-level expression into an anonymous function.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">ParseTopLevelExpr</span><span class="p">())</span> <span class="p">{</span>
+ <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"Parsed a top-level expr</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
+ <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+ <span class="c1">// Skip token for error recovery.</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="c1">/// top ::= definition | external | expression | ';'</span>
+<span class="k">static</span> <span class="kt">void</span> <span class="nf">MainLoop</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">while</span> <span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"ready> "</span><span class="p">);</span>
+ <span class="k">switch</span> <span class="p">(</span><span class="n">CurTok</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">case</span> <span class="n">tok_eof</span>: <span class="k">return</span><span class="p">;</span>
+ <span class="k">case</span> <span class="sc">';'</span>: <span class="n">getNextToken</span><span class="p">();</span> <span class="k">break</span><span class="p">;</span> <span class="c1">// ignore top-level semicolons.</span>
+ <span class="k">case</span> <span class="n">tok_def</span>: <span class="n">HandleDefinition</span><span class="p">();</span> <span class="k">break</span><span class="p">;</span>
+ <span class="k">case</span> <span class="n">tok_extern</span>: <span class="n">HandleExtern</span><span class="p">();</span> <span class="k">break</span><span class="p">;</span>
+ <span class="nl">default:</span> <span class="n">HandleTopLevelExpression</span><span class="p">();</span> <span class="k">break</span><span class="p">;</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// Main driver code.</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+
+<span class="kt">int</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
+ <span class="c1">// Install standard binary operators.</span>
+ <span class="c1">// 1 is lowest precedence.</span>
+ <span class="n">BinopPrecedence</span><span class="p">[</span><span class="sc">'<'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">10</span><span class="p">;</span>
+ <span class="n">BinopPrecedence</span><span class="p">[</span><span class="sc">'+'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">20</span><span class="p">;</span>
+ <span class="n">BinopPrecedence</span><span class="p">[</span><span class="sc">'-'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">20</span><span class="p">;</span>
+ <span class="n">BinopPrecedence</span><span class="p">[</span><span class="sc">'*'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">40</span><span class="p">;</span> <span class="c1">// highest.</span>
+
+ <span class="c1">// Prime the first token.</span>
+ <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"ready> "</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+
+ <span class="c1">// Run the main "interpreter loop" now.</span>
+ <span class="n">MainLoop</span><span class="p">();</span>
+
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p><a class="reference external" href="LangImpl3.html">Next: Implementing Code Generation to LLVM IR</a></p>
+</div>
+</div>
+
+
+ </div>
+ </div>
+ <div class="clearer"></div>
+ </div>
+ <div class="related">
+ <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="LangImpl3.html" title="3. Kaleidoscope: Code generation to LLVM IR"
+ >next</a> |</li>
+ <li class="right" >
+ <a href="LangImpl1.html" title="1. Kaleidoscope: Tutorial Introduction and the Lexer"
+ >previous</a> |</li>
+ <li><a href="http://llvm.org/">LLVM Home</a> | </li>
+ <li><a href="../index.html">Documentation</a>»</li>
+
+ <li><a href="index.html" >LLVM Tutorial: Table of Contents</a> »</li>
+ </ul>
+ </div>
+ <div class="footer">
+ © Copyright 2003-2016, LLVM Project.
+ Last updated on 2016-01-04.
+ Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.2.3.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/3.7.1/docs/tutorial/LangImpl3.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/3.7.1/docs/tutorial/LangImpl3.html?rev=257950&view=auto
==============================================================================
--- www-releases/trunk/3.7.1/docs/tutorial/LangImpl3.html (added)
+++ www-releases/trunk/3.7.1/docs/tutorial/LangImpl3.html Fri Jan 15 17:13:16 2016
@@ -0,0 +1,1193 @@
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+ <title>3. Kaleidoscope: Code generation to LLVM IR — LLVM 3.7 documentation</title>
+
+ <link rel="stylesheet" href="../_static/llvm-theme.css" type="text/css" />
+ <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
+
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: '../',
+ VERSION: '3.7',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true
+ };
+ </script>
+ <script type="text/javascript" src="../_static/jquery.js"></script>
+ <script type="text/javascript" src="../_static/underscore.js"></script>
+ <script type="text/javascript" src="../_static/doctools.js"></script>
+ <link rel="top" title="LLVM 3.7 documentation" href="../index.html" />
+ <link rel="up" title="LLVM Tutorial: Table of Contents" href="index.html" />
+ <link rel="next" title="4. Kaleidoscope: Adding JIT and Optimizer Support" href="LangImpl4.html" />
+ <link rel="prev" title="2. Kaleidoscope: Implementing a Parser and AST" href="LangImpl2.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">
+ <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="LangImpl4.html" title="4. Kaleidoscope: Adding JIT and Optimizer Support"
+ accesskey="N">next</a> |</li>
+ <li class="right" >
+ <a href="LangImpl2.html" title="2. Kaleidoscope: Implementing a Parser and AST"
+ accesskey="P">previous</a> |</li>
+ <li><a href="http://llvm.org/">LLVM Home</a> | </li>
+ <li><a href="../index.html">Documentation</a>»</li>
+
+ <li><a href="index.html" accesskey="U">LLVM Tutorial: Table of Contents</a> »</li>
+ </ul>
+ </div>
+
+
+ <div class="document">
+ <div class="documentwrapper">
+ <div class="body">
+
+ <div class="section" id="kaleidoscope-code-generation-to-llvm-ir">
+<h1>3. Kaleidoscope: Code generation to LLVM IR<a class="headerlink" href="#kaleidoscope-code-generation-to-llvm-ir" title="Permalink to this headline">¶</a></h1>
+<div class="contents local topic" id="contents">
+<ul class="simple">
+<li><a class="reference internal" href="#chapter-3-introduction" id="id1">Chapter 3 Introduction</a></li>
+<li><a class="reference internal" href="#code-generation-setup" id="id2">Code Generation Setup</a></li>
+<li><a class="reference internal" href="#expression-code-generation" id="id3">Expression Code Generation</a></li>
+<li><a class="reference internal" href="#function-code-generation" id="id4">Function Code Generation</a></li>
+<li><a class="reference internal" href="#driver-changes-and-closing-thoughts" id="id5">Driver Changes and Closing Thoughts</a></li>
+<li><a class="reference internal" href="#full-code-listing" id="id6">Full Code Listing</a></li>
+</ul>
+</div>
+<div class="section" id="chapter-3-introduction">
+<h2><a class="toc-backref" href="#id1">3.1. Chapter 3 Introduction</a><a class="headerlink" href="#chapter-3-introduction" title="Permalink to this headline">¶</a></h2>
+<p>Welcome to Chapter 3 of the “<a class="reference external" href="index.html">Implementing a language with
+LLVM</a>” tutorial. This chapter shows you how to transform
+the <a class="reference external" href="LangImpl2.html">Abstract Syntax Tree</a>, built in Chapter 2, into
+LLVM IR. This will teach you a little bit about how LLVM does things, as
+well as demonstrate how easy it is to use. It’s much more work to build
+a lexer and parser than it is to generate LLVM IR code. :)</p>
+<p><strong>Please note</strong>: the code in this chapter and later require LLVM 2.2 or
+later. LLVM 2.1 and before will not work with it. Also note that you
+need to use a version of this tutorial that matches your LLVM release:
+If you are using an official LLVM release, use the version of the
+documentation included with your release or on the <a class="reference external" href="http://llvm.org/releases/">llvm.org releases
+page</a>.</p>
+</div>
+<div class="section" id="code-generation-setup">
+<h2><a class="toc-backref" href="#id2">3.2. Code Generation Setup</a><a class="headerlink" href="#code-generation-setup" title="Permalink to this headline">¶</a></h2>
+<p>In order to generate LLVM IR, we want some simple setup to get started.
+First we define virtual code generation (codegen) methods in each AST
+class:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">/// ExprAST - Base class for all expression nodes.</span>
+<span class="k">class</span> <span class="nc">ExprAST</span> <span class="p">{</span>
+<span class="nl">public:</span>
+ <span class="k">virtual</span> <span class="o">~</span><span class="n">ExprAST</span><span class="p">()</span> <span class="p">{}</span>
+ <span class="k">virtual</span> <span class="n">Value</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">()</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="c1">/// NumberExprAST - Expression class for numeric literals like "1.0".</span>
+<span class="k">class</span> <span class="nc">NumberExprAST</span> <span class="o">:</span> <span class="k">public</span> <span class="n">ExprAST</span> <span class="p">{</span>
+ <span class="kt">double</span> <span class="n">Val</span><span class="p">;</span>
+<span class="nl">public:</span>
+ <span class="n">NumberExprAST</span><span class="p">(</span><span class="kt">double</span> <span class="n">val</span><span class="p">)</span> <span class="o">:</span> <span class="n">Val</span><span class="p">(</span><span class="n">val</span><span class="p">)</span> <span class="p">{}</span>
+ <span class="k">virtual</span> <span class="n">Value</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">();</span>
+<span class="p">};</span>
+<span class="p">...</span>
+</pre></div>
+</div>
+<p>The Codegen() method says to emit IR for that AST node along with all
+the things it depends on, and they all return an LLVM Value object.
+“Value” is the class used to represent a “<a class="reference external" href="http://en.wikipedia.org/wiki/Static_single_assignment_form">Static Single Assignment
+(SSA)</a>
+register” or “SSA value” in LLVM. The most distinct aspect of SSA values
+is that their value is computed as the related instruction executes, and
+it does not get a new value until (and if) the instruction re-executes.
+In other words, there is no way to “change” an SSA value. For more
+information, please read up on <a class="reference external" href="http://en.wikipedia.org/wiki/Static_single_assignment_form">Static Single
+Assignment</a>
+- the concepts are really quite natural once you grok them.</p>
+<p>Note that instead of adding virtual methods to the ExprAST class
+hierarchy, it could also make sense to use a <a class="reference external" href="http://en.wikipedia.org/wiki/Visitor_pattern">visitor
+pattern</a> or some other
+way to model this. Again, this tutorial won’t dwell on good software
+engineering practices: for our purposes, adding a virtual method is
+simplest.</p>
+<p>The second thing we want is an “Error” method like we used for the
+parser, which will be used to report errors found during code generation
+(for example, use of an undeclared parameter):</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">Value</span> <span class="o">*</span><span class="nf">ErrorV</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">Str</span><span class="p">)</span> <span class="p">{</span> <span class="n">Error</span><span class="p">(</span><span class="n">Str</span><span class="p">);</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span> <span class="p">}</span>
+
+<span class="k">static</span> <span class="n">Module</span> <span class="o">*</span><span class="n">TheModule</span><span class="p">;</span>
+<span class="k">static</span> <span class="n">IRBuilder</span><span class="o"><></span> <span class="n">Builder</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">());</span>
+<span class="k">static</span> <span class="n">std</span><span class="o">::</span><span class="n">map</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">,</span> <span class="n">Value</span><span class="o">*></span> <span class="n">NamedValues</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>The static variables will be used during code generation. <tt class="docutils literal"><span class="pre">TheModule</span></tt>
+is the LLVM construct that contains all of the functions and global
+variables in a chunk of code. In many ways, it is the top-level
+structure that the LLVM IR uses to contain code.</p>
+<p>The <tt class="docutils literal"><span class="pre">Builder</span></tt> object is a helper object that makes it easy to generate
+LLVM instructions. Instances of the
+<a class="reference external" href="http://llvm.org/doxygen/IRBuilder_8h-source.html">IRBuilder</a>
+class template keep track of the current place to insert instructions
+and has methods to create new instructions.</p>
+<p>The <tt class="docutils literal"><span class="pre">NamedValues</span></tt> map keeps track of which values are defined in the
+current scope and what their LLVM representation is. (In other words, it
+is a symbol table for the code). In this form of Kaleidoscope, the only
+things that can be referenced are function parameters. As such, function
+parameters will be in this map when generating code for their function
+body.</p>
+<p>With these basics in place, we can start talking about how to generate
+code for each expression. Note that this assumes that the <tt class="docutils literal"><span class="pre">Builder</span></tt>
+has been set up to generate code <em>into</em> something. For now, we’ll assume
+that this has already been done, and we’ll just use it to emit code.</p>
+</div>
+<div class="section" id="expression-code-generation">
+<h2><a class="toc-backref" href="#id3">3.3. Expression Code Generation</a><a class="headerlink" href="#expression-code-generation" title="Permalink to this headline">¶</a></h2>
+<p>Generating LLVM code for expression nodes is very straightforward: less
+than 45 lines of commented code for all four of our expression nodes.
+First we’ll do numeric literals:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">Value</span> <span class="o">*</span><span class="n">NumberExprAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="n">ConstantFP</span><span class="o">::</span><span class="n">get</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">(),</span> <span class="n">APFloat</span><span class="p">(</span><span class="n">Val</span><span class="p">));</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>In the LLVM IR, numeric constants are represented with the
+<tt class="docutils literal"><span class="pre">ConstantFP</span></tt> class, which holds the numeric value in an <tt class="docutils literal"><span class="pre">APFloat</span></tt>
+internally (<tt class="docutils literal"><span class="pre">APFloat</span></tt> has the capability of holding floating point
+constants of Arbitrary Precision). This code basically just creates
+and returns a <tt class="docutils literal"><span class="pre">ConstantFP</span></tt>. Note that in the LLVM IR that constants
+are all uniqued together and shared. For this reason, the API uses the
+“foo::get(...)” idiom instead of “new foo(..)” or “foo::Create(..)”.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">Value</span> <span class="o">*</span><span class="n">VariableExprAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="c1">// Look this variable up in the function.</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">V</span> <span class="o">=</span> <span class="n">NamedValues</span><span class="p">[</span><span class="n">Name</span><span class="p">];</span>
+ <span class="k">return</span> <span class="n">V</span> <span class="o">?</span> <span class="n">V</span> <span class="o">:</span> <span class="n">ErrorV</span><span class="p">(</span><span class="s">"Unknown variable name"</span><span class="p">);</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>References to variables are also quite simple using LLVM. In the simple
+version of Kaleidoscope, we assume that the variable has already been
+emitted somewhere and its value is available. In practice, the only
+values that can be in the <tt class="docutils literal"><span class="pre">NamedValues</span></tt> map are function arguments.
+This code simply checks to see that the specified name is in the map (if
+not, an unknown variable is being referenced) and returns the value for
+it. In future chapters, we’ll add support for <a class="reference external" href="LangImpl5.html#for">loop induction
+variables</a> in the symbol table, and for <a class="reference external" href="LangImpl7.html#localvars">local
+variables</a>.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">Value</span> <span class="o">*</span><span class="n">BinaryExprAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">L</span> <span class="o">=</span> <span class="n">LHS</span><span class="o">-></span><span class="n">Codegen</span><span class="p">();</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">R</span> <span class="o">=</span> <span class="n">RHS</span><span class="o">-></span><span class="n">Codegen</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">L</span> <span class="o">==</span> <span class="mi">0</span> <span class="o">||</span> <span class="n">R</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">switch</span> <span class="p">(</span><span class="n">Op</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">case</span> <span class="sc">'+'</span>: <span class="k">return</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateFAdd</span><span class="p">(</span><span class="n">L</span><span class="p">,</span> <span class="n">R</span><span class="p">,</span> <span class="s">"addtmp"</span><span class="p">);</span>
+ <span class="k">case</span> <span class="sc">'-'</span>: <span class="k">return</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateFSub</span><span class="p">(</span><span class="n">L</span><span class="p">,</span> <span class="n">R</span><span class="p">,</span> <span class="s">"subtmp"</span><span class="p">);</span>
+ <span class="k">case</span> <span class="sc">'*'</span>: <span class="k">return</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateFMul</span><span class="p">(</span><span class="n">L</span><span class="p">,</span> <span class="n">R</span><span class="p">,</span> <span class="s">"multmp"</span><span class="p">);</span>
+ <span class="k">case</span> <span class="sc">'<'</span>:
+ <span class="n">L</span> <span class="o">=</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateFCmpULT</span><span class="p">(</span><span class="n">L</span><span class="p">,</span> <span class="n">R</span><span class="p">,</span> <span class="s">"cmptmp"</span><span class="p">);</span>
+ <span class="c1">// Convert bool 0/1 to double 0.0 or 1.0</span>
+ <span class="k">return</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateUIToFP</span><span class="p">(</span><span class="n">L</span><span class="p">,</span> <span class="n">Type</span><span class="o">::</span><span class="n">getDoubleTy</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">()),</span>
+ <span class="s">"booltmp"</span><span class="p">);</span>
+ <span class="nl">default:</span> <span class="k">return</span> <span class="nf">ErrorV</span><span class="p">(</span><span class="s">"invalid binary operator"</span><span class="p">);</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>Binary operators start to get more interesting. The basic idea here is
+that we recursively emit code for the left-hand side of the expression,
+then the right-hand side, then we compute the result of the binary
+expression. In this code, we do a simple switch on the opcode to create
+the right LLVM instruction.</p>
+<p>In the example above, the LLVM builder class is starting to show its
+value. IRBuilder knows where to insert the newly created instruction,
+all you have to do is specify what instruction to create (e.g. with
+<tt class="docutils literal"><span class="pre">CreateFAdd</span></tt>), which operands to use (<tt class="docutils literal"><span class="pre">L</span></tt> and <tt class="docutils literal"><span class="pre">R</span></tt> here) and
+optionally provide a name for the generated instruction.</p>
+<p>One nice thing about LLVM is that the name is just a hint. For instance,
+if the code above emits multiple “addtmp” variables, LLVM will
+automatically provide each one with an increasing, unique numeric
+suffix. Local value names for instructions are purely optional, but it
+makes it much easier to read the IR dumps.</p>
+<p><a class="reference external" href="../LangRef.html#instref">LLVM instructions</a> are constrained by strict
+rules: for example, the Left and Right operators of an <a class="reference external" href="../LangRef.html#i_add">add
+instruction</a> must have the same type, and the
+result type of the add must match the operand types. Because all values
+in Kaleidoscope are doubles, this makes for very simple code for add,
+sub and mul.</p>
+<p>On the other hand, LLVM specifies that the <a class="reference external" href="../LangRef.html#i_fcmp">fcmp
+instruction</a> always returns an ‘i1’ value (a
+one bit integer). The problem with this is that Kaleidoscope wants the
+value to be a 0.0 or 1.0 value. In order to get these semantics, we
+combine the fcmp instruction with a <a class="reference external" href="../LangRef.html#i_uitofp">uitofp
+instruction</a>. This instruction converts its
+input integer into a floating point value by treating the input as an
+unsigned value. In contrast, if we used the <a class="reference external" href="../LangRef.html#i_sitofp">sitofp
+instruction</a>, the Kaleidoscope ‘<’ operator
+would return 0.0 and -1.0, depending on the input value.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">Value</span> <span class="o">*</span><span class="n">CallExprAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="c1">// Look up the name in the global module table.</span>
+ <span class="n">Function</span> <span class="o">*</span><span class="n">CalleeF</span> <span class="o">=</span> <span class="n">TheModule</span><span class="o">-></span><span class="n">getFunction</span><span class="p">(</span><span class="n">Callee</span><span class="p">);</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CalleeF</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">ErrorV</span><span class="p">(</span><span class="s">"Unknown function referenced"</span><span class="p">);</span>
+
+ <span class="c1">// If argument mismatch error.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CalleeF</span><span class="o">-></span><span class="n">arg_size</span><span class="p">()</span> <span class="o">!=</span> <span class="n">Args</span><span class="p">.</span><span class="n">size</span><span class="p">())</span>
+ <span class="k">return</span> <span class="n">ErrorV</span><span class="p">(</span><span class="s">"Incorrect # arguments passed"</span><span class="p">);</span>
+
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">Value</span><span class="o">*></span> <span class="n">ArgsV</span><span class="p">;</span>
+ <span class="k">for</span> <span class="p">(</span><span class="kt">unsigned</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">,</span> <span class="n">e</span> <span class="o">=</span> <span class="n">Args</span><span class="p">.</span><span class="n">size</span><span class="p">();</span> <span class="n">i</span> <span class="o">!=</span> <span class="n">e</span><span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">ArgsV</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">Args</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">-></span><span class="n">Codegen</span><span class="p">());</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">ArgsV</span><span class="p">.</span><span class="n">back</span><span class="p">()</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="k">return</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateCall</span><span class="p">(</span><span class="n">CalleeF</span><span class="p">,</span> <span class="n">ArgsV</span><span class="p">,</span> <span class="s">"calltmp"</span><span class="p">);</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>Code generation for function calls is quite straightforward with LLVM.
+The code above initially does a function name lookup in the LLVM
+Module’s symbol table. Recall that the LLVM Module is the container that
+holds all of the functions we are JIT’ing. By giving each function the
+same name as what the user specifies, we can use the LLVM symbol table
+to resolve function names for us.</p>
+<p>Once we have the function to call, we recursively codegen each argument
+that is to be passed in, and create an LLVM <a class="reference external" href="../LangRef.html#i_call">call
+instruction</a>. Note that LLVM uses the native C
+calling conventions by default, allowing these calls to also call into
+standard library functions like “sin” and “cos”, with no additional
+effort.</p>
+<p>This wraps up our handling of the four basic expressions that we have so
+far in Kaleidoscope. Feel free to go in and add some more. For example,
+by browsing the <a class="reference external" href="../LangRef.html">LLVM language reference</a> you’ll find
+several other interesting instructions that are really easy to plug into
+our basic framework.</p>
+</div>
+<div class="section" id="function-code-generation">
+<h2><a class="toc-backref" href="#id4">3.4. Function Code Generation</a><a class="headerlink" href="#function-code-generation" title="Permalink to this headline">¶</a></h2>
+<p>Code generation for prototypes and functions must handle a number of
+details, which make their code less beautiful than expression code
+generation, but allows us to illustrate some important points. First,
+lets talk about code generation for prototypes: they are used both for
+function bodies and external function declarations. The code starts
+with:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">Function</span> <span class="o">*</span><span class="n">PrototypeAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="c1">// Make the function type: double(double,double) etc.</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">Type</span><span class="o">*></span> <span class="n">Doubles</span><span class="p">(</span><span class="n">Args</span><span class="p">.</span><span class="n">size</span><span class="p">(),</span>
+ <span class="n">Type</span><span class="o">::</span><span class="n">getDoubleTy</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">()));</span>
+ <span class="n">FunctionType</span> <span class="o">*</span><span class="n">FT</span> <span class="o">=</span> <span class="n">FunctionType</span><span class="o">::</span><span class="n">get</span><span class="p">(</span><span class="n">Type</span><span class="o">::</span><span class="n">getDoubleTy</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">()),</span>
+ <span class="n">Doubles</span><span class="p">,</span> <span class="nb">false</span><span class="p">);</span>
+
+ <span class="n">Function</span> <span class="o">*</span><span class="n">F</span> <span class="o">=</span> <span class="n">Function</span><span class="o">::</span><span class="n">Create</span><span class="p">(</span><span class="n">FT</span><span class="p">,</span> <span class="n">Function</span><span class="o">::</span><span class="n">ExternalLinkage</span><span class="p">,</span> <span class="n">Name</span><span class="p">,</span> <span class="n">TheModule</span><span class="p">);</span>
+</pre></div>
+</div>
+<p>This code packs a lot of power into a few lines. Note first that this
+function returns a “Function*” instead of a “Value*”. Because a
+“prototype” really talks about the external interface for a function
+(not the value computed by an expression), it makes sense for it to
+return the LLVM Function it corresponds to when codegen’d.</p>
+<p>The call to <tt class="docutils literal"><span class="pre">FunctionType::get</span></tt> creates the <tt class="docutils literal"><span class="pre">FunctionType</span></tt> that
+should be used for a given Prototype. Since all function arguments in
+Kaleidoscope are of type double, the first line creates a vector of “N”
+LLVM double types. It then uses the <tt class="docutils literal"><span class="pre">Functiontype::get</span></tt> method to
+create a function type that takes “N” doubles as arguments, returns one
+double as a result, and that is not vararg (the false parameter
+indicates this). Note that Types in LLVM are uniqued just like Constants
+are, so you don’t “new” a type, you “get” it.</p>
+<p>The final line above actually creates the function that the prototype
+will correspond to. This indicates the type, linkage and name to use, as
+well as which module to insert into. “<a class="reference external" href="../LangRef.html#linkage">external
+linkage</a>” means that the function may be
+defined outside the current module and/or that it is callable by
+functions outside the module. The Name passed in is the name the user
+specified: since “<tt class="docutils literal"><span class="pre">TheModule</span></tt>” is specified, this name is registered
+in “<tt class="docutils literal"><span class="pre">TheModule</span></tt>“s symbol table, which is used by the function call
+code above.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">// If F conflicted, there was already something named 'Name'. If it has a</span>
+<span class="c1">// body, don't allow redefinition or reextern.</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">F</span><span class="o">-></span><span class="n">getName</span><span class="p">()</span> <span class="o">!=</span> <span class="n">Name</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">// Delete the one we just made and get the existing one.</span>
+ <span class="n">F</span><span class="o">-></span><span class="n">eraseFromParent</span><span class="p">();</span>
+ <span class="n">F</span> <span class="o">=</span> <span class="n">TheModule</span><span class="o">-></span><span class="n">getFunction</span><span class="p">(</span><span class="n">Name</span><span class="p">);</span>
+</pre></div>
+</div>
+<p>The Module symbol table works just like the Function symbol table when
+it comes to name conflicts: if a new function is created with a name
+that was previously added to the symbol table, the new function will get
+implicitly renamed when added to the Module. The code above exploits
+this fact to determine if there was a previous definition of this
+function.</p>
+<p>In Kaleidoscope, I choose to allow redefinitions of functions in two
+cases: first, we want to allow ‘extern’ing a function more than once, as
+long as the prototypes for the externs match (since all arguments have
+the same type, we just have to check that the number of arguments
+match). Second, we want to allow ‘extern’ing a function and then
+defining a body for it. This is useful when defining mutually recursive
+functions.</p>
+<p>In order to implement this, the code above first checks to see if there
+is a collision on the name of the function. If so, it deletes the
+function we just created (by calling <tt class="docutils literal"><span class="pre">eraseFromParent</span></tt>) and then
+calling <tt class="docutils literal"><span class="pre">getFunction</span></tt> to get the existing function with the specified
+name. Note that many APIs in LLVM have “erase” forms and “remove” forms.
+The “remove” form unlinks the object from its parent (e.g. a Function
+from a Module) and returns it. The “erase” form unlinks the object and
+then deletes it.</p>
+<div class="highlight-c++"><div class="highlight"><pre> <span class="c1">// If F already has a body, reject this.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">F</span><span class="o">-></span><span class="n">empty</span><span class="p">())</span> <span class="p">{</span>
+ <span class="n">ErrorF</span><span class="p">(</span><span class="s">"redefinition of function"</span><span class="p">);</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="c1">// If F took a different number of args, reject.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">F</span><span class="o">-></span><span class="n">arg_size</span><span class="p">()</span> <span class="o">!=</span> <span class="n">Args</span><span class="p">.</span><span class="n">size</span><span class="p">())</span> <span class="p">{</span>
+ <span class="n">ErrorF</span><span class="p">(</span><span class="s">"redefinition of function with different # args"</span><span class="p">);</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>In order to verify the logic above, we first check to see if the
+pre-existing function is “empty”. In this case, empty means that it has
+no basic blocks in it, which means it has no body. If it has no body, it
+is a forward declaration. Since we don’t allow anything after a full
+definition of the function, the code rejects this case. If the previous
+reference to a function was an ‘extern’, we simply verify that the
+number of arguments for that definition and this one match up. If not,
+we emit an error.</p>
+<div class="highlight-c++"><div class="highlight"><pre> <span class="c1">// Set names for all arguments.</span>
+ <span class="kt">unsigned</span> <span class="n">Idx</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="k">for</span> <span class="p">(</span><span class="n">Function</span><span class="o">::</span><span class="n">arg_iterator</span> <span class="n">AI</span> <span class="o">=</span> <span class="n">F</span><span class="o">-></span><span class="n">arg_begin</span><span class="p">();</span> <span class="n">Idx</span> <span class="o">!=</span> <span class="n">Args</span><span class="p">.</span><span class="n">size</span><span class="p">();</span>
+ <span class="o">++</span><span class="n">AI</span><span class="p">,</span> <span class="o">++</span><span class="n">Idx</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">AI</span><span class="o">-></span><span class="n">setName</span><span class="p">(</span><span class="n">Args</span><span class="p">[</span><span class="n">Idx</span><span class="p">]);</span>
+
+ <span class="c1">// Add arguments to variable symbol table.</span>
+ <span class="n">NamedValues</span><span class="p">[</span><span class="n">Args</span><span class="p">[</span><span class="n">Idx</span><span class="p">]]</span> <span class="o">=</span> <span class="n">AI</span><span class="p">;</span>
+ <span class="p">}</span>
+ <span class="k">return</span> <span class="n">F</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>The last bit of code for prototypes loops over all of the arguments in
+the function, setting the name of the LLVM Argument objects to match,
+and registering the arguments in the <tt class="docutils literal"><span class="pre">NamedValues</span></tt> map for future use
+by the <tt class="docutils literal"><span class="pre">VariableExprAST</span></tt> AST node. Once this is set up, it returns the
+Function object to the caller. Note that we don’t check for conflicting
+argument names here (e.g. “extern foo(a b a)”). Doing so would be very
+straight-forward with the mechanics we have already used above.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">Function</span> <span class="o">*</span><span class="n">FunctionAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">NamedValues</span><span class="p">.</span><span class="n">clear</span><span class="p">();</span>
+
+ <span class="n">Function</span> <span class="o">*</span><span class="n">TheFunction</span> <span class="o">=</span> <span class="n">Proto</span><span class="o">-></span><span class="n">Codegen</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">TheFunction</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>Code generation for function definitions starts out simply enough: we
+just codegen the prototype (Proto) and verify that it is ok. We then
+clear out the <tt class="docutils literal"><span class="pre">NamedValues</span></tt> map to make sure that there isn’t anything
+in it from the last function we compiled. Code generation of the
+prototype ensures that there is an LLVM Function object that is ready to
+go for us.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">// Create a new basic block to start insertion into.</span>
+<span class="n">BasicBlock</span> <span class="o">*</span><span class="n">BB</span> <span class="o">=</span> <span class="n">BasicBlock</span><span class="o">::</span><span class="n">Create</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">(),</span> <span class="s">"entry"</span><span class="p">,</span> <span class="n">TheFunction</span><span class="p">);</span>
+<span class="n">Builder</span><span class="p">.</span><span class="n">SetInsertPoint</span><span class="p">(</span><span class="n">BB</span><span class="p">);</span>
+
+<span class="k">if</span> <span class="p">(</span><span class="n">Value</span> <span class="o">*</span><span class="n">RetVal</span> <span class="o">=</span> <span class="n">Body</span><span class="o">-></span><span class="n">Codegen</span><span class="p">())</span> <span class="p">{</span>
+</pre></div>
+</div>
+<p>Now we get to the point where the <tt class="docutils literal"><span class="pre">Builder</span></tt> is set up. The first line
+creates a new <a class="reference external" href="http://en.wikipedia.org/wiki/Basic_block">basic block</a>
+(named “entry”), which is inserted into <tt class="docutils literal"><span class="pre">TheFunction</span></tt>. The second line
+then tells the builder that new instructions should be inserted into the
+end of the new basic block. Basic blocks in LLVM are an important part
+of functions that define the <a class="reference external" href="http://en.wikipedia.org/wiki/Control_flow_graph">Control Flow
+Graph</a>. Since we
+don’t have any control flow, our functions will only contain one block
+at this point. We’ll fix this in <a class="reference external" href="LangImpl5.html">Chapter 5</a> :).</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">if</span> <span class="p">(</span><span class="n">Value</span> <span class="o">*</span><span class="n">RetVal</span> <span class="o">=</span> <span class="n">Body</span><span class="o">-></span><span class="n">Codegen</span><span class="p">())</span> <span class="p">{</span>
+ <span class="c1">// Finish off the function.</span>
+ <span class="n">Builder</span><span class="p">.</span><span class="n">CreateRet</span><span class="p">(</span><span class="n">RetVal</span><span class="p">);</span>
+
+ <span class="c1">// Validate the generated code, checking for consistency.</span>
+ <span class="n">verifyFunction</span><span class="p">(</span><span class="o">*</span><span class="n">TheFunction</span><span class="p">);</span>
+
+ <span class="k">return</span> <span class="n">TheFunction</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>Once the insertion point is set up, we call the <tt class="docutils literal"><span class="pre">CodeGen()</span></tt> method for
+the root expression of the function. If no error happens, this emits
+code to compute the expression into the entry block and returns the
+value that was computed. Assuming no error, we then create an LLVM <a class="reference external" href="../LangRef.html#i_ret">ret
+instruction</a>, which completes the function.
+Once the function is built, we call <tt class="docutils literal"><span class="pre">verifyFunction</span></tt>, which is
+provided by LLVM. This function does a variety of consistency checks on
+the generated code, to determine if our compiler is doing everything
+right. Using this is important: it can catch a lot of bugs. Once the
+function is finished and validated, we return it.</p>
+<div class="highlight-c++"><div class="highlight"><pre> <span class="c1">// Error reading body, remove function.</span>
+ <span class="n">TheFunction</span><span class="o">-></span><span class="n">eraseFromParent</span><span class="p">();</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>The only piece left here is handling of the error case. For simplicity,
+we handle this by merely deleting the function we produced with the
+<tt class="docutils literal"><span class="pre">eraseFromParent</span></tt> method. This allows the user to redefine a function
+that they incorrectly typed in before: if we didn’t delete it, it would
+live in the symbol table, with a body, preventing future redefinition.</p>
+<p>This code does have a bug, though. Since the <tt class="docutils literal"><span class="pre">PrototypeAST::Codegen</span></tt>
+can return a previously defined forward declaration, our code can
+actually delete a forward declaration. There are a number of ways to fix
+this bug, see what you can come up with! Here is a testcase:</p>
+<div class="highlight-python"><div class="highlight"><pre>extern foo(a b); # ok, defines foo.
+def foo(a b) c; # error, 'c' is invalid.
+def bar() foo(1, 2); # error, unknown function "foo"
+</pre></div>
+</div>
+</div>
+<div class="section" id="driver-changes-and-closing-thoughts">
+<h2><a class="toc-backref" href="#id5">3.5. Driver Changes and Closing Thoughts</a><a class="headerlink" href="#driver-changes-and-closing-thoughts" title="Permalink to this headline">¶</a></h2>
+<p>For now, code generation to LLVM doesn’t really get us much, except that
+we can look at the pretty IR calls. The sample code inserts calls to
+Codegen into the “<tt class="docutils literal"><span class="pre">HandleDefinition</span></tt>”, “<tt class="docutils literal"><span class="pre">HandleExtern</span></tt>” etc
+functions, and then dumps out the LLVM IR. This gives a nice way to look
+at the LLVM IR for simple functions. For example:</p>
+<div class="highlight-python"><div class="highlight"><pre>ready> 4+5;
+Read top-level expression:
+define double @0() {
+entry:
+ ret double 9.000000e+00
+}
+</pre></div>
+</div>
+<p>Note how the parser turns the top-level expression into anonymous
+functions for us. This will be handy when we add <a class="reference external" href="LangImpl4.html#jit">JIT
+support</a> in the next chapter. Also note that the
+code is very literally transcribed, no optimizations are being performed
+except simple constant folding done by IRBuilder. We will <a class="reference external" href="LangImpl4.html#trivialconstfold">add
+optimizations</a> explicitly in the next
+chapter.</p>
+<div class="highlight-python"><div class="highlight"><pre>ready> def foo(a b) a*a + 2*a*b + b*b;
+Read function definition:
+define double @foo(double %a, double %b) {
+entry:
+ %multmp = fmul double %a, %a
+ %multmp1 = fmul double 2.000000e+00, %a
+ %multmp2 = fmul double %multmp1, %b
+ %addtmp = fadd double %multmp, %multmp2
+ %multmp3 = fmul double %b, %b
+ %addtmp4 = fadd double %addtmp, %multmp3
+ ret double %addtmp4
+}
+</pre></div>
+</div>
+<p>This shows some simple arithmetic. Notice the striking similarity to the
+LLVM builder calls that we use to create the instructions.</p>
+<div class="highlight-python"><div class="highlight"><pre>ready> def bar(a) foo(a, 4.0) + bar(31337);
+Read function definition:
+define double @bar(double %a) {
+entry:
+ %calltmp = call double @foo(double %a, double 4.000000e+00)
+ %calltmp1 = call double @bar(double 3.133700e+04)
+ %addtmp = fadd double %calltmp, %calltmp1
+ ret double %addtmp
+}
+</pre></div>
+</div>
+<p>This shows some function calls. Note that this function will take a long
+time to execute if you call it. In the future we’ll add conditional
+control flow to actually make recursion useful :).</p>
+<div class="highlight-python"><div class="highlight"><pre>ready> extern cos(x);
+Read extern:
+declare double @cos(double)
+
+ready> cos(1.234);
+Read top-level expression:
+define double @1() {
+entry:
+ %calltmp = call double @cos(double 1.234000e+00)
+ ret double %calltmp
+}
+</pre></div>
+</div>
+<p>This shows an extern for the libm “cos” function, and a call to it.</p>
+<div class="highlight-python"><div class="highlight"><pre>ready> ^D
+; ModuleID = 'my cool jit'
+
+define double @0() {
+entry:
+ %addtmp = fadd double 4.000000e+00, 5.000000e+00
+ ret double %addtmp
+}
+
+define double @foo(double %a, double %b) {
+entry:
+ %multmp = fmul double %a, %a
+ %multmp1 = fmul double 2.000000e+00, %a
+ %multmp2 = fmul double %multmp1, %b
+ %addtmp = fadd double %multmp, %multmp2
+ %multmp3 = fmul double %b, %b
+ %addtmp4 = fadd double %addtmp, %multmp3
+ ret double %addtmp4
+}
+
+define double @bar(double %a) {
+entry:
+ %calltmp = call double @foo(double %a, double 4.000000e+00)
+ %calltmp1 = call double @bar(double 3.133700e+04)
+ %addtmp = fadd double %calltmp, %calltmp1
+ ret double %addtmp
+}
+
+declare double @cos(double)
+
+define double @1() {
+entry:
+ %calltmp = call double @cos(double 1.234000e+00)
+ ret double %calltmp
+}
+</pre></div>
+</div>
+<p>When you quit the current demo, it dumps out the IR for the entire
+module generated. Here you can see the big picture with all the
+functions referencing each other.</p>
+<p>This wraps up the third chapter of the Kaleidoscope tutorial. Up next,
+we’ll describe how to <a class="reference external" href="LangImpl4.html">add JIT codegen and optimizer
+support</a> to this so we can actually start running
+code!</p>
+</div>
+<div class="section" id="full-code-listing">
+<h2><a class="toc-backref" href="#id6">3.6. 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, enhanced with
+the LLVM code generator. Because this uses the LLVM libraries, we need
+to link them in. To do this, we use the
+<a class="reference external" href="http://llvm.org/cmds/llvm-config.html">llvm-config</a> tool to inform
+our makefile/command line about which options to use:</p>
+<div class="highlight-bash"><div class="highlight"><pre><span class="c"># Compile</span>
+clang++ -g -O3 toy.cpp <span class="sb">`</span>llvm-config --cxxflags --ldflags --system-libs --libs core<span class="sb">`</span> -o toy
+<span class="c"># Run</span>
+./toy
+</pre></div>
+</div>
+<p>Here is the code:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="cp">#include "llvm/IR/Verifier.h"</span>
+<span class="cp">#include "llvm/IR/DerivedTypes.h"</span>
+<span class="cp">#include "llvm/IR/IRBuilder.h"</span>
+<span class="cp">#include "llvm/IR/LLVMContext.h"</span>
+<span class="cp">#include "llvm/IR/Module.h"</span>
+<span class="cp">#include <cctype></span>
+<span class="cp">#include <cstdio></span>
+<span class="cp">#include <map></span>
+<span class="cp">#include <string></span>
+<span class="cp">#include <vector></span>
+<span class="k">using</span> <span class="k">namespace</span> <span class="n">llvm</span><span class="p">;</span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// Lexer</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+
+<span class="c1">// The lexer returns tokens [0-255] if it is an unknown character, otherwise one</span>
+<span class="c1">// of these for known things.</span>
+<span class="k">enum</span> <span class="n">Token</span> <span class="p">{</span>
+ <span class="n">tok_eof</span> <span class="o">=</span> <span class="o">-</span><span class="mi">1</span><span class="p">,</span>
+
+ <span class="c1">// commands</span>
+ <span class="n">tok_def</span> <span class="o">=</span> <span class="o">-</span><span class="mi">2</span><span class="p">,</span> <span class="n">tok_extern</span> <span class="o">=</span> <span class="o">-</span><span class="mi">3</span><span class="p">,</span>
+
+ <span class="c1">// primary</span>
+ <span class="n">tok_identifier</span> <span class="o">=</span> <span class="o">-</span><span class="mi">4</span><span class="p">,</span> <span class="n">tok_number</span> <span class="o">=</span> <span class="o">-</span><span class="mi">5</span>
+<span class="p">};</span>
+
+<span class="k">static</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">IdentifierStr</span><span class="p">;</span> <span class="c1">// Filled in if tok_identifier</span>
+<span class="k">static</span> <span class="kt">double</span> <span class="n">NumVal</span><span class="p">;</span> <span class="c1">// Filled in if tok_number</span>
+
+<span class="c1">/// gettok - Return the next token from standard input.</span>
+<span class="k">static</span> <span class="kt">int</span> <span class="nf">gettok</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">static</span> <span class="kt">int</span> <span class="n">LastChar</span> <span class="o">=</span> <span class="sc">' '</span><span class="p">;</span>
+
+ <span class="c1">// Skip any whitespace.</span>
+ <span class="k">while</span> <span class="p">(</span><span class="n">isspace</span><span class="p">(</span><span class="n">LastChar</span><span class="p">))</span>
+ <span class="n">LastChar</span> <span class="o">=</span> <span class="n">getchar</span><span class="p">();</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">isalpha</span><span class="p">(</span><span class="n">LastChar</span><span class="p">))</span> <span class="p">{</span> <span class="c1">// identifier: [a-zA-Z][a-zA-Z0-9]*</span>
+ <span class="n">IdentifierStr</span> <span class="o">=</span> <span class="n">LastChar</span><span class="p">;</span>
+ <span class="k">while</span> <span class="p">(</span><span class="n">isalnum</span><span class="p">((</span><span class="n">LastChar</span> <span class="o">=</span> <span class="n">getchar</span><span class="p">())))</span>
+ <span class="n">IdentifierStr</span> <span class="o">+=</span> <span class="n">LastChar</span><span class="p">;</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"def"</span><span class="p">)</span> <span class="k">return</span> <span class="n">tok_def</span><span class="p">;</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"extern"</span><span class="p">)</span> <span class="k">return</span> <span class="n">tok_extern</span><span class="p">;</span>
+ <span class="k">return</span> <span class="n">tok_identifier</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">isdigit</span><span class="p">(</span><span class="n">LastChar</span><span class="p">)</span> <span class="o">||</span> <span class="n">LastChar</span> <span class="o">==</span> <span class="sc">'.'</span><span class="p">)</span> <span class="p">{</span> <span class="c1">// Number: [0-9.]+</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">NumStr</span><span class="p">;</span>
+ <span class="k">do</span> <span class="p">{</span>
+ <span class="n">NumStr</span> <span class="o">+=</span> <span class="n">LastChar</span><span class="p">;</span>
+ <span class="n">LastChar</span> <span class="o">=</span> <span class="n">getchar</span><span class="p">();</span>
+ <span class="p">}</span> <span class="k">while</span> <span class="p">(</span><span class="n">isdigit</span><span class="p">(</span><span class="n">LastChar</span><span class="p">)</span> <span class="o">||</span> <span class="n">LastChar</span> <span class="o">==</span> <span class="sc">'.'</span><span class="p">);</span>
+
+ <span class="n">NumVal</span> <span class="o">=</span> <span class="n">strtod</span><span class="p">(</span><span class="n">NumStr</span><span class="p">.</span><span class="n">c_str</span><span class="p">(),</span> <span class="mi">0</span><span class="p">);</span>
+ <span class="k">return</span> <span class="n">tok_number</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">LastChar</span> <span class="o">==</span> <span class="sc">'#'</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">// Comment until end of line.</span>
+ <span class="k">do</span> <span class="n">LastChar</span> <span class="o">=</span> <span class="n">getchar</span><span class="p">();</span>
+ <span class="k">while</span> <span class="p">(</span><span class="n">LastChar</span> <span class="o">!=</span> <span class="n">EOF</span> <span class="o">&&</span> <span class="n">LastChar</span> <span class="o">!=</span> <span class="sc">'\n'</span> <span class="o">&&</span> <span class="n">LastChar</span> <span class="o">!=</span> <span class="sc">'\r'</span><span class="p">);</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">LastChar</span> <span class="o">!=</span> <span class="n">EOF</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">gettok</span><span class="p">();</span>
+ <span class="p">}</span>
+
+ <span class="c1">// Check for end of file. Don't eat the EOF.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">LastChar</span> <span class="o">==</span> <span class="n">EOF</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">tok_eof</span><span class="p">;</span>
+
+ <span class="c1">// Otherwise, just return the character as its ascii value.</span>
+ <span class="kt">int</span> <span class="n">ThisChar</span> <span class="o">=</span> <span class="n">LastChar</span><span class="p">;</span>
+ <span class="n">LastChar</span> <span class="o">=</span> <span class="n">getchar</span><span class="p">();</span>
+ <span class="k">return</span> <span class="n">ThisChar</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// Abstract Syntax Tree (aka Parse Tree)</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="k">namespace</span> <span class="p">{</span>
+<span class="c1">/// ExprAST - Base class for all expression nodes.</span>
+<span class="k">class</span> <span class="nc">ExprAST</span> <span class="p">{</span>
+<span class="nl">public:</span>
+ <span class="k">virtual</span> <span class="o">~</span><span class="n">ExprAST</span><span class="p">()</span> <span class="p">{}</span>
+ <span class="k">virtual</span> <span class="n">Value</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">()</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="c1">/// NumberExprAST - Expression class for numeric literals like "1.0".</span>
+<span class="k">class</span> <span class="nc">NumberExprAST</span> <span class="o">:</span> <span class="k">public</span> <span class="n">ExprAST</span> <span class="p">{</span>
+ <span class="kt">double</span> <span class="n">Val</span><span class="p">;</span>
+<span class="nl">public:</span>
+ <span class="n">NumberExprAST</span><span class="p">(</span><span class="kt">double</span> <span class="n">val</span><span class="p">)</span> <span class="o">:</span> <span class="n">Val</span><span class="p">(</span><span class="n">val</span><span class="p">)</span> <span class="p">{}</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">()</span> <span class="n">override</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="c1">/// VariableExprAST - Expression class for referencing a variable, like "a".</span>
+<span class="k">class</span> <span class="nc">VariableExprAST</span> <span class="o">:</span> <span class="k">public</span> <span class="n">ExprAST</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">Name</span><span class="p">;</span>
+<span class="nl">public:</span>
+ <span class="n">VariableExprAST</span><span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="o">&</span><span class="n">name</span><span class="p">)</span> <span class="o">:</span> <span class="n">Name</span><span class="p">(</span><span class="n">name</span><span class="p">)</span> <span class="p">{}</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">()</span> <span class="n">override</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="c1">/// BinaryExprAST - Expression class for a binary operator.</span>
+<span class="k">class</span> <span class="nc">BinaryExprAST</span> <span class="o">:</span> <span class="k">public</span> <span class="n">ExprAST</span> <span class="p">{</span>
+ <span class="kt">char</span> <span class="n">Op</span><span class="p">;</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">LHS</span><span class="p">,</span> <span class="o">*</span><span class="n">RHS</span><span class="p">;</span>
+<span class="nl">public:</span>
+ <span class="n">BinaryExprAST</span><span class="p">(</span><span class="kt">char</span> <span class="n">op</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">lhs</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">rhs</span><span class="p">)</span>
+ <span class="o">:</span> <span class="n">Op</span><span class="p">(</span><span class="n">op</span><span class="p">),</span> <span class="n">LHS</span><span class="p">(</span><span class="n">lhs</span><span class="p">),</span> <span class="n">RHS</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span> <span class="p">{}</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">()</span> <span class="n">override</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="c1">/// CallExprAST - Expression class for function calls.</span>
+<span class="k">class</span> <span class="nc">CallExprAST</span> <span class="o">:</span> <span class="k">public</span> <span class="n">ExprAST</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">Callee</span><span class="p">;</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">ExprAST</span><span class="o">*></span> <span class="n">Args</span><span class="p">;</span>
+<span class="nl">public:</span>
+ <span class="n">CallExprAST</span><span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="o">&</span><span class="n">callee</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">ExprAST</span><span class="o">*></span> <span class="o">&</span><span class="n">args</span><span class="p">)</span>
+ <span class="o">:</span> <span class="n">Callee</span><span class="p">(</span><span class="n">callee</span><span class="p">),</span> <span class="n">Args</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="p">{}</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">()</span> <span class="n">override</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="c1">/// PrototypeAST - This class represents the "prototype" for a function,</span>
+<span class="c1">/// which captures its name, and its argument names (thus implicitly the number</span>
+<span class="c1">/// of arguments the function takes).</span>
+<span class="k">class</span> <span class="nc">PrototypeAST</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">Name</span><span class="p">;</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span> <span class="n">Args</span><span class="p">;</span>
+<span class="nl">public:</span>
+ <span class="n">PrototypeAST</span><span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="o">&</span><span class="n">name</span><span class="p">,</span> <span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span> <span class="o">&</span><span class="n">args</span><span class="p">)</span>
+ <span class="o">:</span> <span class="n">Name</span><span class="p">(</span><span class="n">name</span><span class="p">),</span> <span class="n">Args</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="p">{}</span>
+
+ <span class="n">Function</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">();</span>
+<span class="p">};</span>
+
+<span class="c1">/// FunctionAST - This class represents a function definition itself.</span>
+<span class="k">class</span> <span class="nc">FunctionAST</span> <span class="p">{</span>
+ <span class="n">PrototypeAST</span> <span class="o">*</span><span class="n">Proto</span><span class="p">;</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Body</span><span class="p">;</span>
+<span class="nl">public:</span>
+ <span class="n">FunctionAST</span><span class="p">(</span><span class="n">PrototypeAST</span> <span class="o">*</span><span class="n">proto</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">body</span><span class="p">)</span>
+ <span class="o">:</span> <span class="n">Proto</span><span class="p">(</span><span class="n">proto</span><span class="p">),</span> <span class="n">Body</span><span class="p">(</span><span class="n">body</span><span class="p">)</span> <span class="p">{}</span>
+
+ <span class="n">Function</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">();</span>
+<span class="p">};</span>
+<span class="p">}</span> <span class="c1">// end anonymous namespace</span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// Parser</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+
+<span class="c1">/// CurTok/getNextToken - Provide a simple token buffer. CurTok is the current</span>
+<span class="c1">/// token the parser is looking at. getNextToken reads another token from the</span>
+<span class="c1">/// lexer and updates CurTok with its results.</span>
+<span class="k">static</span> <span class="kt">int</span> <span class="n">CurTok</span><span class="p">;</span>
+<span class="k">static</span> <span class="kt">int</span> <span class="nf">getNextToken</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="n">CurTok</span> <span class="o">=</span> <span class="n">gettok</span><span class="p">();</span>
+<span class="p">}</span>
+
+<span class="c1">/// BinopPrecedence - This holds the precedence for each binary operator that is</span>
+<span class="c1">/// defined.</span>
+<span class="k">static</span> <span class="n">std</span><span class="o">::</span><span class="n">map</span><span class="o"><</span><span class="kt">char</span><span class="p">,</span> <span class="kt">int</span><span class="o">></span> <span class="n">BinopPrecedence</span><span class="p">;</span>
+
+<span class="c1">/// GetTokPrecedence - Get the precedence of the pending binary operator token.</span>
+<span class="k">static</span> <span class="kt">int</span> <span class="nf">GetTokPrecedence</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">isascii</span><span class="p">(</span><span class="n">CurTok</span><span class="p">))</span>
+ <span class="k">return</span> <span class="o">-</span><span class="mi">1</span><span class="p">;</span>
+
+ <span class="c1">// Make sure it's a declared binop.</span>
+ <span class="kt">int</span> <span class="n">TokPrec</span> <span class="o">=</span> <span class="n">BinopPrecedence</span><span class="p">[</span><span class="n">CurTok</span><span class="p">];</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">TokPrec</span> <span class="o"><=</span> <span class="mi">0</span><span class="p">)</span> <span class="k">return</span> <span class="o">-</span><span class="mi">1</span><span class="p">;</span>
+ <span class="k">return</span> <span class="n">TokPrec</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">/// Error* - These are little helper functions for error handling.</span>
+<span class="n">ExprAST</span> <span class="o">*</span><span class="nf">Error</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">Str</span><span class="p">)</span> <span class="p">{</span> <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"Error: %s</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">Str</span><span class="p">);</span><span class="k">return</span> <span class="mi">0</span><span class="p">;}</span>
+<span class="n">PrototypeAST</span> <span class="o">*</span><span class="nf">ErrorP</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">Str</span><span class="p">)</span> <span class="p">{</span> <span class="n">Error</span><span class="p">(</span><span class="n">Str</span><span class="p">);</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span> <span class="p">}</span>
+<span class="n">FunctionAST</span> <span class="o">*</span><span class="nf">ErrorF</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">Str</span><span class="p">)</span> <span class="p">{</span> <span class="n">Error</span><span class="p">(</span><span class="n">Str</span><span class="p">);</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span> <span class="p">}</span>
+
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseExpression</span><span class="p">();</span>
+
+<span class="c1">/// identifierexpr</span>
+<span class="c1">/// ::= identifier</span>
+<span class="c1">/// ::= identifier '(' expression* ')'</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseIdentifierExpr</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">IdName</span> <span class="o">=</span> <span class="n">IdentifierStr</span><span class="p">;</span>
+
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat identifier.</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">'('</span><span class="p">)</span> <span class="c1">// Simple variable ref.</span>
+ <span class="k">return</span> <span class="k">new</span> <span class="n">VariableExprAST</span><span class="p">(</span><span class="n">IdName</span><span class="p">);</span>
+
+ <span class="c1">// Call.</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat (</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">ExprAST</span><span class="o">*></span> <span class="n">Args</span><span class="p">;</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">')'</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">while</span> <span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Arg</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">Arg</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="n">Args</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">Arg</span><span class="p">);</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">==</span> <span class="sc">')'</span><span class="p">)</span> <span class="k">break</span><span class="p">;</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">','</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"Expected ')' or ',' in argument list"</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+
+ <span class="c1">// Eat the ')'.</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+
+ <span class="k">return</span> <span class="k">new</span> <span class="n">CallExprAST</span><span class="p">(</span><span class="n">IdName</span><span class="p">,</span> <span class="n">Args</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="c1">/// numberexpr ::= number</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseNumberExpr</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Result</span> <span class="o">=</span> <span class="k">new</span> <span class="n">NumberExprAST</span><span class="p">(</span><span class="n">NumVal</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// consume the number</span>
+ <span class="k">return</span> <span class="n">Result</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">/// parenexpr ::= '(' expression ')'</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseParenExpr</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat (.</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">V</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">V</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">')'</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"expected ')'"</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat ).</span>
+ <span class="k">return</span> <span class="n">V</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">/// primary</span>
+<span class="c1">/// ::= identifierexpr</span>
+<span class="c1">/// ::= numberexpr</span>
+<span class="c1">/// ::= parenexpr</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParsePrimary</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">switch</span> <span class="p">(</span><span class="n">CurTok</span><span class="p">)</span> <span class="p">{</span>
+ <span class="nl">default:</span> <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"unknown token when expecting an expression"</span><span class="p">);</span>
+ <span class="k">case</span> <span class="n">tok_identifier</span>: <span class="k">return</span> <span class="n">ParseIdentifierExpr</span><span class="p">();</span>
+ <span class="k">case</span> <span class="n">tok_number</span>: <span class="k">return</span> <span class="n">ParseNumberExpr</span><span class="p">();</span>
+ <span class="k">case</span> <span class="sc">'('</span>: <span class="k">return</span> <span class="n">ParseParenExpr</span><span class="p">();</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="c1">/// binoprhs</span>
+<span class="c1">/// ::= ('+' primary)*</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseBinOpRHS</span><span class="p">(</span><span class="kt">int</span> <span class="n">ExprPrec</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">LHS</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">// If this is a binop, find its precedence.</span>
+ <span class="k">while</span> <span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
+ <span class="kt">int</span> <span class="n">TokPrec</span> <span class="o">=</span> <span class="n">GetTokPrecedence</span><span class="p">();</span>
+
+ <span class="c1">// If this is a binop that binds at least as tightly as the current binop,</span>
+ <span class="c1">// consume it, otherwise we are done.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">TokPrec</span> <span class="o"><</span> <span class="n">ExprPrec</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">LHS</span><span class="p">;</span>
+
+ <span class="c1">// Okay, we know this is a binop.</span>
+ <span class="kt">int</span> <span class="n">BinOp</span> <span class="o">=</span> <span class="n">CurTok</span><span class="p">;</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat binop</span>
+
+ <span class="c1">// Parse the primary expression after the binary operator.</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">RHS</span> <span class="o">=</span> <span class="n">ParsePrimary</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">RHS</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="c1">// If BinOp binds less tightly with RHS than the operator after RHS, let</span>
+ <span class="c1">// the pending operator take RHS as its LHS.</span>
+ <span class="kt">int</span> <span class="n">NextPrec</span> <span class="o">=</span> <span class="n">GetTokPrecedence</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">TokPrec</span> <span class="o"><</span> <span class="n">NextPrec</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">RHS</span> <span class="o">=</span> <span class="n">ParseBinOpRHS</span><span class="p">(</span><span class="n">TokPrec</span><span class="o">+</span><span class="mi">1</span><span class="p">,</span> <span class="n">RHS</span><span class="p">);</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">RHS</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="c1">// Merge LHS/RHS.</span>
+ <span class="n">LHS</span> <span class="o">=</span> <span class="k">new</span> <span class="n">BinaryExprAST</span><span class="p">(</span><span class="n">BinOp</span><span class="p">,</span> <span class="n">LHS</span><span class="p">,</span> <span class="n">RHS</span><span class="p">);</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="c1">/// expression</span>
+<span class="c1">/// ::= primary binoprhs</span>
+<span class="c1">///</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseExpression</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">LHS</span> <span class="o">=</span> <span class="n">ParsePrimary</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">LHS</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">return</span> <span class="n">ParseBinOpRHS</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="n">LHS</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="c1">/// prototype</span>
+<span class="c1">/// ::= id '(' id* ')'</span>
+<span class="k">static</span> <span class="n">PrototypeAST</span> <span class="o">*</span><span class="nf">ParsePrototype</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="n">tok_identifier</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">ErrorP</span><span class="p">(</span><span class="s">"Expected function name in prototype"</span><span class="p">);</span>
+
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">FnName</span> <span class="o">=</span> <span class="n">IdentifierStr</span><span class="p">;</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">'('</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">ErrorP</span><span class="p">(</span><span class="s">"Expected '(' in prototype"</span><span class="p">);</span>
+
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span> <span class="n">ArgNames</span><span class="p">;</span>
+ <span class="k">while</span> <span class="p">(</span><span class="n">getNextToken</span><span class="p">()</span> <span class="o">==</span> <span class="n">tok_identifier</span><span class="p">)</span>
+ <span class="n">ArgNames</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">IdentifierStr</span><span class="p">);</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">')'</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">ErrorP</span><span class="p">(</span><span class="s">"Expected ')' in prototype"</span><span class="p">);</span>
+
+ <span class="c1">// success.</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat ')'.</span>
+
+ <span class="k">return</span> <span class="k">new</span> <span class="n">PrototypeAST</span><span class="p">(</span><span class="n">FnName</span><span class="p">,</span> <span class="n">ArgNames</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="c1">/// definition ::= 'def' prototype expression</span>
+<span class="k">static</span> <span class="n">FunctionAST</span> <span class="o">*</span><span class="nf">ParseDefinition</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat def.</span>
+ <span class="n">PrototypeAST</span> <span class="o">*</span><span class="n">Proto</span> <span class="o">=</span> <span class="n">ParsePrototype</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">Proto</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">ExprAST</span> <span class="o">*</span><span class="n">E</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">())</span>
+ <span class="k">return</span> <span class="k">new</span> <span class="n">FunctionAST</span><span class="p">(</span><span class="n">Proto</span><span class="p">,</span> <span class="n">E</span><span class="p">);</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">/// toplevelexpr ::= expression</span>
+<span class="k">static</span> <span class="n">FunctionAST</span> <span class="o">*</span><span class="nf">ParseTopLevelExpr</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">ExprAST</span> <span class="o">*</span><span class="n">E</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">())</span> <span class="p">{</span>
+ <span class="c1">// Make an anonymous proto.</span>
+ <span class="n">PrototypeAST</span> <span class="o">*</span><span class="n">Proto</span> <span class="o">=</span> <span class="k">new</span> <span class="n">PrototypeAST</span><span class="p">(</span><span class="s">""</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span><span class="p">());</span>
+ <span class="k">return</span> <span class="k">new</span> <span class="n">FunctionAST</span><span class="p">(</span><span class="n">Proto</span><span class="p">,</span> <span class="n">E</span><span class="p">);</span>
+ <span class="p">}</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">/// external ::= 'extern' prototype</span>
+<span class="k">static</span> <span class="n">PrototypeAST</span> <span class="o">*</span><span class="nf">ParseExtern</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat extern.</span>
+ <span class="k">return</span> <span class="n">ParsePrototype</span><span class="p">();</span>
+<span class="p">}</span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// Code Generation</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+
+<span class="k">static</span> <span class="n">Module</span> <span class="o">*</span><span class="n">TheModule</span><span class="p">;</span>
+<span class="k">static</span> <span class="n">IRBuilder</span><span class="o"><></span> <span class="n">Builder</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">());</span>
+<span class="k">static</span> <span class="n">std</span><span class="o">::</span><span class="n">map</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">,</span> <span class="n">Value</span><span class="o">*></span> <span class="n">NamedValues</span><span class="p">;</span>
+
+<span class="n">Value</span> <span class="o">*</span><span class="nf">ErrorV</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">Str</span><span class="p">)</span> <span class="p">{</span> <span class="n">Error</span><span class="p">(</span><span class="n">Str</span><span class="p">);</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span> <span class="p">}</span>
+
+<span class="n">Value</span> <span class="o">*</span><span class="n">NumberExprAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="n">ConstantFP</span><span class="o">::</span><span class="n">get</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">(),</span> <span class="n">APFloat</span><span class="p">(</span><span class="n">Val</span><span class="p">));</span>
+<span class="p">}</span>
+
+<span class="n">Value</span> <span class="o">*</span><span class="n">VariableExprAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="c1">// Look this variable up in the function.</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">V</span> <span class="o">=</span> <span class="n">NamedValues</span><span class="p">[</span><span class="n">Name</span><span class="p">];</span>
+ <span class="k">return</span> <span class="n">V</span> <span class="o">?</span> <span class="n">V</span> <span class="o">:</span> <span class="n">ErrorV</span><span class="p">(</span><span class="s">"Unknown variable name"</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="n">Value</span> <span class="o">*</span><span class="n">BinaryExprAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">L</span> <span class="o">=</span> <span class="n">LHS</span><span class="o">-></span><span class="n">Codegen</span><span class="p">();</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">R</span> <span class="o">=</span> <span class="n">RHS</span><span class="o">-></span><span class="n">Codegen</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">L</span> <span class="o">==</span> <span class="mi">0</span> <span class="o">||</span> <span class="n">R</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">switch</span> <span class="p">(</span><span class="n">Op</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">case</span> <span class="sc">'+'</span>: <span class="k">return</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateFAdd</span><span class="p">(</span><span class="n">L</span><span class="p">,</span> <span class="n">R</span><span class="p">,</span> <span class="s">"addtmp"</span><span class="p">);</span>
+ <span class="k">case</span> <span class="sc">'-'</span>: <span class="k">return</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateFSub</span><span class="p">(</span><span class="n">L</span><span class="p">,</span> <span class="n">R</span><span class="p">,</span> <span class="s">"subtmp"</span><span class="p">);</span>
+ <span class="k">case</span> <span class="sc">'*'</span>: <span class="k">return</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateFMul</span><span class="p">(</span><span class="n">L</span><span class="p">,</span> <span class="n">R</span><span class="p">,</span> <span class="s">"multmp"</span><span class="p">);</span>
+ <span class="k">case</span> <span class="sc">'<'</span>:
+ <span class="n">L</span> <span class="o">=</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateFCmpULT</span><span class="p">(</span><span class="n">L</span><span class="p">,</span> <span class="n">R</span><span class="p">,</span> <span class="s">"cmptmp"</span><span class="p">);</span>
+ <span class="c1">// Convert bool 0/1 to double 0.0 or 1.0</span>
+ <span class="k">return</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateUIToFP</span><span class="p">(</span><span class="n">L</span><span class="p">,</span> <span class="n">Type</span><span class="o">::</span><span class="n">getDoubleTy</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">()),</span>
+ <span class="s">"booltmp"</span><span class="p">);</span>
+ <span class="nl">default:</span> <span class="k">return</span> <span class="nf">ErrorV</span><span class="p">(</span><span class="s">"invalid binary operator"</span><span class="p">);</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="n">Value</span> <span class="o">*</span><span class="n">CallExprAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="c1">// Look up the name in the global module table.</span>
+ <span class="n">Function</span> <span class="o">*</span><span class="n">CalleeF</span> <span class="o">=</span> <span class="n">TheModule</span><span class="o">-></span><span class="n">getFunction</span><span class="p">(</span><span class="n">Callee</span><span class="p">);</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CalleeF</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">ErrorV</span><span class="p">(</span><span class="s">"Unknown function referenced"</span><span class="p">);</span>
+
+ <span class="c1">// If argument mismatch error.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CalleeF</span><span class="o">-></span><span class="n">arg_size</span><span class="p">()</span> <span class="o">!=</span> <span class="n">Args</span><span class="p">.</span><span class="n">size</span><span class="p">())</span>
+ <span class="k">return</span> <span class="n">ErrorV</span><span class="p">(</span><span class="s">"Incorrect # arguments passed"</span><span class="p">);</span>
+
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">Value</span><span class="o">*></span> <span class="n">ArgsV</span><span class="p">;</span>
+ <span class="k">for</span> <span class="p">(</span><span class="kt">unsigned</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">,</span> <span class="n">e</span> <span class="o">=</span> <span class="n">Args</span><span class="p">.</span><span class="n">size</span><span class="p">();</span> <span class="n">i</span> <span class="o">!=</span> <span class="n">e</span><span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">ArgsV</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">Args</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">-></span><span class="n">Codegen</span><span class="p">());</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">ArgsV</span><span class="p">.</span><span class="n">back</span><span class="p">()</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="k">return</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateCall</span><span class="p">(</span><span class="n">CalleeF</span><span class="p">,</span> <span class="n">ArgsV</span><span class="p">,</span> <span class="s">"calltmp"</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="n">Function</span> <span class="o">*</span><span class="n">PrototypeAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="c1">// Make the function type: double(double,double) etc.</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">Type</span><span class="o">*></span> <span class="n">Doubles</span><span class="p">(</span><span class="n">Args</span><span class="p">.</span><span class="n">size</span><span class="p">(),</span>
+ <span class="n">Type</span><span class="o">::</span><span class="n">getDoubleTy</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">()));</span>
+ <span class="n">FunctionType</span> <span class="o">*</span><span class="n">FT</span> <span class="o">=</span> <span class="n">FunctionType</span><span class="o">::</span><span class="n">get</span><span class="p">(</span><span class="n">Type</span><span class="o">::</span><span class="n">getDoubleTy</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">()),</span>
+ <span class="n">Doubles</span><span class="p">,</span> <span class="nb">false</span><span class="p">);</span>
+
+ <span class="n">Function</span> <span class="o">*</span><span class="n">F</span> <span class="o">=</span> <span class="n">Function</span><span class="o">::</span><span class="n">Create</span><span class="p">(</span><span class="n">FT</span><span class="p">,</span> <span class="n">Function</span><span class="o">::</span><span class="n">ExternalLinkage</span><span class="p">,</span> <span class="n">Name</span><span class="p">,</span> <span class="n">TheModule</span><span class="p">);</span>
+
+ <span class="c1">// If F conflicted, there was already something named 'Name'. If it has a</span>
+ <span class="c1">// body, don't allow redefinition or reextern.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">F</span><span class="o">-></span><span class="n">getName</span><span class="p">()</span> <span class="o">!=</span> <span class="n">Name</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">// Delete the one we just made and get the existing one.</span>
+ <span class="n">F</span><span class="o">-></span><span class="n">eraseFromParent</span><span class="p">();</span>
+ <span class="n">F</span> <span class="o">=</span> <span class="n">TheModule</span><span class="o">-></span><span class="n">getFunction</span><span class="p">(</span><span class="n">Name</span><span class="p">);</span>
+
+ <span class="c1">// If F already has a body, reject this.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">F</span><span class="o">-></span><span class="n">empty</span><span class="p">())</span> <span class="p">{</span>
+ <span class="n">ErrorF</span><span class="p">(</span><span class="s">"redefinition of function"</span><span class="p">);</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="c1">// If F took a different number of args, reject.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">F</span><span class="o">-></span><span class="n">arg_size</span><span class="p">()</span> <span class="o">!=</span> <span class="n">Args</span><span class="p">.</span><span class="n">size</span><span class="p">())</span> <span class="p">{</span>
+ <span class="n">ErrorF</span><span class="p">(</span><span class="s">"redefinition of function with different # args"</span><span class="p">);</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+
+ <span class="c1">// Set names for all arguments.</span>
+ <span class="kt">unsigned</span> <span class="n">Idx</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="k">for</span> <span class="p">(</span><span class="n">Function</span><span class="o">::</span><span class="n">arg_iterator</span> <span class="n">AI</span> <span class="o">=</span> <span class="n">F</span><span class="o">-></span><span class="n">arg_begin</span><span class="p">();</span> <span class="n">Idx</span> <span class="o">!=</span> <span class="n">Args</span><span class="p">.</span><span class="n">size</span><span class="p">();</span>
+ <span class="o">++</span><span class="n">AI</span><span class="p">,</span> <span class="o">++</span><span class="n">Idx</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">AI</span><span class="o">-></span><span class="n">setName</span><span class="p">(</span><span class="n">Args</span><span class="p">[</span><span class="n">Idx</span><span class="p">]);</span>
+
+ <span class="c1">// Add arguments to variable symbol table.</span>
+ <span class="n">NamedValues</span><span class="p">[</span><span class="n">Args</span><span class="p">[</span><span class="n">Idx</span><span class="p">]]</span> <span class="o">=</span> <span class="n">AI</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="k">return</span> <span class="n">F</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="n">Function</span> <span class="o">*</span><span class="n">FunctionAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">NamedValues</span><span class="p">.</span><span class="n">clear</span><span class="p">();</span>
+
+ <span class="n">Function</span> <span class="o">*</span><span class="n">TheFunction</span> <span class="o">=</span> <span class="n">Proto</span><span class="o">-></span><span class="n">Codegen</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">TheFunction</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="c1">// Create a new basic block to start insertion into.</span>
+ <span class="n">BasicBlock</span> <span class="o">*</span><span class="n">BB</span> <span class="o">=</span> <span class="n">BasicBlock</span><span class="o">::</span><span class="n">Create</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">(),</span> <span class="s">"entry"</span><span class="p">,</span> <span class="n">TheFunction</span><span class="p">);</span>
+ <span class="n">Builder</span><span class="p">.</span><span class="n">SetInsertPoint</span><span class="p">(</span><span class="n">BB</span><span class="p">);</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">Value</span> <span class="o">*</span><span class="n">RetVal</span> <span class="o">=</span> <span class="n">Body</span><span class="o">-></span><span class="n">Codegen</span><span class="p">())</span> <span class="p">{</span>
+ <span class="c1">// Finish off the function.</span>
+ <span class="n">Builder</span><span class="p">.</span><span class="n">CreateRet</span><span class="p">(</span><span class="n">RetVal</span><span class="p">);</span>
+
+ <span class="c1">// Validate the generated code, checking for consistency.</span>
+ <span class="n">verifyFunction</span><span class="p">(</span><span class="o">*</span><span class="n">TheFunction</span><span class="p">);</span>
+
+ <span class="k">return</span> <span class="n">TheFunction</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="c1">// Error reading body, remove function.</span>
+ <span class="n">TheFunction</span><span class="o">-></span><span class="n">eraseFromParent</span><span class="p">();</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// Top-Level parsing and JIT Driver</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+
+<span class="k">static</span> <span class="kt">void</span> <span class="n">HandleDefinition</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">FunctionAST</span> <span class="o">*</span><span class="n">F</span> <span class="o">=</span> <span class="n">ParseDefinition</span><span class="p">())</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">Function</span> <span class="o">*</span><span class="n">LF</span> <span class="o">=</span> <span class="n">F</span><span class="o">-></span><span class="n">Codegen</span><span class="p">())</span> <span class="p">{</span>
+ <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"Read function definition:"</span><span class="p">);</span>
+ <span class="n">LF</span><span class="o">-></span><span class="n">dump</span><span class="p">();</span>
+ <span class="p">}</span>
+ <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+ <span class="c1">// Skip token for error recovery.</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="k">static</span> <span class="kt">void</span> <span class="n">HandleExtern</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">PrototypeAST</span> <span class="o">*</span><span class="n">P</span> <span class="o">=</span> <span class="n">ParseExtern</span><span class="p">())</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">Function</span> <span class="o">*</span><span class="n">F</span> <span class="o">=</span> <span class="n">P</span><span class="o">-></span><span class="n">Codegen</span><span class="p">())</span> <span class="p">{</span>
+ <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"Read extern: "</span><span class="p">);</span>
+ <span class="n">F</span><span class="o">-></span><span class="n">dump</span><span class="p">();</span>
+ <span class="p">}</span>
+ <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+ <span class="c1">// Skip token for error recovery.</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="k">static</span> <span class="kt">void</span> <span class="n">HandleTopLevelExpression</span><span class="p">()</span> <span class="p">{</span>
+ <span class="c1">// Evaluate a top-level expression into an anonymous function.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">FunctionAST</span> <span class="o">*</span><span class="n">F</span> <span class="o">=</span> <span class="n">ParseTopLevelExpr</span><span class="p">())</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">Function</span> <span class="o">*</span><span class="n">LF</span> <span class="o">=</span> <span class="n">F</span><span class="o">-></span><span class="n">Codegen</span><span class="p">())</span> <span class="p">{</span>
+ <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"Read top-level expression:"</span><span class="p">);</span>
+ <span class="n">LF</span><span class="o">-></span><span class="n">dump</span><span class="p">();</span>
+ <span class="p">}</span>
+ <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+ <span class="c1">// Skip token for error recovery.</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="c1">/// top ::= definition | external | expression | ';'</span>
+<span class="k">static</span> <span class="kt">void</span> <span class="n">MainLoop</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">while</span> <span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"ready> "</span><span class="p">);</span>
+ <span class="k">switch</span> <span class="p">(</span><span class="n">CurTok</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">case</span> <span class="n">tok_eof</span>: <span class="k">return</span><span class="p">;</span>
+ <span class="k">case</span> <span class="sc">';'</span>: <span class="n">getNextToken</span><span class="p">();</span> <span class="k">break</span><span class="p">;</span> <span class="c1">// ignore top-level semicolons.</span>
+ <span class="k">case</span> <span class="n">tok_def</span>: <span class="n">HandleDefinition</span><span class="p">();</span> <span class="k">break</span><span class="p">;</span>
+ <span class="k">case</span> <span class="n">tok_extern</span>: <span class="n">HandleExtern</span><span class="p">();</span> <span class="k">break</span><span class="p">;</span>
+ <span class="nl">default:</span> <span class="n">HandleTopLevelExpression</span><span class="p">();</span> <span class="k">break</span><span class="p">;</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// "Library" functions that can be "extern'd" from user code.</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+
+<span class="c1">/// putchard - putchar that takes a double and returns 0.</span>
+<span class="k">extern</span> <span class="s">"C"</span>
+<span class="kt">double</span> <span class="n">putchard</span><span class="p">(</span><span class="kt">double</span> <span class="n">X</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">putchar</span><span class="p">((</span><span class="kt">char</span><span class="p">)</span><span class="n">X</span><span class="p">);</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// Main driver code.</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+
+<span class="kt">int</span> <span class="n">main</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">LLVMContext</span> <span class="o">&</span><span class="n">Context</span> <span class="o">=</span> <span class="n">getGlobalContext</span><span class="p">();</span>
+
+ <span class="c1">// Install standard binary operators.</span>
+ <span class="c1">// 1 is lowest precedence.</span>
+ <span class="n">BinopPrecedence</span><span class="p">[</span><span class="sc">'<'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">10</span><span class="p">;</span>
+ <span class="n">BinopPrecedence</span><span class="p">[</span><span class="sc">'+'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">20</span><span class="p">;</span>
+ <span class="n">BinopPrecedence</span><span class="p">[</span><span class="sc">'-'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">20</span><span class="p">;</span>
+ <span class="n">BinopPrecedence</span><span class="p">[</span><span class="sc">'*'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">40</span><span class="p">;</span> <span class="c1">// highest.</span>
+
+ <span class="c1">// Prime the first token.</span>
+ <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"ready> "</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+
+ <span class="c1">// Make the module, which holds all the code.</span>
+ <span class="n">TheModule</span> <span class="o">=</span> <span class="k">new</span> <span class="n">Module</span><span class="p">(</span><span class="s">"my cool jit"</span><span class="p">,</span> <span class="n">Context</span><span class="p">);</span>
+
+ <span class="c1">// Run the main "interpreter loop" now.</span>
+ <span class="n">MainLoop</span><span class="p">();</span>
+
+ <span class="c1">// Print out all of the generated code.</span>
+ <span class="n">TheModule</span><span class="o">-></span><span class="n">dump</span><span class="p">();</span>
+
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p><a class="reference external" href="LangImpl4.html">Next: Adding JIT and Optimizer Support</a></p>
+</div>
+</div>
+
+
+ </div>
+ </div>
+ <div class="clearer"></div>
+ </div>
+ <div class="related">
+ <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="LangImpl4.html" title="4. Kaleidoscope: Adding JIT and Optimizer Support"
+ >next</a> |</li>
+ <li class="right" >
+ <a href="LangImpl2.html" title="2. Kaleidoscope: Implementing a Parser and AST"
+ >previous</a> |</li>
+ <li><a href="http://llvm.org/">LLVM Home</a> | </li>
+ <li><a href="../index.html">Documentation</a>»</li>
+
+ <li><a href="index.html" >LLVM Tutorial: Table of Contents</a> »</li>
+ </ul>
+ </div>
+ <div class="footer">
+ © Copyright 2003-2016, LLVM Project.
+ Last updated on 2016-01-04.
+ Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.2.3.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/3.7.1/docs/tutorial/LangImpl4.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/3.7.1/docs/tutorial/LangImpl4.html?rev=257950&view=auto
==============================================================================
--- www-releases/trunk/3.7.1/docs/tutorial/LangImpl4.html (added)
+++ www-releases/trunk/3.7.1/docs/tutorial/LangImpl4.html Fri Jan 15 17:13:16 2016
@@ -0,0 +1,1358 @@
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+ <title>4. Kaleidoscope: Adding JIT and Optimizer Support — LLVM 3.7 documentation</title>
+
+ <link rel="stylesheet" href="../_static/llvm-theme.css" type="text/css" />
+ <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
+
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: '../',
+ VERSION: '3.7',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true
+ };
+ </script>
+ <script type="text/javascript" src="../_static/jquery.js"></script>
+ <script type="text/javascript" src="../_static/underscore.js"></script>
+ <script type="text/javascript" src="../_static/doctools.js"></script>
+ <link rel="top" title="LLVM 3.7 documentation" href="../index.html" />
+ <link rel="up" title="LLVM Tutorial: Table of Contents" href="index.html" />
+ <link rel="next" title="5. Kaleidoscope: Extending the Language: Control Flow" href="LangImpl5.html" />
+ <link rel="prev" title="3. Kaleidoscope: Code generation to LLVM IR" href="LangImpl3.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">
+ <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="LangImpl5.html" title="5. Kaleidoscope: Extending the Language: Control Flow"
+ accesskey="N">next</a> |</li>
+ <li class="right" >
+ <a href="LangImpl3.html" title="3. Kaleidoscope: Code generation to LLVM IR"
+ accesskey="P">previous</a> |</li>
+ <li><a href="http://llvm.org/">LLVM Home</a> | </li>
+ <li><a href="../index.html">Documentation</a>»</li>
+
+ <li><a href="index.html" accesskey="U">LLVM Tutorial: Table of Contents</a> »</li>
+ </ul>
+ </div>
+
+
+ <div class="document">
+ <div class="documentwrapper">
+ <div class="body">
+
+ <div class="section" id="kaleidoscope-adding-jit-and-optimizer-support">
+<h1>4. Kaleidoscope: Adding JIT and Optimizer Support<a class="headerlink" href="#kaleidoscope-adding-jit-and-optimizer-support" title="Permalink to this headline">¶</a></h1>
+<div class="contents local topic" id="contents">
+<ul class="simple">
+<li><a class="reference internal" href="#chapter-4-introduction" id="id1">Chapter 4 Introduction</a></li>
+<li><a class="reference internal" href="#trivial-constant-folding" id="id2">Trivial Constant Folding</a></li>
+<li><a class="reference internal" href="#llvm-optimization-passes" id="id3">LLVM Optimization Passes</a></li>
+<li><a class="reference internal" href="#adding-a-jit-compiler" id="id4">Adding a JIT Compiler</a></li>
+<li><a class="reference internal" href="#full-code-listing" id="id5">Full Code Listing</a></li>
+</ul>
+</div>
+<div class="section" id="chapter-4-introduction">
+<h2><a class="toc-backref" href="#id1">4.1. Chapter 4 Introduction</a><a class="headerlink" href="#chapter-4-introduction" title="Permalink to this headline">¶</a></h2>
+<p>Welcome to Chapter 4 of the “<a class="reference external" href="index.html">Implementing a language with
+LLVM</a>” tutorial. Chapters 1-3 described the implementation
+of a simple language and added support for generating LLVM IR. This
+chapter describes two new techniques: adding optimizer support to your
+language, and adding JIT compiler support. These additions will
+demonstrate how to get nice, efficient code for the Kaleidoscope
+language.</p>
+</div>
+<div class="section" id="trivial-constant-folding">
+<h2><a class="toc-backref" href="#id2">4.2. Trivial Constant Folding</a><a class="headerlink" href="#trivial-constant-folding" title="Permalink to this headline">¶</a></h2>
+<p>Our demonstration for Chapter 3 is elegant and easy to extend.
+Unfortunately, it does not produce wonderful code. The IRBuilder,
+however, does give us obvious optimizations when compiling simple code:</p>
+<div class="highlight-python"><div class="highlight"><pre>ready> def test(x) 1+2+x;
+Read function definition:
+define double @test(double %x) {
+entry:
+ %addtmp = fadd double 3.000000e+00, %x
+ ret double %addtmp
+}
+</pre></div>
+</div>
+<p>This code is not a literal transcription of the AST built by parsing the
+input. That would be:</p>
+<div class="highlight-python"><div class="highlight"><pre>ready> def test(x) 1+2+x;
+Read function definition:
+define double @test(double %x) {
+entry:
+ %addtmp = fadd double 2.000000e+00, 1.000000e+00
+ %addtmp1 = fadd double %addtmp, %x
+ ret double %addtmp1
+}
+</pre></div>
+</div>
+<p>Constant folding, as seen above, in particular, is a very common and
+very important optimization: so much so that many language implementors
+implement constant folding support in their AST representation.</p>
+<p>With LLVM, you don’t need this support in the AST. Since all calls to
+build LLVM IR go through the LLVM IR builder, the builder itself checked
+to see if there was a constant folding opportunity when you call it. If
+so, it just does the constant fold and return the constant instead of
+creating an instruction.</p>
+<p>Well, that was easy :). In practice, we recommend always using
+<tt class="docutils literal"><span class="pre">IRBuilder</span></tt> when generating code like this. It has no “syntactic
+overhead” for its use (you don’t have to uglify your compiler with
+constant checks everywhere) and it can dramatically reduce the amount of
+LLVM IR that is generated in some cases (particular for languages with a
+macro preprocessor or that use a lot of constants).</p>
+<p>On the other hand, the <tt class="docutils literal"><span class="pre">IRBuilder</span></tt> is limited by the fact that it does
+all of its analysis inline with the code as it is built. If you take a
+slightly more complex example:</p>
+<div class="highlight-python"><div class="highlight"><pre>ready> def test(x) (1+2+x)*(x+(1+2));
+ready> Read function definition:
+define double @test(double %x) {
+entry:
+ %addtmp = fadd double 3.000000e+00, %x
+ %addtmp1 = fadd double %x, 3.000000e+00
+ %multmp = fmul double %addtmp, %addtmp1
+ ret double %multmp
+}
+</pre></div>
+</div>
+<p>In this case, the LHS and RHS of the multiplication are the same value.
+We’d really like to see this generate “<tt class="docutils literal"><span class="pre">tmp</span> <span class="pre">=</span> <span class="pre">x+3;</span> <span class="pre">result</span> <span class="pre">=</span> <span class="pre">tmp*tmp;</span></tt>”
+instead of computing “<tt class="docutils literal"><span class="pre">x+3</span></tt>” twice.</p>
+<p>Unfortunately, no amount of local analysis will be able to detect and
+correct this. This requires two transformations: reassociation of
+expressions (to make the add’s lexically identical) and Common
+Subexpression Elimination (CSE) to delete the redundant add instruction.
+Fortunately, LLVM provides a broad range of optimizations that you can
+use, in the form of “passes”.</p>
+</div>
+<div class="section" id="llvm-optimization-passes">
+<h2><a class="toc-backref" href="#id3">4.3. LLVM Optimization Passes</a><a class="headerlink" href="#llvm-optimization-passes" title="Permalink to this headline">¶</a></h2>
+<p>LLVM provides many optimization passes, which do many different sorts of
+things and have different tradeoffs. Unlike other systems, LLVM doesn’t
+hold to the mistaken notion that one set of optimizations is right for
+all languages and for all situations. LLVM allows a compiler implementor
+to make complete decisions about what optimizations to use, in which
+order, and in what situation.</p>
+<p>As a concrete example, LLVM supports both “whole module” passes, which
+look across as large of body of code as they can (often a whole file,
+but if run at link time, this can be a substantial portion of the whole
+program). It also supports and includes “per-function” passes which just
+operate on a single function at a time, without looking at other
+functions. For more information on passes and how they are run, see the
+<a class="reference external" href="../WritingAnLLVMPass.html">How to Write a Pass</a> document and the
+<a class="reference external" href="../Passes.html">List of LLVM Passes</a>.</p>
+<p>For Kaleidoscope, we are currently generating functions on the fly, one
+at a time, as the user types them in. We aren’t shooting for the
+ultimate optimization experience in this setting, but we also want to
+catch the easy and quick stuff where possible. As such, we will choose
+to run a few per-function optimizations as the user types the function
+in. If we wanted to make a “static Kaleidoscope compiler”, we would use
+exactly the code we have now, except that we would defer running the
+optimizer until the entire file has been parsed.</p>
+<p>In order to get per-function optimizations going, we need to set up a
+<a class="reference external" href="../WritingAnLLVMPass.html#passmanager">FunctionPassManager</a> to hold
+and organize the LLVM optimizations that we want to run. Once we have
+that, we can add a set of optimizations to run. The code looks like
+this:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">FunctionPassManager</span> <span class="nf">OurFPM</span><span class="p">(</span><span class="n">TheModule</span><span class="p">);</span>
+
+<span class="c1">// Set up the optimizer pipeline. Start with registering info about how the</span>
+<span class="c1">// target lays out data structures.</span>
+<span class="n">OurFPM</span><span class="p">.</span><span class="n">add</span><span class="p">(</span><span class="k">new</span> <span class="n">DataLayout</span><span class="p">(</span><span class="o">*</span><span class="n">TheExecutionEngine</span><span class="o">-></span><span class="n">getDataLayout</span><span class="p">()));</span>
+<span class="c1">// Provide basic AliasAnalysis support for GVN.</span>
+<span class="n">OurFPM</span><span class="p">.</span><span class="n">add</span><span class="p">(</span><span class="n">createBasicAliasAnalysisPass</span><span class="p">());</span>
+<span class="c1">// Do simple "peephole" optimizations and bit-twiddling optzns.</span>
+<span class="n">OurFPM</span><span class="p">.</span><span class="n">add</span><span class="p">(</span><span class="n">createInstructionCombiningPass</span><span class="p">());</span>
+<span class="c1">// Reassociate expressions.</span>
+<span class="n">OurFPM</span><span class="p">.</span><span class="n">add</span><span class="p">(</span><span class="n">createReassociatePass</span><span class="p">());</span>
+<span class="c1">// Eliminate Common SubExpressions.</span>
+<span class="n">OurFPM</span><span class="p">.</span><span class="n">add</span><span class="p">(</span><span class="n">createGVNPass</span><span class="p">());</span>
+<span class="c1">// Simplify the control flow graph (deleting unreachable blocks, etc).</span>
+<span class="n">OurFPM</span><span class="p">.</span><span class="n">add</span><span class="p">(</span><span class="n">createCFGSimplificationPass</span><span class="p">());</span>
+
+<span class="n">OurFPM</span><span class="p">.</span><span class="n">doInitialization</span><span class="p">();</span>
+
+<span class="c1">// Set the global so the code gen can use this.</span>
+<span class="n">TheFPM</span> <span class="o">=</span> <span class="o">&</span><span class="n">OurFPM</span><span class="p">;</span>
+
+<span class="c1">// Run the main "interpreter loop" now.</span>
+<span class="n">MainLoop</span><span class="p">();</span>
+</pre></div>
+</div>
+<p>This code defines a <tt class="docutils literal"><span class="pre">FunctionPassManager</span></tt>, “<tt class="docutils literal"><span class="pre">OurFPM</span></tt>”. It requires a
+pointer to the <tt class="docutils literal"><span class="pre">Module</span></tt> to construct itself. Once it is set up, we use
+a series of “add” calls to add a bunch of LLVM passes. The first pass is
+basically boilerplate, it adds a pass so that later optimizations know
+how the data structures in the program are laid out. The
+“<tt class="docutils literal"><span class="pre">TheExecutionEngine</span></tt>” variable is related to the JIT, which we will
+get to in the next section.</p>
+<p>In this case, we choose to add 4 optimization passes. The passes we
+chose here are a pretty standard set of “cleanup” optimizations that are
+useful for a wide variety of code. I won’t delve into what they do but,
+believe me, they are a good starting place :).</p>
+<p>Once the PassManager is set up, we need to make use of it. We do this by
+running it after our newly created function is constructed (in
+<tt class="docutils literal"><span class="pre">FunctionAST::Codegen</span></tt>), but before it is returned to the client:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">if</span> <span class="p">(</span><span class="n">Value</span> <span class="o">*</span><span class="n">RetVal</span> <span class="o">=</span> <span class="n">Body</span><span class="o">-></span><span class="n">Codegen</span><span class="p">())</span> <span class="p">{</span>
+ <span class="c1">// Finish off the function.</span>
+ <span class="n">Builder</span><span class="p">.</span><span class="n">CreateRet</span><span class="p">(</span><span class="n">RetVal</span><span class="p">);</span>
+
+ <span class="c1">// Validate the generated code, checking for consistency.</span>
+ <span class="n">verifyFunction</span><span class="p">(</span><span class="o">*</span><span class="n">TheFunction</span><span class="p">);</span>
+
+ <span class="c1">// Optimize the function.</span>
+ <span class="n">TheFPM</span><span class="o">-></span><span class="n">run</span><span class="p">(</span><span class="o">*</span><span class="n">TheFunction</span><span class="p">);</span>
+
+ <span class="k">return</span> <span class="n">TheFunction</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>As you can see, this is pretty straightforward. The
+<tt class="docutils literal"><span class="pre">FunctionPassManager</span></tt> optimizes and updates the LLVM Function* in
+place, improving (hopefully) its body. With this in place, we can try
+our test above again:</p>
+<div class="highlight-python"><div class="highlight"><pre>ready> def test(x) (1+2+x)*(x+(1+2));
+ready> Read function definition:
+define double @test(double %x) {
+entry:
+ %addtmp = fadd double %x, 3.000000e+00
+ %multmp = fmul double %addtmp, %addtmp
+ ret double %multmp
+}
+</pre></div>
+</div>
+<p>As expected, we now get our nicely optimized code, saving a floating
+point add instruction from every execution of this function.</p>
+<p>LLVM provides a wide variety of optimizations that can be used in
+certain circumstances. Some <a class="reference external" href="../Passes.html">documentation about the various
+passes</a> is available, but it isn’t very complete.
+Another good source of ideas can come from looking at the passes that
+<tt class="docutils literal"><span class="pre">Clang</span></tt> runs to get started. The “<tt class="docutils literal"><span class="pre">opt</span></tt>” tool allows you to
+experiment with passes from the command line, so you can see if they do
+anything.</p>
+<p>Now that we have reasonable code coming out of our front-end, lets talk
+about executing it!</p>
+</div>
+<div class="section" id="adding-a-jit-compiler">
+<h2><a class="toc-backref" href="#id4">4.4. Adding a JIT Compiler</a><a class="headerlink" href="#adding-a-jit-compiler" title="Permalink to this headline">¶</a></h2>
+<p>Code that is available in LLVM IR can have a wide variety of tools
+applied to it. For example, you can run optimizations on it (as we did
+above), you can dump it out in textual or binary forms, you can compile
+the code to an assembly file (.s) for some target, or you can JIT
+compile it. The nice thing about the LLVM IR representation is that it
+is the “common currency” between many different parts of the compiler.</p>
+<p>In this section, we’ll add JIT compiler support to our interpreter. The
+basic idea that we want for Kaleidoscope is to have the user enter
+function bodies as they do now, but immediately evaluate the top-level
+expressions they type in. For example, if they type in “1 + 2;”, we
+should evaluate and print out 3. If they define a function, they should
+be able to call it from the command line.</p>
+<p>In order to do this, we first declare and initialize the JIT. This is
+done by adding a global variable and a call in <tt class="docutils literal"><span class="pre">main</span></tt>:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">static</span> <span class="n">ExecutionEngine</span> <span class="o">*</span><span class="n">TheExecutionEngine</span><span class="p">;</span>
+<span class="p">...</span>
+<span class="kt">int</span> <span class="n">main</span><span class="p">()</span> <span class="p">{</span>
+ <span class="p">..</span>
+ <span class="c1">// Create the JIT. This takes ownership of the module.</span>
+ <span class="n">TheExecutionEngine</span> <span class="o">=</span> <span class="n">EngineBuilder</span><span class="p">(</span><span class="n">TheModule</span><span class="p">).</span><span class="n">create</span><span class="p">();</span>
+ <span class="p">..</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>This creates an abstract “Execution Engine” which can be either a JIT
+compiler or the LLVM interpreter. LLVM will automatically pick a JIT
+compiler for you if one is available for your platform, otherwise it
+will fall back to the interpreter.</p>
+<p>Once the <tt class="docutils literal"><span class="pre">ExecutionEngine</span></tt> is created, the JIT is ready to be used.
+There are a variety of APIs that are useful, but the simplest one is the
+“<tt class="docutils literal"><span class="pre">getPointerToFunction(F)</span></tt>” method. This method JIT compiles the
+specified LLVM Function and returns a function pointer to the generated
+machine code. In our case, this means that we can change the code that
+parses a top-level expression to look like this:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">static</span> <span class="kt">void</span> <span class="nf">HandleTopLevelExpression</span><span class="p">()</span> <span class="p">{</span>
+ <span class="c1">// Evaluate a top-level expression into an anonymous function.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">FunctionAST</span> <span class="o">*</span><span class="n">F</span> <span class="o">=</span> <span class="n">ParseTopLevelExpr</span><span class="p">())</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">Function</span> <span class="o">*</span><span class="n">LF</span> <span class="o">=</span> <span class="n">F</span><span class="o">-></span><span class="n">Codegen</span><span class="p">())</span> <span class="p">{</span>
+ <span class="n">LF</span><span class="o">-></span><span class="n">dump</span><span class="p">();</span> <span class="c1">// Dump the function for exposition purposes.</span>
+
+ <span class="c1">// JIT the function, returning a function pointer.</span>
+ <span class="kt">void</span> <span class="o">*</span><span class="n">FPtr</span> <span class="o">=</span> <span class="n">TheExecutionEngine</span><span class="o">-></span><span class="n">getPointerToFunction</span><span class="p">(</span><span class="n">LF</span><span class="p">);</span>
+
+ <span class="c1">// Cast it to the right type (takes no arguments, returns a double) so we</span>
+ <span class="c1">// can call it as a native function.</span>
+ <span class="kt">double</span> <span class="p">(</span><span class="o">*</span><span class="n">FP</span><span class="p">)()</span> <span class="o">=</span> <span class="p">(</span><span class="kt">double</span> <span class="p">(</span><span class="o">*</span><span class="p">)())(</span><span class="kt">intptr_t</span><span class="p">)</span><span class="n">FPtr</span><span class="p">;</span>
+ <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"Evaluated to %f</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">FP</span><span class="p">());</span>
+ <span class="p">}</span>
+</pre></div>
+</div>
+<p>Recall that we compile top-level expressions into a self-contained LLVM
+function that takes no arguments and returns the computed double.
+Because the LLVM JIT compiler matches the native platform ABI, this
+means that you can just cast the result pointer to a function pointer of
+that type and call it directly. This means, there is no difference
+between JIT compiled code and native machine code that is statically
+linked into your application.</p>
+<p>With just these two changes, lets see how Kaleidoscope works now!</p>
+<div class="highlight-python"><div class="highlight"><pre>ready> 4+5;
+Read top-level expression:
+define double @0() {
+entry:
+ ret double 9.000000e+00
+}
+
+Evaluated to 9.000000
+</pre></div>
+</div>
+<p>Well this looks like it is basically working. The dump of the function
+shows the “no argument function that always returns double” that we
+synthesize for each top-level expression that is typed in. This
+demonstrates very basic functionality, but can we do more?</p>
+<div class="highlight-python"><div class="highlight"><pre>ready> def testfunc(x y) x + y*2;
+Read function definition:
+define double @testfunc(double %x, double %y) {
+entry:
+ %multmp = fmul double %y, 2.000000e+00
+ %addtmp = fadd double %multmp, %x
+ ret double %addtmp
+}
+
+ready> testfunc(4, 10);
+Read top-level expression:
+define double @1() {
+entry:
+ %calltmp = call double @testfunc(double 4.000000e+00, double 1.000000e+01)
+ ret double %calltmp
+}
+
+Evaluated to 24.000000
+</pre></div>
+</div>
+<p>This illustrates that we can now call user code, but there is something
+a bit subtle going on here. Note that we only invoke the JIT on the
+anonymous functions that <em>call testfunc</em>, but we never invoked it on
+<em>testfunc</em> itself. What actually happened here is that the JIT scanned
+for all non-JIT’d functions transitively called from the anonymous
+function and compiled all of them before returning from
+<tt class="docutils literal"><span class="pre">getPointerToFunction()</span></tt>.</p>
+<p>The JIT provides a number of other more advanced interfaces for things
+like freeing allocated machine code, rejit’ing functions to update them,
+etc. However, even with this simple code, we get some surprisingly
+powerful capabilities - check this out (I removed the dump of the
+anonymous functions, you should get the idea by now :) :</p>
+<div class="highlight-python"><div class="highlight"><pre>ready> extern sin(x);
+Read extern:
+declare double @sin(double)
+
+ready> extern cos(x);
+Read extern:
+declare double @cos(double)
+
+ready> sin(1.0);
+Read top-level expression:
+define double @2() {
+entry:
+ ret double 0x3FEAED548F090CEE
+}
+
+Evaluated to 0.841471
+
+ready> def foo(x) sin(x)*sin(x) + cos(x)*cos(x);
+Read function definition:
+define double @foo(double %x) {
+entry:
+ %calltmp = call double @sin(double %x)
+ %multmp = fmul double %calltmp, %calltmp
+ %calltmp2 = call double @cos(double %x)
+ %multmp4 = fmul double %calltmp2, %calltmp2
+ %addtmp = fadd double %multmp, %multmp4
+ ret double %addtmp
+}
+
+ready> foo(4.0);
+Read top-level expression:
+define double @3() {
+entry:
+ %calltmp = call double @foo(double 4.000000e+00)
+ ret double %calltmp
+}
+
+Evaluated to 1.000000
+</pre></div>
+</div>
+<p>Whoa, how does the JIT know about sin and cos? The answer is
+surprisingly simple: in this example, the JIT started execution of a
+function and got to a function call. It realized that the function was
+not yet JIT compiled and invoked the standard set of routines to resolve
+the function. In this case, there is no body defined for the function,
+so the JIT ended up calling “<tt class="docutils literal"><span class="pre">dlsym("sin")</span></tt>” on the Kaleidoscope
+process itself. Since “<tt class="docutils literal"><span class="pre">sin</span></tt>” is defined within the JIT’s address
+space, it simply patches up calls in the module to call the libm version
+of <tt class="docutils literal"><span class="pre">sin</span></tt> directly.</p>
+<p>The LLVM JIT provides a number of interfaces (look in the
+<tt class="docutils literal"><span class="pre">ExecutionEngine.h</span></tt> file) for controlling how unknown functions get
+resolved. It allows you to establish explicit mappings between IR
+objects and addresses (useful for LLVM global variables that you want to
+map to static tables, for example), allows you to dynamically decide on
+the fly based on the function name, and even allows you to have the JIT
+compile functions lazily the first time they’re called.</p>
+<p>One interesting application of this is that we can now extend the
+language by writing arbitrary C++ code to implement operations. For
+example, if we add:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">/// putchard - putchar that takes a double and returns 0.</span>
+<span class="k">extern</span> <span class="s">"C"</span>
+<span class="kt">double</span> <span class="n">putchard</span><span class="p">(</span><span class="kt">double</span> <span class="n">X</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">putchar</span><span class="p">((</span><span class="kt">char</span><span class="p">)</span><span class="n">X</span><span class="p">);</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>Now we can produce simple output to the console by using things like:
+“<tt class="docutils literal"><span class="pre">extern</span> <span class="pre">putchard(x);</span> <span class="pre">putchard(120);</span></tt>”, which prints a lowercase ‘x’
+on the console (120 is the ASCII code for ‘x’). Similar code could be
+used to implement file I/O, console input, and many other capabilities
+in Kaleidoscope.</p>
+<p>This completes the JIT and optimizer chapter of the Kaleidoscope
+tutorial. At this point, we can compile a non-Turing-complete
+programming language, optimize and JIT compile it in a user-driven way.
+Next up we’ll look into <a class="reference external" href="LangImpl5.html">extending the language with control flow
+constructs</a>, tackling some interesting LLVM IR issues
+along the way.</p>
+</div>
+<div class="section" id="full-code-listing">
+<h2><a class="toc-backref" href="#id5">4.5. 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, enhanced with
+the LLVM JIT and optimizer. To build this example, use:</p>
+<div class="highlight-bash"><div class="highlight"><pre><span class="c"># Compile</span>
+clang++ -g toy.cpp <span class="sb">`</span>llvm-config --cxxflags --ldflags --system-libs --libs core mcjit native<span class="sb">`</span> -O3 -o toy
+<span class="c"># Run</span>
+./toy
+</pre></div>
+</div>
+<p>If you are compiling this on Linux, make sure to add the “-rdynamic”
+option as well. This makes sure that the external functions are resolved
+properly at runtime.</p>
+<p>Here is the code:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="cp">#include "llvm/Analysis/Passes.h"</span>
+<span class="cp">#include "llvm/ExecutionEngine/ExecutionEngine.h"</span>
+<span class="cp">#include "llvm/ExecutionEngine/MCJIT.h"</span>
+<span class="cp">#include "llvm/ExecutionEngine/SectionMemoryManager.h"</span>
+<span class="cp">#include "llvm/IR/DataLayout.h"</span>
+<span class="cp">#include "llvm/IR/DerivedTypes.h"</span>
+<span class="cp">#include "llvm/IR/IRBuilder.h"</span>
+<span class="cp">#include "llvm/IR/LLVMContext.h"</span>
+<span class="cp">#include "llvm/IR/LegacyPassManager.h"</span>
+<span class="cp">#include "llvm/IR/Module.h"</span>
+<span class="cp">#include "llvm/IR/Verifier.h"</span>
+<span class="cp">#include "llvm/Support/TargetSelect.h"</span>
+<span class="cp">#include "llvm/Transforms/Scalar.h"</span>
+<span class="cp">#include <cctype></span>
+<span class="cp">#include <cstdio></span>
+<span class="cp">#include <map></span>
+<span class="cp">#include <string></span>
+<span class="cp">#include <vector></span>
+<span class="k">using</span> <span class="k">namespace</span> <span class="n">llvm</span><span class="p">;</span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// Lexer</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+
+<span class="c1">// The lexer returns tokens [0-255] if it is an unknown character, otherwise one</span>
+<span class="c1">// of these for known things.</span>
+<span class="k">enum</span> <span class="n">Token</span> <span class="p">{</span>
+ <span class="n">tok_eof</span> <span class="o">=</span> <span class="o">-</span><span class="mi">1</span><span class="p">,</span>
+
+ <span class="c1">// commands</span>
+ <span class="n">tok_def</span> <span class="o">=</span> <span class="o">-</span><span class="mi">2</span><span class="p">,</span>
+ <span class="n">tok_extern</span> <span class="o">=</span> <span class="o">-</span><span class="mi">3</span><span class="p">,</span>
+
+ <span class="c1">// primary</span>
+ <span class="n">tok_identifier</span> <span class="o">=</span> <span class="o">-</span><span class="mi">4</span><span class="p">,</span>
+ <span class="n">tok_number</span> <span class="o">=</span> <span class="o">-</span><span class="mi">5</span>
+<span class="p">};</span>
+
+<span class="k">static</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">IdentifierStr</span><span class="p">;</span> <span class="c1">// Filled in if tok_identifier</span>
+<span class="k">static</span> <span class="kt">double</span> <span class="n">NumVal</span><span class="p">;</span> <span class="c1">// Filled in if tok_number</span>
+
+<span class="c1">/// gettok - Return the next token from standard input.</span>
+<span class="k">static</span> <span class="kt">int</span> <span class="nf">gettok</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">static</span> <span class="kt">int</span> <span class="n">LastChar</span> <span class="o">=</span> <span class="sc">' '</span><span class="p">;</span>
+
+ <span class="c1">// Skip any whitespace.</span>
+ <span class="k">while</span> <span class="p">(</span><span class="n">isspace</span><span class="p">(</span><span class="n">LastChar</span><span class="p">))</span>
+ <span class="n">LastChar</span> <span class="o">=</span> <span class="n">getchar</span><span class="p">();</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">isalpha</span><span class="p">(</span><span class="n">LastChar</span><span class="p">))</span> <span class="p">{</span> <span class="c1">// identifier: [a-zA-Z][a-zA-Z0-9]*</span>
+ <span class="n">IdentifierStr</span> <span class="o">=</span> <span class="n">LastChar</span><span class="p">;</span>
+ <span class="k">while</span> <span class="p">(</span><span class="n">isalnum</span><span class="p">((</span><span class="n">LastChar</span> <span class="o">=</span> <span class="n">getchar</span><span class="p">())))</span>
+ <span class="n">IdentifierStr</span> <span class="o">+=</span> <span class="n">LastChar</span><span class="p">;</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"def"</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">tok_def</span><span class="p">;</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"extern"</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">tok_extern</span><span class="p">;</span>
+ <span class="k">return</span> <span class="n">tok_identifier</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">isdigit</span><span class="p">(</span><span class="n">LastChar</span><span class="p">)</span> <span class="o">||</span> <span class="n">LastChar</span> <span class="o">==</span> <span class="sc">'.'</span><span class="p">)</span> <span class="p">{</span> <span class="c1">// Number: [0-9.]+</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">NumStr</span><span class="p">;</span>
+ <span class="k">do</span> <span class="p">{</span>
+ <span class="n">NumStr</span> <span class="o">+=</span> <span class="n">LastChar</span><span class="p">;</span>
+ <span class="n">LastChar</span> <span class="o">=</span> <span class="n">getchar</span><span class="p">();</span>
+ <span class="p">}</span> <span class="k">while</span> <span class="p">(</span><span class="n">isdigit</span><span class="p">(</span><span class="n">LastChar</span><span class="p">)</span> <span class="o">||</span> <span class="n">LastChar</span> <span class="o">==</span> <span class="sc">'.'</span><span class="p">);</span>
+
+ <span class="n">NumVal</span> <span class="o">=</span> <span class="n">strtod</span><span class="p">(</span><span class="n">NumStr</span><span class="p">.</span><span class="n">c_str</span><span class="p">(),</span> <span class="mi">0</span><span class="p">);</span>
+ <span class="k">return</span> <span class="n">tok_number</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">LastChar</span> <span class="o">==</span> <span class="sc">'#'</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">// Comment until end of line.</span>
+ <span class="k">do</span>
+ <span class="n">LastChar</span> <span class="o">=</span> <span class="n">getchar</span><span class="p">();</span>
+ <span class="k">while</span> <span class="p">(</span><span class="n">LastChar</span> <span class="o">!=</span> <span class="n">EOF</span> <span class="o">&&</span> <span class="n">LastChar</span> <span class="o">!=</span> <span class="sc">'\n'</span> <span class="o">&&</span> <span class="n">LastChar</span> <span class="o">!=</span> <span class="sc">'\r'</span><span class="p">);</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">LastChar</span> <span class="o">!=</span> <span class="n">EOF</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">gettok</span><span class="p">();</span>
+ <span class="p">}</span>
+
+ <span class="c1">// Check for end of file. Don't eat the EOF.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">LastChar</span> <span class="o">==</span> <span class="n">EOF</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">tok_eof</span><span class="p">;</span>
+
+ <span class="c1">// Otherwise, just return the character as its ascii value.</span>
+ <span class="kt">int</span> <span class="n">ThisChar</span> <span class="o">=</span> <span class="n">LastChar</span><span class="p">;</span>
+ <span class="n">LastChar</span> <span class="o">=</span> <span class="n">getchar</span><span class="p">();</span>
+ <span class="k">return</span> <span class="n">ThisChar</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// Abstract Syntax Tree (aka Parse Tree)</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="k">namespace</span> <span class="p">{</span>
+<span class="c1">/// ExprAST - Base class for all expression nodes.</span>
+<span class="k">class</span> <span class="nc">ExprAST</span> <span class="p">{</span>
+<span class="nl">public:</span>
+ <span class="k">virtual</span> <span class="o">~</span><span class="n">ExprAST</span><span class="p">()</span> <span class="p">{}</span>
+ <span class="k">virtual</span> <span class="n">Value</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">()</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="c1">/// NumberExprAST - Expression class for numeric literals like "1.0".</span>
+<span class="k">class</span> <span class="nc">NumberExprAST</span> <span class="o">:</span> <span class="k">public</span> <span class="n">ExprAST</span> <span class="p">{</span>
+ <span class="kt">double</span> <span class="n">Val</span><span class="p">;</span>
+
+<span class="nl">public:</span>
+ <span class="n">NumberExprAST</span><span class="p">(</span><span class="kt">double</span> <span class="n">val</span><span class="p">)</span> <span class="o">:</span> <span class="n">Val</span><span class="p">(</span><span class="n">val</span><span class="p">)</span> <span class="p">{}</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">()</span> <span class="n">override</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="c1">/// VariableExprAST - Expression class for referencing a variable, like "a".</span>
+<span class="k">class</span> <span class="nc">VariableExprAST</span> <span class="o">:</span> <span class="k">public</span> <span class="n">ExprAST</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">Name</span><span class="p">;</span>
+
+<span class="nl">public:</span>
+ <span class="n">VariableExprAST</span><span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="o">&</span><span class="n">name</span><span class="p">)</span> <span class="o">:</span> <span class="n">Name</span><span class="p">(</span><span class="n">name</span><span class="p">)</span> <span class="p">{}</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">()</span> <span class="n">override</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="c1">/// BinaryExprAST - Expression class for a binary operator.</span>
+<span class="k">class</span> <span class="nc">BinaryExprAST</span> <span class="o">:</span> <span class="k">public</span> <span class="n">ExprAST</span> <span class="p">{</span>
+ <span class="kt">char</span> <span class="n">Op</span><span class="p">;</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">LHS</span><span class="p">,</span> <span class="o">*</span><span class="n">RHS</span><span class="p">;</span>
+
+<span class="nl">public:</span>
+ <span class="n">BinaryExprAST</span><span class="p">(</span><span class="kt">char</span> <span class="n">op</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">lhs</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">rhs</span><span class="p">)</span>
+ <span class="o">:</span> <span class="n">Op</span><span class="p">(</span><span class="n">op</span><span class="p">),</span> <span class="n">LHS</span><span class="p">(</span><span class="n">lhs</span><span class="p">),</span> <span class="n">RHS</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span> <span class="p">{}</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">()</span> <span class="n">override</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="c1">/// CallExprAST - Expression class for function calls.</span>
+<span class="k">class</span> <span class="nc">CallExprAST</span> <span class="o">:</span> <span class="k">public</span> <span class="n">ExprAST</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">Callee</span><span class="p">;</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">ExprAST</span> <span class="o">*></span> <span class="n">Args</span><span class="p">;</span>
+
+<span class="nl">public:</span>
+ <span class="n">CallExprAST</span><span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="o">&</span><span class="n">callee</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">ExprAST</span> <span class="o">*></span> <span class="o">&</span><span class="n">args</span><span class="p">)</span>
+ <span class="o">:</span> <span class="n">Callee</span><span class="p">(</span><span class="n">callee</span><span class="p">),</span> <span class="n">Args</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="p">{}</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">()</span> <span class="n">override</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="c1">/// PrototypeAST - This class represents the "prototype" for a function,</span>
+<span class="c1">/// which captures its name, and its argument names (thus implicitly the number</span>
+<span class="c1">/// of arguments the function takes).</span>
+<span class="k">class</span> <span class="nc">PrototypeAST</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">Name</span><span class="p">;</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span> <span class="n">Args</span><span class="p">;</span>
+
+<span class="nl">public:</span>
+ <span class="n">PrototypeAST</span><span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="o">&</span><span class="n">name</span><span class="p">,</span> <span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span> <span class="o">&</span><span class="n">args</span><span class="p">)</span>
+ <span class="o">:</span> <span class="n">Name</span><span class="p">(</span><span class="n">name</span><span class="p">),</span> <span class="n">Args</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="p">{}</span>
+
+ <span class="n">Function</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">();</span>
+<span class="p">};</span>
+
+<span class="c1">/// FunctionAST - This class represents a function definition itself.</span>
+<span class="k">class</span> <span class="nc">FunctionAST</span> <span class="p">{</span>
+ <span class="n">PrototypeAST</span> <span class="o">*</span><span class="n">Proto</span><span class="p">;</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Body</span><span class="p">;</span>
+
+<span class="nl">public:</span>
+ <span class="n">FunctionAST</span><span class="p">(</span><span class="n">PrototypeAST</span> <span class="o">*</span><span class="n">proto</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">body</span><span class="p">)</span> <span class="o">:</span> <span class="n">Proto</span><span class="p">(</span><span class="n">proto</span><span class="p">),</span> <span class="n">Body</span><span class="p">(</span><span class="n">body</span><span class="p">)</span> <span class="p">{}</span>
+
+ <span class="n">Function</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">();</span>
+<span class="p">};</span>
+<span class="p">}</span> <span class="c1">// end anonymous namespace</span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// Parser</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+
+<span class="c1">/// CurTok/getNextToken - Provide a simple token buffer. CurTok is the current</span>
+<span class="c1">/// token the parser is looking at. getNextToken reads another token from the</span>
+<span class="c1">/// lexer and updates CurTok with its results.</span>
+<span class="k">static</span> <span class="kt">int</span> <span class="n">CurTok</span><span class="p">;</span>
+<span class="k">static</span> <span class="kt">int</span> <span class="nf">getNextToken</span><span class="p">()</span> <span class="p">{</span> <span class="k">return</span> <span class="n">CurTok</span> <span class="o">=</span> <span class="n">gettok</span><span class="p">();</span> <span class="p">}</span>
+
+<span class="c1">/// BinopPrecedence - This holds the precedence for each binary operator that is</span>
+<span class="c1">/// defined.</span>
+<span class="k">static</span> <span class="n">std</span><span class="o">::</span><span class="n">map</span><span class="o"><</span><span class="kt">char</span><span class="p">,</span> <span class="kt">int</span><span class="o">></span> <span class="n">BinopPrecedence</span><span class="p">;</span>
+
+<span class="c1">/// GetTokPrecedence - Get the precedence of the pending binary operator token.</span>
+<span class="k">static</span> <span class="kt">int</span> <span class="nf">GetTokPrecedence</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">isascii</span><span class="p">(</span><span class="n">CurTok</span><span class="p">))</span>
+ <span class="k">return</span> <span class="o">-</span><span class="mi">1</span><span class="p">;</span>
+
+ <span class="c1">// Make sure it's a declared binop.</span>
+ <span class="kt">int</span> <span class="n">TokPrec</span> <span class="o">=</span> <span class="n">BinopPrecedence</span><span class="p">[</span><span class="n">CurTok</span><span class="p">];</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">TokPrec</span> <span class="o"><=</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="o">-</span><span class="mi">1</span><span class="p">;</span>
+ <span class="k">return</span> <span class="n">TokPrec</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">/// Error* - These are little helper functions for error handling.</span>
+<span class="n">ExprAST</span> <span class="o">*</span><span class="nf">Error</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">Str</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"Error: %s</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">Str</span><span class="p">);</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+<span class="n">PrototypeAST</span> <span class="o">*</span><span class="nf">ErrorP</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">Str</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">Error</span><span class="p">(</span><span class="n">Str</span><span class="p">);</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+<span class="n">FunctionAST</span> <span class="o">*</span><span class="nf">ErrorF</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">Str</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">Error</span><span class="p">(</span><span class="n">Str</span><span class="p">);</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseExpression</span><span class="p">();</span>
+
+<span class="c1">/// identifierexpr</span>
+<span class="c1">/// ::= identifier</span>
+<span class="c1">/// ::= identifier '(' expression* ')'</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseIdentifierExpr</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">IdName</span> <span class="o">=</span> <span class="n">IdentifierStr</span><span class="p">;</span>
+
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat identifier.</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">'('</span><span class="p">)</span> <span class="c1">// Simple variable ref.</span>
+ <span class="k">return</span> <span class="k">new</span> <span class="n">VariableExprAST</span><span class="p">(</span><span class="n">IdName</span><span class="p">);</span>
+
+ <span class="c1">// Call.</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat (</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">ExprAST</span> <span class="o">*></span> <span class="n">Args</span><span class="p">;</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">')'</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">while</span> <span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Arg</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">Arg</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="n">Args</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">Arg</span><span class="p">);</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">==</span> <span class="sc">')'</span><span class="p">)</span>
+ <span class="k">break</span><span class="p">;</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">','</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"Expected ')' or ',' in argument list"</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+
+ <span class="c1">// Eat the ')'.</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+
+ <span class="k">return</span> <span class="k">new</span> <span class="n">CallExprAST</span><span class="p">(</span><span class="n">IdName</span><span class="p">,</span> <span class="n">Args</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="c1">/// numberexpr ::= number</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseNumberExpr</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Result</span> <span class="o">=</span> <span class="k">new</span> <span class="n">NumberExprAST</span><span class="p">(</span><span class="n">NumVal</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// consume the number</span>
+ <span class="k">return</span> <span class="n">Result</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">/// parenexpr ::= '(' expression ')'</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseParenExpr</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat (.</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">V</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">V</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">')'</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"expected ')'"</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat ).</span>
+ <span class="k">return</span> <span class="n">V</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">/// primary</span>
+<span class="c1">/// ::= identifierexpr</span>
+<span class="c1">/// ::= numberexpr</span>
+<span class="c1">/// ::= parenexpr</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParsePrimary</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">switch</span> <span class="p">(</span><span class="n">CurTok</span><span class="p">)</span> <span class="p">{</span>
+ <span class="nl">default:</span>
+ <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"unknown token when expecting an expression"</span><span class="p">);</span>
+ <span class="k">case</span> <span class="n">tok_identifier</span>:
+ <span class="k">return</span> <span class="n">ParseIdentifierExpr</span><span class="p">();</span>
+ <span class="k">case</span> <span class="n">tok_number</span>:
+ <span class="k">return</span> <span class="n">ParseNumberExpr</span><span class="p">();</span>
+ <span class="k">case</span> <span class="sc">'('</span>:
+ <span class="k">return</span> <span class="n">ParseParenExpr</span><span class="p">();</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="c1">/// binoprhs</span>
+<span class="c1">/// ::= ('+' primary)*</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseBinOpRHS</span><span class="p">(</span><span class="kt">int</span> <span class="n">ExprPrec</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">LHS</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">// If this is a binop, find its precedence.</span>
+ <span class="k">while</span> <span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
+ <span class="kt">int</span> <span class="n">TokPrec</span> <span class="o">=</span> <span class="n">GetTokPrecedence</span><span class="p">();</span>
+
+ <span class="c1">// If this is a binop that binds at least as tightly as the current binop,</span>
+ <span class="c1">// consume it, otherwise we are done.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">TokPrec</span> <span class="o"><</span> <span class="n">ExprPrec</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">LHS</span><span class="p">;</span>
+
+ <span class="c1">// Okay, we know this is a binop.</span>
+ <span class="kt">int</span> <span class="n">BinOp</span> <span class="o">=</span> <span class="n">CurTok</span><span class="p">;</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat binop</span>
+
+ <span class="c1">// Parse the primary expression after the binary operator.</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">RHS</span> <span class="o">=</span> <span class="n">ParsePrimary</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">RHS</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="c1">// If BinOp binds less tightly with RHS than the operator after RHS, let</span>
+ <span class="c1">// the pending operator take RHS as its LHS.</span>
+ <span class="kt">int</span> <span class="n">NextPrec</span> <span class="o">=</span> <span class="n">GetTokPrecedence</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">TokPrec</span> <span class="o"><</span> <span class="n">NextPrec</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">RHS</span> <span class="o">=</span> <span class="n">ParseBinOpRHS</span><span class="p">(</span><span class="n">TokPrec</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="n">RHS</span><span class="p">);</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">RHS</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="c1">// Merge LHS/RHS.</span>
+ <span class="n">LHS</span> <span class="o">=</span> <span class="k">new</span> <span class="n">BinaryExprAST</span><span class="p">(</span><span class="n">BinOp</span><span class="p">,</span> <span class="n">LHS</span><span class="p">,</span> <span class="n">RHS</span><span class="p">);</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="c1">/// expression</span>
+<span class="c1">/// ::= primary binoprhs</span>
+<span class="c1">///</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseExpression</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">LHS</span> <span class="o">=</span> <span class="n">ParsePrimary</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">LHS</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">return</span> <span class="n">ParseBinOpRHS</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="n">LHS</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="c1">/// prototype</span>
+<span class="c1">/// ::= id '(' id* ')'</span>
+<span class="k">static</span> <span class="n">PrototypeAST</span> <span class="o">*</span><span class="nf">ParsePrototype</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="n">tok_identifier</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">ErrorP</span><span class="p">(</span><span class="s">"Expected function name in prototype"</span><span class="p">);</span>
+
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">FnName</span> <span class="o">=</span> <span class="n">IdentifierStr</span><span class="p">;</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">'('</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">ErrorP</span><span class="p">(</span><span class="s">"Expected '(' in prototype"</span><span class="p">);</span>
+
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span> <span class="n">ArgNames</span><span class="p">;</span>
+ <span class="k">while</span> <span class="p">(</span><span class="n">getNextToken</span><span class="p">()</span> <span class="o">==</span> <span class="n">tok_identifier</span><span class="p">)</span>
+ <span class="n">ArgNames</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">IdentifierStr</span><span class="p">);</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">')'</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">ErrorP</span><span class="p">(</span><span class="s">"Expected ')' in prototype"</span><span class="p">);</span>
+
+ <span class="c1">// success.</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat ')'.</span>
+
+ <span class="k">return</span> <span class="k">new</span> <span class="n">PrototypeAST</span><span class="p">(</span><span class="n">FnName</span><span class="p">,</span> <span class="n">ArgNames</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="c1">/// definition ::= 'def' prototype expression</span>
+<span class="k">static</span> <span class="n">FunctionAST</span> <span class="o">*</span><span class="nf">ParseDefinition</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat def.</span>
+ <span class="n">PrototypeAST</span> <span class="o">*</span><span class="n">Proto</span> <span class="o">=</span> <span class="n">ParsePrototype</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">Proto</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">ExprAST</span> <span class="o">*</span><span class="n">E</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">())</span>
+ <span class="k">return</span> <span class="k">new</span> <span class="n">FunctionAST</span><span class="p">(</span><span class="n">Proto</span><span class="p">,</span> <span class="n">E</span><span class="p">);</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">/// toplevelexpr ::= expression</span>
+<span class="k">static</span> <span class="n">FunctionAST</span> <span class="o">*</span><span class="nf">ParseTopLevelExpr</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">ExprAST</span> <span class="o">*</span><span class="n">E</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">())</span> <span class="p">{</span>
+ <span class="c1">// Make an anonymous proto.</span>
+ <span class="n">PrototypeAST</span> <span class="o">*</span><span class="n">Proto</span> <span class="o">=</span> <span class="k">new</span> <span class="n">PrototypeAST</span><span class="p">(</span><span class="s">""</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span><span class="p">());</span>
+ <span class="k">return</span> <span class="k">new</span> <span class="n">FunctionAST</span><span class="p">(</span><span class="n">Proto</span><span class="p">,</span> <span class="n">E</span><span class="p">);</span>
+ <span class="p">}</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">/// external ::= 'extern' prototype</span>
+<span class="k">static</span> <span class="n">PrototypeAST</span> <span class="o">*</span><span class="nf">ParseExtern</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat extern.</span>
+ <span class="k">return</span> <span class="n">ParsePrototype</span><span class="p">();</span>
+<span class="p">}</span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// Quick and dirty hack</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+
+<span class="c1">// FIXME: Obviously we can do better than this</span>
+<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">GenerateUniqueName</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">root</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">static</span> <span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="kt">char</span> <span class="n">s</span><span class="p">[</span><span class="mi">16</span><span class="p">];</span>
+ <span class="n">sprintf</span><span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="s">"%s%d"</span><span class="p">,</span> <span class="n">root</span><span class="p">,</span> <span class="n">i</span><span class="o">++</span><span class="p">);</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">S</span> <span class="o">=</span> <span class="n">s</span><span class="p">;</span>
+ <span class="k">return</span> <span class="n">S</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">MakeLegalFunctionName</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">Name</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">NewName</span><span class="p">;</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">Name</span><span class="p">.</span><span class="n">length</span><span class="p">())</span>
+ <span class="k">return</span> <span class="n">GenerateUniqueName</span><span class="p">(</span><span class="s">"anon_func_"</span><span class="p">);</span>
+
+ <span class="c1">// Start with what we have</span>
+ <span class="n">NewName</span> <span class="o">=</span> <span class="n">Name</span><span class="p">;</span>
+
+ <span class="c1">// Look for a numberic first character</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">NewName</span><span class="p">.</span><span class="n">find_first_of</span><span class="p">(</span><span class="s">"0123456789"</span><span class="p">)</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">NewName</span><span class="p">.</span><span class="n">insert</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="sc">'n'</span><span class="p">);</span>
+ <span class="p">}</span>
+
+ <span class="c1">// Replace illegal characters with their ASCII equivalent</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">legal_elements</span> <span class="o">=</span>
+ <span class="s">"_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"</span><span class="p">;</span>
+ <span class="kt">size_t</span> <span class="n">pos</span><span class="p">;</span>
+ <span class="k">while</span> <span class="p">((</span><span class="n">pos</span> <span class="o">=</span> <span class="n">NewName</span><span class="p">.</span><span class="n">find_first_not_of</span><span class="p">(</span><span class="n">legal_elements</span><span class="p">))</span> <span class="o">!=</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">::</span><span class="n">npos</span><span class="p">)</span> <span class="p">{</span>
+ <span class="kt">char</span> <span class="n">old_c</span> <span class="o">=</span> <span class="n">NewName</span><span class="p">.</span><span class="n">at</span><span class="p">(</span><span class="n">pos</span><span class="p">);</span>
+ <span class="kt">char</span> <span class="n">new_str</span><span class="p">[</span><span class="mi">16</span><span class="p">];</span>
+ <span class="n">sprintf</span><span class="p">(</span><span class="n">new_str</span><span class="p">,</span> <span class="s">"%d"</span><span class="p">,</span> <span class="p">(</span><span class="kt">int</span><span class="p">)</span><span class="n">old_c</span><span class="p">);</span>
+ <span class="n">NewName</span> <span class="o">=</span> <span class="n">NewName</span><span class="p">.</span><span class="n">replace</span><span class="p">(</span><span class="n">pos</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="n">new_str</span><span class="p">);</span>
+ <span class="p">}</span>
+
+ <span class="k">return</span> <span class="n">NewName</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// MCJIT helper class</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+
+<span class="k">class</span> <span class="nc">MCJITHelper</span> <span class="p">{</span>
+<span class="nl">public:</span>
+ <span class="n">MCJITHelper</span><span class="p">(</span><span class="n">LLVMContext</span> <span class="o">&</span><span class="n">C</span><span class="p">)</span> <span class="o">:</span> <span class="n">Context</span><span class="p">(</span><span class="n">C</span><span class="p">),</span> <span class="n">OpenModule</span><span class="p">(</span><span class="nb">NULL</span><span class="p">)</span> <span class="p">{}</span>
+ <span class="o">~</span><span class="n">MCJITHelper</span><span class="p">();</span>
+
+ <span class="n">Function</span> <span class="o">*</span><span class="nf">getFunction</span><span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">FnName</span><span class="p">);</span>
+ <span class="n">Module</span> <span class="o">*</span><span class="nf">getModuleForNewFunction</span><span class="p">();</span>
+ <span class="kt">void</span> <span class="o">*</span><span class="nf">getPointerToFunction</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="kt">void</span> <span class="o">*</span><span class="nf">getSymbolAddress</span><span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="o">&</span><span class="n">Name</span><span class="p">);</span>
+ <span class="kt">void</span> <span class="nf">dump</span><span class="p">();</span>
+
+<span class="nl">private:</span>
+ <span class="k">typedef</span> <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">Module</span> <span class="o">*></span> <span class="n">ModuleVector</span><span class="p">;</span>
+ <span class="k">typedef</span> <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">ExecutionEngine</span> <span class="o">*></span> <span class="n">EngineVector</span><span class="p">;</span>
+
+ <span class="n">LLVMContext</span> <span class="o">&</span><span class="n">Context</span><span class="p">;</span>
+ <span class="n">Module</span> <span class="o">*</span><span class="n">OpenModule</span><span class="p">;</span>
+ <span class="n">ModuleVector</span> <span class="n">Modules</span><span class="p">;</span>
+ <span class="n">EngineVector</span> <span class="n">Engines</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="k">class</span> <span class="nc">HelpingMemoryManager</span> <span class="o">:</span> <span class="k">public</span> <span class="n">SectionMemoryManager</span> <span class="p">{</span>
+ <span class="n">HelpingMemoryManager</span><span class="p">(</span><span class="k">const</span> <span class="n">HelpingMemoryManager</span> <span class="o">&</span><span class="p">)</span> <span class="o">=</span> <span class="k">delete</span><span class="p">;</span>
+ <span class="kt">void</span> <span class="k">operator</span><span class="o">=</span><span class="p">(</span><span class="k">const</span> <span class="n">HelpingMemoryManager</span> <span class="o">&</span><span class="p">)</span> <span class="o">=</span> <span class="k">delete</span><span class="p">;</span>
+
+<span class="nl">public:</span>
+ <span class="n">HelpingMemoryManager</span><span class="p">(</span><span class="n">MCJITHelper</span> <span class="o">*</span><span class="n">Helper</span><span class="p">)</span> <span class="o">:</span> <span class="n">MasterHelper</span><span class="p">(</span><span class="n">Helper</span><span class="p">)</span> <span class="p">{}</span>
+ <span class="o">~</span><span class="n">HelpingMemoryManager</span><span class="p">()</span> <span class="n">override</span> <span class="p">{}</span>
+
+ <span class="c1">/// This method returns the address of the specified symbol.</span>
+ <span class="c1">/// Our implementation will attempt to find symbols in other</span>
+ <span class="c1">/// modules associated with the MCJITHelper to cross link symbols</span>
+ <span class="c1">/// from one generated module to another.</span>
+ <span class="kt">uint64_t</span> <span class="n">getSymbolAddress</span><span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="o">&</span><span class="n">Name</span><span class="p">)</span> <span class="n">override</span><span class="p">;</span>
+
+<span class="nl">private:</span>
+ <span class="n">MCJITHelper</span> <span class="o">*</span><span class="n">MasterHelper</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="kt">uint64_t</span> <span class="n">HelpingMemoryManager</span><span class="o">::</span><span class="n">getSymbolAddress</span><span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="o">&</span><span class="n">Name</span><span class="p">)</span> <span class="p">{</span>
+ <span class="kt">uint64_t</span> <span class="n">FnAddr</span> <span class="o">=</span> <span class="n">SectionMemoryManager</span><span class="o">::</span><span class="n">getSymbolAddress</span><span class="p">(</span><span class="n">Name</span><span class="p">);</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">FnAddr</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">FnAddr</span><span class="p">;</span>
+
+ <span class="kt">uint64_t</span> <span class="n">HelperFun</span> <span class="o">=</span> <span class="p">(</span><span class="kt">uint64_t</span><span class="p">)</span><span class="n">MasterHelper</span><span class="o">-></span><span class="n">getSymbolAddress</span><span class="p">(</span><span class="n">Name</span><span class="p">);</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">HelperFun</span><span class="p">)</span>
+ <span class="n">report_fatal_error</span><span class="p">(</span><span class="s">"Program used extern function '"</span> <span class="o">+</span> <span class="n">Name</span> <span class="o">+</span>
+ <span class="s">"' which could not be resolved!"</span><span class="p">);</span>
+
+ <span class="k">return</span> <span class="n">HelperFun</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="n">MCJITHelper</span><span class="o">::~</span><span class="n">MCJITHelper</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">OpenModule</span><span class="p">)</span>
+ <span class="k">delete</span> <span class="n">OpenModule</span><span class="p">;</span>
+ <span class="n">EngineVector</span><span class="o">::</span><span class="n">iterator</span> <span class="n">begin</span> <span class="o">=</span> <span class="n">Engines</span><span class="p">.</span><span class="n">begin</span><span class="p">();</span>
+ <span class="n">EngineVector</span><span class="o">::</span><span class="n">iterator</span> <span class="n">end</span> <span class="o">=</span> <span class="n">Engines</span><span class="p">.</span><span class="n">end</span><span class="p">();</span>
+ <span class="n">EngineVector</span><span class="o">::</span><span class="n">iterator</span> <span class="n">it</span><span class="p">;</span>
+ <span class="k">for</span> <span class="p">(</span><span class="n">it</span> <span class="o">=</span> <span class="n">begin</span><span class="p">;</span> <span class="n">it</span> <span class="o">!=</span> <span class="n">end</span><span class="p">;</span> <span class="o">++</span><span class="n">it</span><span class="p">)</span>
+ <span class="k">delete</span> <span class="o">*</span><span class="n">it</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="n">Function</span> <span class="o">*</span><span class="n">MCJITHelper</span><span class="o">::</span><span class="n">getFunction</span><span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">FnName</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">ModuleVector</span><span class="o">::</span><span class="n">iterator</span> <span class="n">begin</span> <span class="o">=</span> <span class="n">Modules</span><span class="p">.</span><span class="n">begin</span><span class="p">();</span>
+ <span class="n">ModuleVector</span><span class="o">::</span><span class="n">iterator</span> <span class="n">end</span> <span class="o">=</span> <span class="n">Modules</span><span class="p">.</span><span class="n">end</span><span class="p">();</span>
+ <span class="n">ModuleVector</span><span class="o">::</span><span class="n">iterator</span> <span class="n">it</span><span class="p">;</span>
+ <span class="k">for</span> <span class="p">(</span><span class="n">it</span> <span class="o">=</span> <span class="n">begin</span><span class="p">;</span> <span class="n">it</span> <span class="o">!=</span> <span class="n">end</span><span class="p">;</span> <span class="o">++</span><span class="n">it</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">Function</span> <span class="o">*</span><span class="n">F</span> <span class="o">=</span> <span class="p">(</span><span class="o">*</span><span class="n">it</span><span class="p">)</span><span class="o">-></span><span class="n">getFunction</span><span class="p">(</span><span class="n">FnName</span><span class="p">);</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">F</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">it</span> <span class="o">==</span> <span class="n">OpenModule</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">F</span><span class="p">;</span>
+
+ <span class="n">assert</span><span class="p">(</span><span class="n">OpenModule</span> <span class="o">!=</span> <span class="nb">NULL</span><span class="p">);</span>
+
+ <span class="c1">// This function is in a module that has already been JITed.</span>
+ <span class="c1">// We need to generate a new prototype for external linkage.</span>
+ <span class="n">Function</span> <span class="o">*</span><span class="n">PF</span> <span class="o">=</span> <span class="n">OpenModule</span><span class="o">-></span><span class="n">getFunction</span><span class="p">(</span><span class="n">FnName</span><span class="p">);</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">PF</span> <span class="o">&&</span> <span class="o">!</span><span class="n">PF</span><span class="o">-></span><span class="n">empty</span><span class="p">())</span> <span class="p">{</span>
+ <span class="n">ErrorF</span><span class="p">(</span><span class="s">"redefinition of function across modules"</span><span class="p">);</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="c1">// If we don't have a prototype yet, create one.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">PF</span><span class="p">)</span>
+ <span class="n">PF</span> <span class="o">=</span> <span class="n">Function</span><span class="o">::</span><span class="n">Create</span><span class="p">(</span><span class="n">F</span><span class="o">-></span><span class="n">getFunctionType</span><span class="p">(),</span> <span class="n">Function</span><span class="o">::</span><span class="n">ExternalLinkage</span><span class="p">,</span>
+ <span class="n">FnName</span><span class="p">,</span> <span class="n">OpenModule</span><span class="p">);</span>
+ <span class="k">return</span> <span class="n">PF</span><span class="p">;</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+ <span class="k">return</span> <span class="nb">NULL</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="n">Module</span> <span class="o">*</span><span class="n">MCJITHelper</span><span class="o">::</span><span class="n">getModuleForNewFunction</span><span class="p">()</span> <span class="p">{</span>
+ <span class="c1">// If we have a Module that hasn't been JITed, use that.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">OpenModule</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">OpenModule</span><span class="p">;</span>
+
+ <span class="c1">// Otherwise create a new Module.</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">ModName</span> <span class="o">=</span> <span class="n">GenerateUniqueName</span><span class="p">(</span><span class="s">"mcjit_module_"</span><span class="p">);</span>
+ <span class="n">Module</span> <span class="o">*</span><span class="n">M</span> <span class="o">=</span> <span class="k">new</span> <span class="n">Module</span><span class="p">(</span><span class="n">ModName</span><span class="p">,</span> <span class="n">Context</span><span class="p">);</span>
+ <span class="n">Modules</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">M</span><span class="p">);</span>
+ <span class="n">OpenModule</span> <span class="o">=</span> <span class="n">M</span><span class="p">;</span>
+ <span class="k">return</span> <span class="n">M</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="kt">void</span> <span class="o">*</span><span class="n">MCJITHelper</span><span class="o">::</span><span class="n">getPointerToFunction</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="c1">// See if an existing instance of MCJIT has this function.</span>
+ <span class="n">EngineVector</span><span class="o">::</span><span class="n">iterator</span> <span class="n">begin</span> <span class="o">=</span> <span class="n">Engines</span><span class="p">.</span><span class="n">begin</span><span class="p">();</span>
+ <span class="n">EngineVector</span><span class="o">::</span><span class="n">iterator</span> <span class="n">end</span> <span class="o">=</span> <span class="n">Engines</span><span class="p">.</span><span class="n">end</span><span class="p">();</span>
+ <span class="n">EngineVector</span><span class="o">::</span><span class="n">iterator</span> <span class="n">it</span><span class="p">;</span>
+ <span class="k">for</span> <span class="p">(</span><span class="n">it</span> <span class="o">=</span> <span class="n">begin</span><span class="p">;</span> <span class="n">it</span> <span class="o">!=</span> <span class="n">end</span><span class="p">;</span> <span class="o">++</span><span class="n">it</span><span class="p">)</span> <span class="p">{</span>
+ <span class="kt">void</span> <span class="o">*</span><span class="n">P</span> <span class="o">=</span> <span class="p">(</span><span class="o">*</span><span class="n">it</span><span class="p">)</span><span class="o">-></span><span class="n">getPointerToFunction</span><span class="p">(</span><span class="n">F</span><span class="p">);</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">P</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">P</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="c1">// If we didn't find the function, see if we can generate it.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">OpenModule</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">ErrStr</span><span class="p">;</span>
+ <span class="n">ExecutionEngine</span> <span class="o">*</span><span class="n">NewEngine</span> <span class="o">=</span>
+ <span class="n">EngineBuilder</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">Module</span><span class="o">></span><span class="p">(</span><span class="n">OpenModule</span><span class="p">))</span>
+ <span class="p">.</span><span class="n">setErrorStr</span><span class="p">(</span><span class="o">&</span><span class="n">ErrStr</span><span class="p">)</span>
+ <span class="p">.</span><span class="n">setMCJITMemoryManager</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">HelpingMemoryManager</span><span class="o">></span><span class="p">(</span>
+ <span class="k">new</span> <span class="n">HelpingMemoryManager</span><span class="p">(</span><span class="k">this</span><span class="p">)))</span>
+ <span class="p">.</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">NewEngine</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"Could not create ExecutionEngine: %s</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">ErrStr</span><span class="p">.</span><span class="n">c_str</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="c1">// Create a function pass manager for this engine</span>
+ <span class="k">auto</span> <span class="o">*</span><span class="n">FPM</span> <span class="o">=</span> <span class="k">new</span> <span class="n">legacy</span><span class="o">::</span><span class="n">FunctionPassManager</span><span class="p">(</span><span class="n">OpenModule</span><span class="p">);</span>
+
+ <span class="c1">// Set up the optimizer pipeline. Start with registering info about how the</span>
+ <span class="c1">// target lays out data structures.</span>
+ <span class="n">OpenModule</span><span class="o">-></span><span class="n">setDataLayout</span><span class="p">(</span><span class="o">*</span><span class="n">NewEngine</span><span class="o">-></span><span class="n">getDataLayout</span><span class="p">());</span>
+ <span class="c1">// Provide basic AliasAnalysis support for GVN.</span>
+ <span class="n">FPM</span><span class="o">-></span><span class="n">add</span><span class="p">(</span><span class="n">createBasicAliasAnalysisPass</span><span class="p">());</span>
+ <span class="c1">// Promote allocas to registers.</span>
+ <span class="n">FPM</span><span class="o">-></span><span class="n">add</span><span class="p">(</span><span class="n">createPromoteMemoryToRegisterPass</span><span class="p">());</span>
+ <span class="c1">// Do simple "peephole" optimizations and bit-twiddling optzns.</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="c1">// Reassociate expressions.</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="c1">// Eliminate Common SubExpressions.</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="c1">// Simplify the control flow graph (deleting unreachable blocks, etc).</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">// For each function in the module</span>
+ <span class="n">Module</span><span class="o">::</span><span class="n">iterator</span> <span class="n">it</span><span class="p">;</span>
+ <span class="n">Module</span><span class="o">::</span><span class="n">iterator</span> <span class="n">end</span> <span class="o">=</span> <span class="n">OpenModule</span><span class="o">-></span><span class="n">end</span><span class="p">();</span>
+ <span class="k">for</span> <span class="p">(</span><span class="n">it</span> <span class="o">=</span> <span class="n">OpenModule</span><span class="o">-></span><span class="n">begin</span><span class="p">();</span> <span class="n">it</span> <span class="o">!=</span> <span class="n">end</span><span class="p">;</span> <span class="o">++</span><span class="n">it</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">// Run the FPM on this function</span>
+ <span class="n">FPM</span><span class="o">-></span><span class="n">run</span><span class="p">(</span><span class="o">*</span><span class="n">it</span><span class="p">);</span>
+ <span class="p">}</span>
+
+ <span class="c1">// We don't need this anymore</span>
+ <span class="k">delete</span> <span class="n">FPM</span><span class="p">;</span>
+
+ <span class="n">OpenModule</span> <span class="o">=</span> <span class="nb">NULL</span><span class="p">;</span>
+ <span class="n">Engines</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">NewEngine</span><span class="p">);</span>
+ <span class="n">NewEngine</span><span class="o">-></span><span class="n">finalizeObject</span><span class="p">();</span>
+ <span class="k">return</span> <span class="n">NewEngine</span><span class="o">-></span><span class="n">getPointerToFunction</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="nb">NULL</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="kt">void</span> <span class="o">*</span><span class="n">MCJITHelper</span><span class="o">::</span><span class="n">getSymbolAddress</span><span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="o">&</span><span class="n">Name</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">// Look for the symbol in each of our execution engines.</span>
+ <span class="n">EngineVector</span><span class="o">::</span><span class="n">iterator</span> <span class="n">begin</span> <span class="o">=</span> <span class="n">Engines</span><span class="p">.</span><span class="n">begin</span><span class="p">();</span>
+ <span class="n">EngineVector</span><span class="o">::</span><span class="n">iterator</span> <span class="n">end</span> <span class="o">=</span> <span class="n">Engines</span><span class="p">.</span><span class="n">end</span><span class="p">();</span>
+ <span class="n">EngineVector</span><span class="o">::</span><span class="n">iterator</span> <span class="n">it</span><span class="p">;</span>
+ <span class="k">for</span> <span class="p">(</span><span class="n">it</span> <span class="o">=</span> <span class="n">begin</span><span class="p">;</span> <span class="n">it</span> <span class="o">!=</span> <span class="n">end</span><span class="p">;</span> <span class="o">++</span><span class="n">it</span><span class="p">)</span> <span class="p">{</span>
+ <span class="kt">uint64_t</span> <span class="n">FAddr</span> <span class="o">=</span> <span class="p">(</span><span class="o">*</span><span class="n">it</span><span class="p">)</span><span class="o">-></span><span class="n">getFunctionAddress</span><span class="p">(</span><span class="n">Name</span><span class="p">);</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">FAddr</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="p">(</span><span class="kt">void</span> <span class="o">*</span><span class="p">)</span><span class="n">FAddr</span><span class="p">;</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+ <span class="k">return</span> <span class="nb">NULL</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="kt">void</span> <span class="n">MCJITHelper</span><span class="o">::</span><span class="n">dump</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">ModuleVector</span><span class="o">::</span><span class="n">iterator</span> <span class="n">begin</span> <span class="o">=</span> <span class="n">Modules</span><span class="p">.</span><span class="n">begin</span><span class="p">();</span>
+ <span class="n">ModuleVector</span><span class="o">::</span><span class="n">iterator</span> <span class="n">end</span> <span class="o">=</span> <span class="n">Modules</span><span class="p">.</span><span class="n">end</span><span class="p">();</span>
+ <span class="n">ModuleVector</span><span class="o">::</span><span class="n">iterator</span> <span class="n">it</span><span class="p">;</span>
+ <span class="k">for</span> <span class="p">(</span><span class="n">it</span> <span class="o">=</span> <span class="n">begin</span><span class="p">;</span> <span class="n">it</span> <span class="o">!=</span> <span class="n">end</span><span class="p">;</span> <span class="o">++</span><span class="n">it</span><span class="p">)</span>
+ <span class="p">(</span><span class="o">*</span><span class="n">it</span><span class="p">)</span><span class="o">-></span><span class="n">dump</span><span class="p">();</span>
+<span class="p">}</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// Code Generation</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+
+<span class="k">static</span> <span class="n">MCJITHelper</span> <span class="o">*</span><span class="n">JITHelper</span><span class="p">;</span>
+<span class="k">static</span> <span class="n">IRBuilder</span><span class="o"><></span> <span class="n">Builder</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">());</span>
+<span class="k">static</span> <span class="n">std</span><span class="o">::</span><span class="n">map</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">,</span> <span class="n">Value</span> <span class="o">*></span> <span class="n">NamedValues</span><span class="p">;</span>
+
+<span class="n">Value</span> <span class="o">*</span><span class="nf">ErrorV</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">Str</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">Error</span><span class="p">(</span><span class="n">Str</span><span class="p">);</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="n">Value</span> <span class="o">*</span><span class="n">NumberExprAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="n">ConstantFP</span><span class="o">::</span><span class="n">get</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">(),</span> <span class="n">APFloat</span><span class="p">(</span><span class="n">Val</span><span class="p">));</span>
+<span class="p">}</span>
+
+<span class="n">Value</span> <span class="o">*</span><span class="n">VariableExprAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="c1">// Look this variable up in the function.</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">V</span> <span class="o">=</span> <span class="n">NamedValues</span><span class="p">[</span><span class="n">Name</span><span class="p">];</span>
+ <span class="k">return</span> <span class="n">V</span> <span class="o">?</span> <span class="n">V</span> <span class="o">:</span> <span class="n">ErrorV</span><span class="p">(</span><span class="s">"Unknown variable name"</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="n">Value</span> <span class="o">*</span><span class="n">BinaryExprAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">L</span> <span class="o">=</span> <span class="n">LHS</span><span class="o">-></span><span class="n">Codegen</span><span class="p">();</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">R</span> <span class="o">=</span> <span class="n">RHS</span><span class="o">-></span><span class="n">Codegen</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">L</span> <span class="o">==</span> <span class="mi">0</span> <span class="o">||</span> <span class="n">R</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">switch</span> <span class="p">(</span><span class="n">Op</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">case</span> <span class="sc">'+'</span>:
+ <span class="k">return</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateFAdd</span><span class="p">(</span><span class="n">L</span><span class="p">,</span> <span class="n">R</span><span class="p">,</span> <span class="s">"addtmp"</span><span class="p">);</span>
+ <span class="k">case</span> <span class="sc">'-'</span>:
+ <span class="k">return</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateFSub</span><span class="p">(</span><span class="n">L</span><span class="p">,</span> <span class="n">R</span><span class="p">,</span> <span class="s">"subtmp"</span><span class="p">);</span>
+ <span class="k">case</span> <span class="sc">'*'</span>:
+ <span class="k">return</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateFMul</span><span class="p">(</span><span class="n">L</span><span class="p">,</span> <span class="n">R</span><span class="p">,</span> <span class="s">"multmp"</span><span class="p">);</span>
+ <span class="k">case</span> <span class="sc">'<'</span>:
+ <span class="n">L</span> <span class="o">=</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateFCmpULT</span><span class="p">(</span><span class="n">L</span><span class="p">,</span> <span class="n">R</span><span class="p">,</span> <span class="s">"cmptmp"</span><span class="p">);</span>
+ <span class="c1">// Convert bool 0/1 to double 0.0 or 1.0</span>
+ <span class="k">return</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateUIToFP</span><span class="p">(</span><span class="n">L</span><span class="p">,</span> <span class="n">Type</span><span class="o">::</span><span class="n">getDoubleTy</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">()),</span>
+ <span class="s">"booltmp"</span><span class="p">);</span>
+ <span class="nl">default:</span>
+ <span class="k">return</span> <span class="nf">ErrorV</span><span class="p">(</span><span class="s">"invalid binary operator"</span><span class="p">);</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="n">Value</span> <span class="o">*</span><span class="n">CallExprAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="c1">// Look up the name in the global module table.</span>
+ <span class="n">Function</span> <span class="o">*</span><span class="n">CalleeF</span> <span class="o">=</span> <span class="n">JITHelper</span><span class="o">-></span><span class="n">getFunction</span><span class="p">(</span><span class="n">Callee</span><span class="p">);</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CalleeF</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">ErrorV</span><span class="p">(</span><span class="s">"Unknown function referenced"</span><span class="p">);</span>
+
+ <span class="c1">// If argument mismatch error.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CalleeF</span><span class="o">-></span><span class="n">arg_size</span><span class="p">()</span> <span class="o">!=</span> <span class="n">Args</span><span class="p">.</span><span class="n">size</span><span class="p">())</span>
+ <span class="k">return</span> <span class="n">ErrorV</span><span class="p">(</span><span class="s">"Incorrect # arguments passed"</span><span class="p">);</span>
+
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">Value</span> <span class="o">*></span> <span class="n">ArgsV</span><span class="p">;</span>
+ <span class="k">for</span> <span class="p">(</span><span class="kt">unsigned</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">,</span> <span class="n">e</span> <span class="o">=</span> <span class="n">Args</span><span class="p">.</span><span class="n">size</span><span class="p">();</span> <span class="n">i</span> <span class="o">!=</span> <span class="n">e</span><span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">ArgsV</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">Args</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">-></span><span class="n">Codegen</span><span class="p">());</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">ArgsV</span><span class="p">.</span><span class="n">back</span><span class="p">()</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="k">return</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateCall</span><span class="p">(</span><span class="n">CalleeF</span><span class="p">,</span> <span class="n">ArgsV</span><span class="p">,</span> <span class="s">"calltmp"</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="n">Function</span> <span class="o">*</span><span class="n">PrototypeAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="c1">// Make the function type: double(double,double) etc.</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">Type</span> <span class="o">*></span> <span class="n">Doubles</span><span class="p">(</span><span class="n">Args</span><span class="p">.</span><span class="n">size</span><span class="p">(),</span>
+ <span class="n">Type</span><span class="o">::</span><span class="n">getDoubleTy</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">()));</span>
+ <span class="n">FunctionType</span> <span class="o">*</span><span class="n">FT</span> <span class="o">=</span>
+ <span class="n">FunctionType</span><span class="o">::</span><span class="n">get</span><span class="p">(</span><span class="n">Type</span><span class="o">::</span><span class="n">getDoubleTy</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">()),</span> <span class="n">Doubles</span><span class="p">,</span> <span class="nb">false</span><span class="p">);</span>
+
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">FnName</span> <span class="o">=</span> <span class="n">MakeLegalFunctionName</span><span class="p">(</span><span class="n">Name</span><span class="p">);</span>
+
+ <span class="n">Module</span> <span class="o">*</span><span class="n">M</span> <span class="o">=</span> <span class="n">JITHelper</span><span class="o">-></span><span class="n">getModuleForNewFunction</span><span class="p">();</span>
+
+ <span class="n">Function</span> <span class="o">*</span><span class="n">F</span> <span class="o">=</span> <span class="n">Function</span><span class="o">::</span><span class="n">Create</span><span class="p">(</span><span class="n">FT</span><span class="p">,</span> <span class="n">Function</span><span class="o">::</span><span class="n">ExternalLinkage</span><span class="p">,</span> <span class="n">FnName</span><span class="p">,</span> <span class="n">M</span><span class="p">);</span>
+
+ <span class="c1">// If F conflicted, there was already something named 'Name'. If it has a</span>
+ <span class="c1">// body, don't allow redefinition or reextern.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">F</span><span class="o">-></span><span class="n">getName</span><span class="p">()</span> <span class="o">!=</span> <span class="n">FnName</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">// Delete the one we just made and get the existing one.</span>
+ <span class="n">F</span><span class="o">-></span><span class="n">eraseFromParent</span><span class="p">();</span>
+ <span class="n">F</span> <span class="o">=</span> <span class="n">JITHelper</span><span class="o">-></span><span class="n">getFunction</span><span class="p">(</span><span class="n">Name</span><span class="p">);</span>
+ <span class="c1">// If F already has a body, reject this.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">F</span><span class="o">-></span><span class="n">empty</span><span class="p">())</span> <span class="p">{</span>
+ <span class="n">ErrorF</span><span class="p">(</span><span class="s">"redefinition of function"</span><span class="p">);</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="c1">// If F took a different number of args, reject.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">F</span><span class="o">-></span><span class="n">arg_size</span><span class="p">()</span> <span class="o">!=</span> <span class="n">Args</span><span class="p">.</span><span class="n">size</span><span class="p">())</span> <span class="p">{</span>
+ <span class="n">ErrorF</span><span class="p">(</span><span class="s">"redefinition of function with different # args"</span><span class="p">);</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+
+ <span class="c1">// Set names for all arguments.</span>
+ <span class="kt">unsigned</span> <span class="n">Idx</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="k">for</span> <span class="p">(</span><span class="n">Function</span><span class="o">::</span><span class="n">arg_iterator</span> <span class="n">AI</span> <span class="o">=</span> <span class="n">F</span><span class="o">-></span><span class="n">arg_begin</span><span class="p">();</span> <span class="n">Idx</span> <span class="o">!=</span> <span class="n">Args</span><span class="p">.</span><span class="n">size</span><span class="p">();</span>
+ <span class="o">++</span><span class="n">AI</span><span class="p">,</span> <span class="o">++</span><span class="n">Idx</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">AI</span><span class="o">-></span><span class="n">setName</span><span class="p">(</span><span class="n">Args</span><span class="p">[</span><span class="n">Idx</span><span class="p">]);</span>
+
+ <span class="c1">// Add arguments to variable symbol table.</span>
+ <span class="n">NamedValues</span><span class="p">[</span><span class="n">Args</span><span class="p">[</span><span class="n">Idx</span><span class="p">]]</span> <span class="o">=</span> <span class="n">AI</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="k">return</span> <span class="n">F</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="n">Function</span> <span class="o">*</span><span class="n">FunctionAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">NamedValues</span><span class="p">.</span><span class="n">clear</span><span class="p">();</span>
+
+ <span class="n">Function</span> <span class="o">*</span><span class="n">TheFunction</span> <span class="o">=</span> <span class="n">Proto</span><span class="o">-></span><span class="n">Codegen</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">TheFunction</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="c1">// Create a new basic block to start insertion into.</span>
+ <span class="n">BasicBlock</span> <span class="o">*</span><span class="n">BB</span> <span class="o">=</span> <span class="n">BasicBlock</span><span class="o">::</span><span class="n">Create</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">(),</span> <span class="s">"entry"</span><span class="p">,</span> <span class="n">TheFunction</span><span class="p">);</span>
+ <span class="n">Builder</span><span class="p">.</span><span class="n">SetInsertPoint</span><span class="p">(</span><span class="n">BB</span><span class="p">);</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">Value</span> <span class="o">*</span><span class="n">RetVal</span> <span class="o">=</span> <span class="n">Body</span><span class="o">-></span><span class="n">Codegen</span><span class="p">())</span> <span class="p">{</span>
+ <span class="c1">// Finish off the function.</span>
+ <span class="n">Builder</span><span class="p">.</span><span class="n">CreateRet</span><span class="p">(</span><span class="n">RetVal</span><span class="p">);</span>
+
+ <span class="c1">// Validate the generated code, checking for consistency.</span>
+ <span class="n">verifyFunction</span><span class="p">(</span><span class="o">*</span><span class="n">TheFunction</span><span class="p">);</span>
+
+ <span class="k">return</span> <span class="n">TheFunction</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="c1">// Error reading body, remove function.</span>
+ <span class="n">TheFunction</span><span class="o">-></span><span class="n">eraseFromParent</span><span class="p">();</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// Top-Level parsing and JIT Driver</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+
+<span class="k">static</span> <span class="kt">void</span> <span class="n">HandleDefinition</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">FunctionAST</span> <span class="o">*</span><span class="n">F</span> <span class="o">=</span> <span class="n">ParseDefinition</span><span class="p">())</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">Function</span> <span class="o">*</span><span class="n">LF</span> <span class="o">=</span> <span class="n">F</span><span class="o">-></span><span class="n">Codegen</span><span class="p">())</span> <span class="p">{</span>
+ <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"Read function definition:"</span><span class="p">);</span>
+ <span class="n">LF</span><span class="o">-></span><span class="n">dump</span><span class="p">();</span>
+ <span class="p">}</span>
+ <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+ <span class="c1">// Skip token for error recovery.</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="k">static</span> <span class="kt">void</span> <span class="n">HandleExtern</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">PrototypeAST</span> <span class="o">*</span><span class="n">P</span> <span class="o">=</span> <span class="n">ParseExtern</span><span class="p">())</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">Function</span> <span class="o">*</span><span class="n">F</span> <span class="o">=</span> <span class="n">P</span><span class="o">-></span><span class="n">Codegen</span><span class="p">())</span> <span class="p">{</span>
+ <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"Read extern: "</span><span class="p">);</span>
+ <span class="n">F</span><span class="o">-></span><span class="n">dump</span><span class="p">();</span>
+ <span class="p">}</span>
+ <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+ <span class="c1">// Skip token for error recovery.</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="k">static</span> <span class="kt">void</span> <span class="n">HandleTopLevelExpression</span><span class="p">()</span> <span class="p">{</span>
+ <span class="c1">// Evaluate a top-level expression into an anonymous function.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">FunctionAST</span> <span class="o">*</span><span class="n">F</span> <span class="o">=</span> <span class="n">ParseTopLevelExpr</span><span class="p">())</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">Function</span> <span class="o">*</span><span class="n">LF</span> <span class="o">=</span> <span class="n">F</span><span class="o">-></span><span class="n">Codegen</span><span class="p">())</span> <span class="p">{</span>
+ <span class="c1">// JIT the function, returning a function pointer.</span>
+ <span class="kt">void</span> <span class="o">*</span><span class="n">FPtr</span> <span class="o">=</span> <span class="n">JITHelper</span><span class="o">-></span><span class="n">getPointerToFunction</span><span class="p">(</span><span class="n">LF</span><span class="p">);</span>
+
+ <span class="c1">// Cast it to the right type (takes no arguments, returns a double) so we</span>
+ <span class="c1">// can call it as a native function.</span>
+ <span class="kt">double</span> <span class="p">(</span><span class="o">*</span><span class="n">FP</span><span class="p">)()</span> <span class="o">=</span> <span class="p">(</span><span class="kt">double</span> <span class="p">(</span><span class="o">*</span><span class="p">)())(</span><span class="kt">intptr_t</span><span class="p">)</span><span class="n">FPtr</span><span class="p">;</span>
+ <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"Evaluated to %f</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">FP</span><span class="p">());</span>
+ <span class="p">}</span>
+ <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+ <span class="c1">// Skip token for error recovery.</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="c1">/// top ::= definition | external | expression | ';'</span>
+<span class="k">static</span> <span class="kt">void</span> <span class="n">MainLoop</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">while</span> <span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"ready> "</span><span class="p">);</span>
+ <span class="k">switch</span> <span class="p">(</span><span class="n">CurTok</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">case</span> <span class="n">tok_eof</span>:
+ <span class="k">return</span><span class="p">;</span>
+ <span class="k">case</span> <span class="sc">';'</span>:
+ <span class="n">getNextToken</span><span class="p">();</span>
+ <span class="k">break</span><span class="p">;</span> <span class="c1">// ignore top-level semicolons.</span>
+ <span class="k">case</span> <span class="n">tok_def</span>:
+ <span class="n">HandleDefinition</span><span class="p">();</span>
+ <span class="k">break</span><span class="p">;</span>
+ <span class="k">case</span> <span class="n">tok_extern</span>:
+ <span class="n">HandleExtern</span><span class="p">();</span>
+ <span class="k">break</span><span class="p">;</span>
+ <span class="nl">default:</span>
+ <span class="n">HandleTopLevelExpression</span><span class="p">();</span>
+ <span class="k">break</span><span class="p">;</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// "Library" functions that can be "extern'd" from user code.</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+
+<span class="c1">/// putchard - putchar that takes a double and returns 0.</span>
+<span class="k">extern</span> <span class="s">"C"</span> <span class="kt">double</span> <span class="n">putchard</span><span class="p">(</span><span class="kt">double</span> <span class="n">X</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">putchar</span><span class="p">((</span><span class="kt">char</span><span class="p">)</span><span class="n">X</span><span class="p">);</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// Main driver code.</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+
+<span class="kt">int</span> <span class="n">main</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">InitializeNativeTarget</span><span class="p">();</span>
+ <span class="n">InitializeNativeTargetAsmPrinter</span><span class="p">();</span>
+ <span class="n">InitializeNativeTargetAsmParser</span><span class="p">();</span>
+ <span class="n">LLVMContext</span> <span class="o">&</span><span class="n">Context</span> <span class="o">=</span> <span class="n">getGlobalContext</span><span class="p">();</span>
+ <span class="n">JITHelper</span> <span class="o">=</span> <span class="k">new</span> <span class="n">MCJITHelper</span><span class="p">(</span><span class="n">Context</span><span class="p">);</span>
+
+ <span class="c1">// Install standard binary operators.</span>
+ <span class="c1">// 1 is lowest precedence.</span>
+ <span class="n">BinopPrecedence</span><span class="p">[</span><span class="sc">'<'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">10</span><span class="p">;</span>
+ <span class="n">BinopPrecedence</span><span class="p">[</span><span class="sc">'+'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">20</span><span class="p">;</span>
+ <span class="n">BinopPrecedence</span><span class="p">[</span><span class="sc">'-'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">20</span><span class="p">;</span>
+ <span class="n">BinopPrecedence</span><span class="p">[</span><span class="sc">'*'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">40</span><span class="p">;</span> <span class="c1">// highest.</span>
+
+ <span class="c1">// Prime the first token.</span>
+ <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"ready> "</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+
+ <span class="c1">// Run the main "interpreter loop" now.</span>
+ <span class="n">MainLoop</span><span class="p">();</span>
+
+ <span class="c1">// Print out all of the generated code.</span>
+ <span class="n">JITHelper</span><span class="o">-></span><span class="n">dump</span><span class="p">();</span>
+
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p><a class="reference external" href="LangImpl5.html">Next: Extending the language: control flow</a></p>
+</div>
+</div>
+
+
+ </div>
+ </div>
+ <div class="clearer"></div>
+ </div>
+ <div class="related">
+ <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="LangImpl5.html" title="5. Kaleidoscope: Extending the Language: Control Flow"
+ >next</a> |</li>
+ <li class="right" >
+ <a href="LangImpl3.html" title="3. Kaleidoscope: Code generation to LLVM IR"
+ >previous</a> |</li>
+ <li><a href="http://llvm.org/">LLVM Home</a> | </li>
+ <li><a href="../index.html">Documentation</a>»</li>
+
+ <li><a href="index.html" >LLVM Tutorial: Table of Contents</a> »</li>
+ </ul>
+ </div>
+ <div class="footer">
+ © Copyright 2003-2016, LLVM Project.
+ Last updated on 2016-01-04.
+ Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.2.3.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/3.7.1/docs/tutorial/LangImpl5.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/3.7.1/docs/tutorial/LangImpl5.html?rev=257950&view=auto
==============================================================================
--- www-releases/trunk/3.7.1/docs/tutorial/LangImpl5.html (added)
+++ www-releases/trunk/3.7.1/docs/tutorial/LangImpl5.html Fri Jan 15 17:13:16 2016
@@ -0,0 +1,1721 @@
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+ <title>5. Kaleidoscope: Extending the Language: Control Flow — LLVM 3.7 documentation</title>
+
+ <link rel="stylesheet" href="../_static/llvm-theme.css" type="text/css" />
+ <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
+
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: '../',
+ VERSION: '3.7',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true
+ };
+ </script>
+ <script type="text/javascript" src="../_static/jquery.js"></script>
+ <script type="text/javascript" src="../_static/underscore.js"></script>
+ <script type="text/javascript" src="../_static/doctools.js"></script>
+ <link rel="top" title="LLVM 3.7 documentation" href="../index.html" />
+ <link rel="up" title="LLVM Tutorial: Table of Contents" href="index.html" />
+ <link rel="next" title="6. Kaleidoscope: Extending the Language: User-defined Operators" href="LangImpl6.html" />
+ <link rel="prev" title="4. Kaleidoscope: Adding JIT and Optimizer Support" href="LangImpl4.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">
+ <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="LangImpl6.html" title="6. Kaleidoscope: Extending the Language: User-defined Operators"
+ accesskey="N">next</a> |</li>
+ <li class="right" >
+ <a href="LangImpl4.html" title="4. Kaleidoscope: Adding JIT and Optimizer Support"
+ accesskey="P">previous</a> |</li>
+ <li><a href="http://llvm.org/">LLVM Home</a> | </li>
+ <li><a href="../index.html">Documentation</a>»</li>
+
+ <li><a href="index.html" accesskey="U">LLVM Tutorial: Table of Contents</a> »</li>
+ </ul>
+ </div>
+
+
+ <div class="document">
+ <div class="documentwrapper">
+ <div class="body">
+
+ <div class="section" id="kaleidoscope-extending-the-language-control-flow">
+<h1>5. Kaleidoscope: Extending the Language: Control Flow<a class="headerlink" href="#kaleidoscope-extending-the-language-control-flow" title="Permalink to this headline">¶</a></h1>
+<div class="contents local topic" id="contents">
+<ul class="simple">
+<li><a class="reference internal" href="#chapter-5-introduction" id="id1">Chapter 5 Introduction</a></li>
+<li><a class="reference internal" href="#if-then-else" id="id2">If/Then/Else</a><ul>
+<li><a class="reference internal" href="#lexer-extensions-for-if-then-else" id="id3">Lexer Extensions for If/Then/Else</a></li>
+<li><a class="reference internal" href="#ast-extensions-for-if-then-else" id="id4">AST Extensions for If/Then/Else</a></li>
+<li><a class="reference internal" href="#parser-extensions-for-if-then-else" id="id5">Parser Extensions for If/Then/Else</a></li>
+<li><a class="reference internal" href="#llvm-ir-for-if-then-else" id="id6">LLVM IR for If/Then/Else</a></li>
+<li><a class="reference internal" href="#code-generation-for-if-then-else" id="id7">Code Generation for If/Then/Else</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#for-loop-expression" id="id8">‘for’ Loop Expression</a><ul>
+<li><a class="reference internal" href="#lexer-extensions-for-the-for-loop" id="id9">Lexer Extensions for the ‘for’ Loop</a></li>
+<li><a class="reference internal" href="#ast-extensions-for-the-for-loop" id="id10">AST Extensions for the ‘for’ Loop</a></li>
+<li><a class="reference internal" href="#parser-extensions-for-the-for-loop" id="id11">Parser Extensions for the ‘for’ Loop</a></li>
+<li><a class="reference internal" href="#llvm-ir-for-the-for-loop" id="id12">LLVM IR for the ‘for’ Loop</a></li>
+<li><a class="reference internal" href="#code-generation-for-the-for-loop" id="id13">Code Generation for the ‘for’ Loop</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#full-code-listing" id="id14">Full Code Listing</a></li>
+</ul>
+</div>
+<div class="section" id="chapter-5-introduction">
+<h2><a class="toc-backref" href="#id1">5.1. Chapter 5 Introduction</a><a class="headerlink" href="#chapter-5-introduction" title="Permalink to this headline">¶</a></h2>
+<p>Welcome to Chapter 5 of the “<a class="reference external" href="index.html">Implementing a language with
+LLVM</a>” tutorial. Parts 1-4 described the implementation of
+the simple Kaleidoscope language and included support for generating
+LLVM IR, followed by optimizations and a JIT compiler. Unfortunately, as
+presented, Kaleidoscope is mostly useless: it has no control flow other
+than call and return. This means that you can’t have conditional
+branches in the code, significantly limiting its power. In this episode
+of “build that compiler”, we’ll extend Kaleidoscope to have an
+if/then/else expression plus a simple ‘for’ loop.</p>
+</div>
+<div class="section" id="if-then-else">
+<h2><a class="toc-backref" href="#id2">5.2. If/Then/Else</a><a class="headerlink" href="#if-then-else" title="Permalink to this headline">¶</a></h2>
+<p>Extending Kaleidoscope to support if/then/else is quite straightforward.
+It basically requires adding support for this “new” concept to the
+lexer, parser, AST, and LLVM code emitter. This example is nice, because
+it shows how easy it is to “grow” a language over time, incrementally
+extending it as new ideas are discovered.</p>
+<p>Before we get going on “how” we add this extension, lets talk about
+“what” we want. The basic idea is that we want to be able to write this
+sort of thing:</p>
+<div class="highlight-python"><div class="highlight"><pre>def fib(x)
+ if x < 3 then
+ 1
+ else
+ fib(x-1)+fib(x-2);
+</pre></div>
+</div>
+<p>In Kaleidoscope, every construct is an expression: there are no
+statements. As such, the if/then/else expression needs to return a value
+like any other. Since we’re using a mostly functional form, we’ll have
+it evaluate its conditional, then return the ‘then’ or ‘else’ value
+based on how the condition was resolved. This is very similar to the C
+”?:” expression.</p>
+<p>The semantics of the if/then/else expression is that it evaluates the
+condition to a boolean equality value: 0.0 is considered to be false and
+everything else is considered to be true. If the condition is true, the
+first subexpression is evaluated and returned, if the condition is
+false, the second subexpression is evaluated and returned. Since
+Kaleidoscope allows side-effects, this behavior is important to nail
+down.</p>
+<p>Now that we know what we “want”, lets break this down into its
+constituent pieces.</p>
+<div class="section" id="lexer-extensions-for-if-then-else">
+<h3><a class="toc-backref" href="#id3">5.2.1. Lexer Extensions for If/Then/Else</a><a class="headerlink" href="#lexer-extensions-for-if-then-else" title="Permalink to this headline">¶</a></h3>
+<p>The lexer extensions are straightforward. First we add new enum values
+for the relevant tokens:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">// control</span>
+<span class="n">tok_if</span> <span class="o">=</span> <span class="o">-</span><span class="mi">6</span><span class="p">,</span> <span class="n">tok_then</span> <span class="o">=</span> <span class="o">-</span><span class="mi">7</span><span class="p">,</span> <span class="n">tok_else</span> <span class="o">=</span> <span class="o">-</span><span class="mi">8</span><span class="p">,</span>
+</pre></div>
+</div>
+<p>Once we have that, we recognize the new keywords in the lexer. This is
+pretty simple stuff:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="p">...</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"def"</span><span class="p">)</span> <span class="k">return</span> <span class="n">tok_def</span><span class="p">;</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"extern"</span><span class="p">)</span> <span class="k">return</span> <span class="n">tok_extern</span><span class="p">;</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"if"</span><span class="p">)</span> <span class="k">return</span> <span class="n">tok_if</span><span class="p">;</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"then"</span><span class="p">)</span> <span class="k">return</span> <span class="n">tok_then</span><span class="p">;</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"else"</span><span class="p">)</span> <span class="k">return</span> <span class="n">tok_else</span><span class="p">;</span>
+<span class="k">return</span> <span class="n">tok_identifier</span><span class="p">;</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="ast-extensions-for-if-then-else">
+<h3><a class="toc-backref" href="#id4">5.2.2. AST Extensions for If/Then/Else</a><a class="headerlink" href="#ast-extensions-for-if-then-else" title="Permalink to this headline">¶</a></h3>
+<p>To represent the new expression we add a new AST node for it:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">/// IfExprAST - Expression class for if/then/else.</span>
+<span class="k">class</span> <span class="nc">IfExprAST</span> <span class="o">:</span> <span class="k">public</span> <span class="n">ExprAST</span> <span class="p">{</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Cond</span><span class="p">,</span> <span class="o">*</span><span class="n">Then</span><span class="p">,</span> <span class="o">*</span><span class="n">Else</span><span class="p">;</span>
+<span class="nl">public:</span>
+ <span class="n">IfExprAST</span><span class="p">(</span><span class="n">ExprAST</span> <span class="o">*</span><span class="n">cond</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">then</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">_else</span><span class="p">)</span>
+ <span class="o">:</span> <span class="n">Cond</span><span class="p">(</span><span class="n">cond</span><span class="p">),</span> <span class="n">Then</span><span class="p">(</span><span class="n">then</span><span class="p">),</span> <span class="n">Else</span><span class="p">(</span><span class="n">_else</span><span class="p">)</span> <span class="p">{}</span>
+ <span class="k">virtual</span> <span class="n">Value</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">();</span>
+<span class="p">};</span>
+</pre></div>
+</div>
+<p>The AST node just has pointers to the various subexpressions.</p>
+</div>
+<div class="section" id="parser-extensions-for-if-then-else">
+<h3><a class="toc-backref" href="#id5">5.2.3. Parser Extensions for If/Then/Else</a><a class="headerlink" href="#parser-extensions-for-if-then-else" title="Permalink to this headline">¶</a></h3>
+<p>Now that we have the relevant tokens coming from the lexer and we have
+the AST node to build, our parsing logic is relatively straightforward.
+First we define a new parsing function:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">/// ifexpr ::= 'if' expression 'then' expression 'else' expression</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseIfExpr</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat the if.</span>
+
+ <span class="c1">// condition.</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Cond</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">Cond</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="n">tok_then</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"expected then"</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat the then</span>
+
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Then</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">Then</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="n">tok_else</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"expected else"</span><span class="p">);</span>
+
+ <span class="n">getNextToken</span><span class="p">();</span>
+
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Else</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">Else</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">return</span> <span class="k">new</span> <span class="n">IfExprAST</span><span class="p">(</span><span class="n">Cond</span><span class="p">,</span> <span class="n">Then</span><span class="p">,</span> <span class="n">Else</span><span class="p">);</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>Next we hook it up as a primary expression:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParsePrimary</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">switch</span> <span class="p">(</span><span class="n">CurTok</span><span class="p">)</span> <span class="p">{</span>
+ <span class="nl">default:</span> <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"unknown token when expecting an expression"</span><span class="p">);</span>
+ <span class="k">case</span> <span class="n">tok_identifier</span>: <span class="k">return</span> <span class="n">ParseIdentifierExpr</span><span class="p">();</span>
+ <span class="k">case</span> <span class="n">tok_number</span>: <span class="k">return</span> <span class="n">ParseNumberExpr</span><span class="p">();</span>
+ <span class="k">case</span> <span class="sc">'('</span>: <span class="k">return</span> <span class="n">ParseParenExpr</span><span class="p">();</span>
+ <span class="k">case</span> <span class="n">tok_if</span>: <span class="k">return</span> <span class="n">ParseIfExpr</span><span class="p">();</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="llvm-ir-for-if-then-else">
+<h3><a class="toc-backref" href="#id6">5.2.4. LLVM IR for If/Then/Else</a><a class="headerlink" href="#llvm-ir-for-if-then-else" title="Permalink to this headline">¶</a></h3>
+<p>Now that we have it parsing and building the AST, the final piece is
+adding LLVM code generation support. This is the most interesting part
+of the if/then/else example, because this is where it starts to
+introduce new concepts. All of the code above has been thoroughly
+described in previous chapters.</p>
+<p>To motivate the code we want to produce, lets take a look at a simple
+example. Consider:</p>
+<div class="highlight-python"><div class="highlight"><pre>extern foo();
+extern bar();
+def baz(x) if x then foo() else bar();
+</pre></div>
+</div>
+<p>If you disable optimizations, the code you’ll (soon) get from
+Kaleidoscope looks like this:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="k">declare</span> <span class="kt">double</span> <span class="vg">@foo</span><span class="p">()</span>
+
+<span class="k">declare</span> <span class="kt">double</span> <span class="vg">@bar</span><span class="p">()</span>
+
+<span class="k">define</span> <span class="kt">double</span> <span class="vg">@baz</span><span class="p">(</span><span class="kt">double</span> <span class="nv">%x</span><span class="p">)</span> <span class="p">{</span>
+<span class="nl">entry:</span>
+ <span class="nv">%ifcond</span> <span class="p">=</span> <span class="k">fcmp</span> <span class="k">one</span> <span class="kt">double</span> <span class="nv">%x</span><span class="p">,</span> <span class="m">0.000000e+00</span>
+ <span class="k">br</span> <span class="k">i1</span> <span class="nv">%ifcond</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%then</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%else</span>
+
+<span class="nl">then:</span> <span class="c">; preds = %entry</span>
+ <span class="nv">%calltmp</span> <span class="p">=</span> <span class="k">call</span> <span class="kt">double</span> <span class="vg">@foo</span><span class="p">()</span>
+ <span class="k">br</span> <span class="kt">label</span> <span class="nv">%ifcont</span>
+
+<span class="nl">else:</span> <span class="c">; preds = %entry</span>
+ <span class="nv">%calltmp1</span> <span class="p">=</span> <span class="k">call</span> <span class="kt">double</span> <span class="vg">@bar</span><span class="p">()</span>
+ <span class="k">br</span> <span class="kt">label</span> <span class="nv">%ifcont</span>
+
+<span class="nl">ifcont:</span> <span class="c">; preds = %else, %then</span>
+ <span class="nv">%iftmp</span> <span class="p">=</span> <span class="k">phi</span> <span class="kt">double</span> <span class="p">[</span> <span class="nv">%calltmp</span><span class="p">,</span> <span class="nv">%then</span> <span class="p">],</span> <span class="p">[</span> <span class="nv">%calltmp1</span><span class="p">,</span> <span class="nv">%else</span> <span class="p">]</span>
+ <span class="k">ret</span> <span class="kt">double</span> <span class="nv">%iftmp</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>To visualize the control flow graph, you can use a nifty feature of the
+LLVM ‘<a class="reference external" href="http://llvm.org/cmds/opt.html">opt</a>‘ tool. If you put this LLVM
+IR into “t.ll” and run “<tt class="docutils literal"><span class="pre">llvm-as</span> <span class="pre"><</span> <span class="pre">t.ll</span> <span class="pre">|</span> <span class="pre">opt</span> <span class="pre">-analyze</span> <span class="pre">-view-cfg</span></tt>”, <a class="reference external" href="../ProgrammersManual.html#ViewGraph">a
+window will pop up</a> and you’ll
+see this graph:</p>
+<div class="figure align-center">
+<img alt="Example CFG" src="../_images/LangImpl5-cfg.png" />
+<p class="caption">Example CFG</p>
+</div>
+<p>Another way to get this is to call “<tt class="docutils literal"><span class="pre">F->viewCFG()</span></tt>” or
+“<tt class="docutils literal"><span class="pre">F->viewCFGOnly()</span></tt>” (where F is a “<tt class="docutils literal"><span class="pre">Function*</span></tt>”) either by
+inserting actual calls into the code and recompiling or by calling these
+in the debugger. LLVM has many nice features for visualizing various
+graphs.</p>
+<p>Getting back to the generated code, it is fairly simple: the entry block
+evaluates the conditional expression (“x” in our case here) and compares
+the result to 0.0 with the “<tt class="docutils literal"><span class="pre">fcmp</span> <span class="pre">one</span></tt>” instruction (‘one’ is “Ordered
+and Not Equal”). Based on the result of this expression, the code jumps
+to either the “then” or “else” blocks, which contain the expressions for
+the true/false cases.</p>
+<p>Once the then/else blocks are finished executing, they both branch back
+to the ‘ifcont’ block to execute the code that happens after the
+if/then/else. In this case the only thing left to do is to return to the
+caller of the function. The question then becomes: how does the code
+know which expression to return?</p>
+<p>The answer to this question involves an important SSA operation: the
+<a class="reference external" href="http://en.wikipedia.org/wiki/Static_single_assignment_form">Phi
+operation</a>.
+If you’re not familiar with SSA, <a class="reference external" href="http://en.wikipedia.org/wiki/Static_single_assignment_form">the wikipedia
+article</a>
+is a good introduction and there are various other introductions to it
+available on your favorite search engine. The short version is that
+“execution” of the Phi operation requires “remembering” which block
+control came from. The Phi operation takes on the value corresponding to
+the input control block. In this case, if control comes in from the
+“then” block, it gets the value of “calltmp”. If control comes from the
+“else” block, it gets the value of “calltmp1”.</p>
+<p>At this point, you are probably starting to think “Oh no! This means my
+simple and elegant front-end will have to start generating SSA form in
+order to use LLVM!”. Fortunately, this is not the case, and we strongly
+advise <em>not</em> implementing an SSA construction algorithm in your
+front-end unless there is an amazingly good reason to do so. In
+practice, there are two sorts of values that float around in code
+written for your average imperative programming language that might need
+Phi nodes:</p>
+<ol class="arabic simple">
+<li>Code that involves user variables: <tt class="docutils literal"><span class="pre">x</span> <span class="pre">=</span> <span class="pre">1;</span> <span class="pre">x</span> <span class="pre">=</span> <span class="pre">x</span> <span class="pre">+</span> <span class="pre">1;</span></tt></li>
+<li>Values that are implicit in the structure of your AST, such as the
+Phi node in this case.</li>
+</ol>
+<p>In <a class="reference external" href="LangImpl7.html">Chapter 7</a> of this tutorial (“mutable variables”),
+we’ll talk about #1 in depth. For now, just believe me that you don’t
+need SSA construction to handle this case. For #2, you have the choice
+of using the techniques that we will describe for #1, or you can insert
+Phi nodes directly, if convenient. In this case, it is really
+easy to generate the Phi node, so we choose to do it directly.</p>
+<p>Okay, enough of the motivation and overview, lets generate code!</p>
+</div>
+<div class="section" id="code-generation-for-if-then-else">
+<h3><a class="toc-backref" href="#id7">5.2.5. Code Generation for If/Then/Else</a><a class="headerlink" href="#code-generation-for-if-then-else" title="Permalink to this headline">¶</a></h3>
+<p>In order to generate code for this, we implement the <tt class="docutils literal"><span class="pre">Codegen</span></tt> method
+for <tt class="docutils literal"><span class="pre">IfExprAST</span></tt>:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">Value</span> <span class="o">*</span><span class="n">IfExprAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">CondV</span> <span class="o">=</span> <span class="n">Cond</span><span class="o">-></span><span class="n">Codegen</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CondV</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="c1">// Convert condition to a bool by comparing equal to 0.0.</span>
+ <span class="n">CondV</span> <span class="o">=</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateFCmpONE</span><span class="p">(</span><span class="n">CondV</span><span class="p">,</span>
+ <span class="n">ConstantFP</span><span class="o">::</span><span class="n">get</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">(),</span> <span class="n">APFloat</span><span class="p">(</span><span class="mf">0.0</span><span class="p">)),</span>
+ <span class="s">"ifcond"</span><span class="p">);</span>
+</pre></div>
+</div>
+<p>This code is straightforward and similar to what we saw before. We emit
+the expression for the condition, then compare that value to zero to get
+a truth value as a 1-bit (bool) value.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">Function</span> <span class="o">*</span><span class="n">TheFunction</span> <span class="o">=</span> <span class="n">Builder</span><span class="p">.</span><span class="n">GetInsertBlock</span><span class="p">()</span><span class="o">-></span><span class="n">getParent</span><span class="p">();</span>
+
+<span class="c1">// Create blocks for the then and else cases. Insert the 'then' block at the</span>
+<span class="c1">// end of the function.</span>
+<span class="n">BasicBlock</span> <span class="o">*</span><span class="n">ThenBB</span> <span class="o">=</span> <span class="n">BasicBlock</span><span class="o">::</span><span class="n">Create</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">(),</span> <span class="s">"then"</span><span class="p">,</span> <span class="n">TheFunction</span><span class="p">);</span>
+<span class="n">BasicBlock</span> <span class="o">*</span><span class="n">ElseBB</span> <span class="o">=</span> <span class="n">BasicBlock</span><span class="o">::</span><span class="n">Create</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">(),</span> <span class="s">"else"</span><span class="p">);</span>
+<span class="n">BasicBlock</span> <span class="o">*</span><span class="n">MergeBB</span> <span class="o">=</span> <span class="n">BasicBlock</span><span class="o">::</span><span class="n">Create</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">(),</span> <span class="s">"ifcont"</span><span class="p">);</span>
+
+<span class="n">Builder</span><span class="p">.</span><span class="n">CreateCondBr</span><span class="p">(</span><span class="n">CondV</span><span class="p">,</span> <span class="n">ThenBB</span><span class="p">,</span> <span class="n">ElseBB</span><span class="p">);</span>
+</pre></div>
+</div>
+<p>This code creates the basic blocks that are related to the if/then/else
+statement, and correspond directly to the blocks in the example above.
+The first line gets the current Function object that is being built. It
+gets this by asking the builder for the current BasicBlock, and asking
+that block for its “parent” (the function it is currently embedded
+into).</p>
+<p>Once it has that, it creates three blocks. Note that it passes
+“TheFunction” into the constructor for the “then” block. This causes the
+constructor to automatically insert the new block into the end of the
+specified function. The other two blocks are created, but aren’t yet
+inserted into the function.</p>
+<p>Once the blocks are created, we can emit the conditional branch that
+chooses between them. Note that creating new blocks does not implicitly
+affect the IRBuilder, so it is still inserting into the block that the
+condition went into. Also note that it is creating a branch to the
+“then” block and the “else” block, even though the “else” block isn’t
+inserted into the function yet. This is all ok: it is the standard way
+that LLVM supports forward references.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">// Emit then value.</span>
+<span class="n">Builder</span><span class="p">.</span><span class="n">SetInsertPoint</span><span class="p">(</span><span class="n">ThenBB</span><span class="p">);</span>
+
+<span class="n">Value</span> <span class="o">*</span><span class="n">ThenV</span> <span class="o">=</span> <span class="n">Then</span><span class="o">-></span><span class="n">Codegen</span><span class="p">();</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">ThenV</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+<span class="n">Builder</span><span class="p">.</span><span class="n">CreateBr</span><span class="p">(</span><span class="n">MergeBB</span><span class="p">);</span>
+<span class="c1">// Codegen of 'Then' can change the current block, update ThenBB for the PHI.</span>
+<span class="n">ThenBB</span> <span class="o">=</span> <span class="n">Builder</span><span class="p">.</span><span class="n">GetInsertBlock</span><span class="p">();</span>
+</pre></div>
+</div>
+<p>After the conditional branch is inserted, we move the builder to start
+inserting into the “then” block. Strictly speaking, this call moves the
+insertion point to be at the end of the specified block. However, since
+the “then” block is empty, it also starts out by inserting at the
+beginning of the block. :)</p>
+<p>Once the insertion point is set, we recursively codegen the “then”
+expression from the AST. To finish off the “then” block, we create an
+unconditional branch to the merge block. One interesting (and very
+important) aspect of the LLVM IR is that it <a class="reference external" href="../LangRef.html#functionstructure">requires all basic blocks
+to be “terminated”</a> with a <a class="reference external" href="../LangRef.html#terminators">control
+flow instruction</a> such as return or
+branch. This means that all control flow, <em>including fall throughs</em> must
+be made explicit in the LLVM IR. If you violate this rule, the verifier
+will emit an error.</p>
+<p>The final line here is quite subtle, but is very important. The basic
+issue is that when we create the Phi node in the merge block, we need to
+set up the block/value pairs that indicate how the Phi will work.
+Importantly, the Phi node expects to have an entry for each predecessor
+of the block in the CFG. Why then, are we getting the current block when
+we just set it to ThenBB 5 lines above? The problem is that the “Then”
+expression may actually itself change the block that the Builder is
+emitting into if, for example, it contains a nested “if/then/else”
+expression. Because calling Codegen recursively could arbitrarily change
+the notion of the current block, we are required to get an up-to-date
+value for code that will set up the Phi node.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">// Emit else block.</span>
+<span class="n">TheFunction</span><span class="o">-></span><span class="n">getBasicBlockList</span><span class="p">().</span><span class="n">push_back</span><span class="p">(</span><span class="n">ElseBB</span><span class="p">);</span>
+<span class="n">Builder</span><span class="p">.</span><span class="n">SetInsertPoint</span><span class="p">(</span><span class="n">ElseBB</span><span class="p">);</span>
+
+<span class="n">Value</span> <span class="o">*</span><span class="n">ElseV</span> <span class="o">=</span> <span class="n">Else</span><span class="o">-></span><span class="n">Codegen</span><span class="p">();</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">ElseV</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+<span class="n">Builder</span><span class="p">.</span><span class="n">CreateBr</span><span class="p">(</span><span class="n">MergeBB</span><span class="p">);</span>
+<span class="c1">// Codegen of 'Else' can change the current block, update ElseBB for the PHI.</span>
+<span class="n">ElseBB</span> <span class="o">=</span> <span class="n">Builder</span><span class="p">.</span><span class="n">GetInsertBlock</span><span class="p">();</span>
+</pre></div>
+</div>
+<p>Code generation for the ‘else’ block is basically identical to codegen
+for the ‘then’ block. The only significant difference is the first line,
+which adds the ‘else’ block to the function. Recall previously that the
+‘else’ block was created, but not added to the function. Now that the
+‘then’ and ‘else’ blocks are emitted, we can finish up with the merge
+code:</p>
+<div class="highlight-c++"><div class="highlight"><pre> <span class="c1">// Emit merge block.</span>
+ <span class="n">TheFunction</span><span class="o">-></span><span class="n">getBasicBlockList</span><span class="p">().</span><span class="n">push_back</span><span class="p">(</span><span class="n">MergeBB</span><span class="p">);</span>
+ <span class="n">Builder</span><span class="p">.</span><span class="n">SetInsertPoint</span><span class="p">(</span><span class="n">MergeBB</span><span class="p">);</span>
+ <span class="n">PHINode</span> <span class="o">*</span><span class="n">PN</span> <span class="o">=</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreatePHI</span><span class="p">(</span><span class="n">Type</span><span class="o">::</span><span class="n">getDoubleTy</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">()),</span> <span class="mi">2</span><span class="p">,</span>
+ <span class="s">"iftmp"</span><span class="p">);</span>
+
+ <span class="n">PN</span><span class="o">-></span><span class="n">addIncoming</span><span class="p">(</span><span class="n">ThenV</span><span class="p">,</span> <span class="n">ThenBB</span><span class="p">);</span>
+ <span class="n">PN</span><span class="o">-></span><span class="n">addIncoming</span><span class="p">(</span><span class="n">ElseV</span><span class="p">,</span> <span class="n">ElseBB</span><span class="p">);</span>
+ <span class="k">return</span> <span class="n">PN</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>The first two lines here are now familiar: the first adds the “merge”
+block to the Function object (it was previously floating, like the else
+block above). The second changes the insertion point so that newly
+created code will go into the “merge” block. Once that is done, we need
+to create the PHI node and set up the block/value pairs for the PHI.</p>
+<p>Finally, the CodeGen function returns the phi node as the value computed
+by the if/then/else expression. In our example above, this returned
+value will feed into the code for the top-level function, which will
+create the return instruction.</p>
+<p>Overall, we now have the ability to execute conditional code in
+Kaleidoscope. With this extension, Kaleidoscope is a fairly complete
+language that can calculate a wide variety of numeric functions. Next up
+we’ll add another useful expression that is familiar from non-functional
+languages...</p>
+</div>
+</div>
+<div class="section" id="for-loop-expression">
+<h2><a class="toc-backref" href="#id8">5.3. ‘for’ Loop Expression</a><a class="headerlink" href="#for-loop-expression" title="Permalink to this headline">¶</a></h2>
+<p>Now that we know how to add basic control flow constructs to the
+language, we have the tools to add more powerful things. Lets add
+something more aggressive, a ‘for’ expression:</p>
+<div class="highlight-python"><div class="highlight"><pre>extern putchard(char)
+def printstar(n)
+ for i = 1, i < n, 1.0 in
+ putchard(42); # ascii 42 = '*'
+
+# print 100 '*' characters
+printstar(100);
+</pre></div>
+</div>
+<p>This expression defines a new variable (“i” in this case) which iterates
+from a starting value, while the condition (“i < n” in this case) is
+true, incrementing by an optional step value (“1.0” in this case). If
+the step value is omitted, it defaults to 1.0. While the loop is true,
+it executes its body expression. Because we don’t have anything better
+to return, we’ll just define the loop as always returning 0.0. In the
+future when we have mutable variables, it will get more useful.</p>
+<p>As before, lets talk about the changes that we need to Kaleidoscope to
+support this.</p>
+<div class="section" id="lexer-extensions-for-the-for-loop">
+<h3><a class="toc-backref" href="#id9">5.3.1. Lexer Extensions for the ‘for’ Loop</a><a class="headerlink" href="#lexer-extensions-for-the-for-loop" title="Permalink to this headline">¶</a></h3>
+<p>The lexer extensions are the same sort of thing as for if/then/else:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="p">...</span> <span class="n">in</span> <span class="k">enum</span> <span class="n">Token</span> <span class="p">...</span>
+<span class="c1">// control</span>
+<span class="n">tok_if</span> <span class="o">=</span> <span class="o">-</span><span class="mi">6</span><span class="p">,</span> <span class="n">tok_then</span> <span class="o">=</span> <span class="o">-</span><span class="mi">7</span><span class="p">,</span> <span class="n">tok_else</span> <span class="o">=</span> <span class="o">-</span><span class="mi">8</span><span class="p">,</span>
+<span class="n">tok_for</span> <span class="o">=</span> <span class="o">-</span><span class="mi">9</span><span class="p">,</span> <span class="n">tok_in</span> <span class="o">=</span> <span class="o">-</span><span class="mi">10</span>
+
+<span class="p">...</span> <span class="n">in</span> <span class="n">gettok</span> <span class="p">...</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"def"</span><span class="p">)</span> <span class="k">return</span> <span class="n">tok_def</span><span class="p">;</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"extern"</span><span class="p">)</span> <span class="k">return</span> <span class="n">tok_extern</span><span class="p">;</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"if"</span><span class="p">)</span> <span class="k">return</span> <span class="n">tok_if</span><span class="p">;</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"then"</span><span class="p">)</span> <span class="k">return</span> <span class="n">tok_then</span><span class="p">;</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"else"</span><span class="p">)</span> <span class="k">return</span> <span class="n">tok_else</span><span class="p">;</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"for"</span><span class="p">)</span> <span class="k">return</span> <span class="n">tok_for</span><span class="p">;</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"in"</span><span class="p">)</span> <span class="k">return</span> <span class="n">tok_in</span><span class="p">;</span>
+<span class="k">return</span> <span class="n">tok_identifier</span><span class="p">;</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="ast-extensions-for-the-for-loop">
+<h3><a class="toc-backref" href="#id10">5.3.2. AST Extensions for the ‘for’ Loop</a><a class="headerlink" href="#ast-extensions-for-the-for-loop" title="Permalink to this headline">¶</a></h3>
+<p>The AST node is just as simple. It basically boils down to capturing the
+variable name and the constituent expressions in the node.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">/// ForExprAST - Expression class for for/in.</span>
+<span class="k">class</span> <span class="nc">ForExprAST</span> <span class="o">:</span> <span class="k">public</span> <span class="n">ExprAST</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">VarName</span><span class="p">;</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Start</span><span class="p">,</span> <span class="o">*</span><span class="n">End</span><span class="p">,</span> <span class="o">*</span><span class="n">Step</span><span class="p">,</span> <span class="o">*</span><span class="n">Body</span><span class="p">;</span>
+<span class="nl">public:</span>
+ <span class="n">ForExprAST</span><span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="o">&</span><span class="n">varname</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">start</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">end</span><span class="p">,</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">step</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">body</span><span class="p">)</span>
+ <span class="o">:</span> <span class="n">VarName</span><span class="p">(</span><span class="n">varname</span><span class="p">),</span> <span class="n">Start</span><span class="p">(</span><span class="n">start</span><span class="p">),</span> <span class="n">End</span><span class="p">(</span><span class="n">end</span><span class="p">),</span> <span class="n">Step</span><span class="p">(</span><span class="n">step</span><span class="p">),</span> <span class="n">Body</span><span class="p">(</span><span class="n">body</span><span class="p">)</span> <span class="p">{}</span>
+ <span class="k">virtual</span> <span class="n">Value</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">();</span>
+<span class="p">};</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="parser-extensions-for-the-for-loop">
+<h3><a class="toc-backref" href="#id11">5.3.3. Parser Extensions for the ‘for’ Loop</a><a class="headerlink" href="#parser-extensions-for-the-for-loop" title="Permalink to this headline">¶</a></h3>
+<p>The parser code is also fairly standard. The only interesting thing here
+is handling of the optional step value. The parser code handles it by
+checking to see if the second comma is present. If not, it sets the step
+value to null in the AST node:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">/// forexpr ::= 'for' identifier '=' expr ',' expr (',' expr)? 'in' expression</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseForExpr</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat the for.</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="n">tok_identifier</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"expected identifier after for"</span><span class="p">);</span>
+
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">IdName</span> <span class="o">=</span> <span class="n">IdentifierStr</span><span class="p">;</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat identifier.</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">'='</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"expected '=' after for"</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat '='.</span>
+
+
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Start</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">Start</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">','</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"expected ',' after for start value"</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">End</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">End</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="c1">// The step value is optional.</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Step</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">==</span> <span class="sc">','</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+ <span class="n">Step</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">Step</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="n">tok_in</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"expected 'in' after for"</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat 'in'.</span>
+
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Body</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">Body</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">return</span> <span class="k">new</span> <span class="n">ForExprAST</span><span class="p">(</span><span class="n">IdName</span><span class="p">,</span> <span class="n">Start</span><span class="p">,</span> <span class="n">End</span><span class="p">,</span> <span class="n">Step</span><span class="p">,</span> <span class="n">Body</span><span class="p">);</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="llvm-ir-for-the-for-loop">
+<h3><a class="toc-backref" href="#id12">5.3.4. LLVM IR for the ‘for’ Loop</a><a class="headerlink" href="#llvm-ir-for-the-for-loop" title="Permalink to this headline">¶</a></h3>
+<p>Now we get to the good part: the LLVM IR we want to generate for this
+thing. With the simple example above, we get this LLVM IR (note that
+this dump is generated with optimizations disabled for clarity):</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="k">declare</span> <span class="kt">double</span> <span class="vg">@putchard</span><span class="p">(</span><span class="kt">double</span><span class="p">)</span>
+
+<span class="k">define</span> <span class="kt">double</span> <span class="vg">@printstar</span><span class="p">(</span><span class="kt">double</span> <span class="nv">%n</span><span class="p">)</span> <span class="p">{</span>
+<span class="nl">entry:</span>
+ <span class="c">; initial value = 1.0 (inlined into phi)</span>
+ <span class="k">br</span> <span class="kt">label</span> <span class="nv">%loop</span>
+
+<span class="nl">loop:</span> <span class="c">; preds = %loop, %entry</span>
+ <span class="nv">%i</span> <span class="p">=</span> <span class="k">phi</span> <span class="kt">double</span> <span class="p">[</span> <span class="m">1.000000e+00</span><span class="p">,</span> <span class="nv">%entry</span> <span class="p">],</span> <span class="p">[</span> <span class="nv">%nextvar</span><span class="p">,</span> <span class="nv">%loop</span> <span class="p">]</span>
+ <span class="c">; body</span>
+ <span class="nv">%calltmp</span> <span class="p">=</span> <span class="k">call</span> <span class="kt">double</span> <span class="vg">@putchard</span><span class="p">(</span><span class="kt">double</span> <span class="m">4.200000e+01</span><span class="p">)</span>
+ <span class="c">; increment</span>
+ <span class="nv">%nextvar</span> <span class="p">=</span> <span class="k">fadd</span> <span class="kt">double</span> <span class="nv">%i</span><span class="p">,</span> <span class="m">1.000000e+00</span>
+
+ <span class="c">; termination test</span>
+ <span class="nv">%cmptmp</span> <span class="p">=</span> <span class="k">fcmp</span> <span class="k">ult</span> <span class="kt">double</span> <span class="nv">%i</span><span class="p">,</span> <span class="nv">%n</span>
+ <span class="nv">%booltmp</span> <span class="p">=</span> <span class="k">uitofp</span> <span class="k">i1</span> <span class="nv">%cmptmp</span> <span class="k">to</span> <span class="kt">double</span>
+ <span class="nv">%loopcond</span> <span class="p">=</span> <span class="k">fcmp</span> <span class="k">one</span> <span class="kt">double</span> <span class="nv">%booltmp</span><span class="p">,</span> <span class="m">0.000000e+00</span>
+ <span class="k">br</span> <span class="k">i1</span> <span class="nv">%loopcond</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%loop</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%afterloop</span>
+
+<span class="nl">afterloop:</span> <span class="c">; preds = %loop</span>
+ <span class="c">; loop always returns 0.0</span>
+ <span class="k">ret</span> <span class="kt">double</span> <span class="m">0.000000e+00</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>This loop contains all the same constructs we saw before: a phi node,
+several expressions, and some basic blocks. Lets see how this fits
+together.</p>
+</div>
+<div class="section" id="code-generation-for-the-for-loop">
+<h3><a class="toc-backref" href="#id13">5.3.5. Code Generation for the ‘for’ Loop</a><a class="headerlink" href="#code-generation-for-the-for-loop" title="Permalink to this headline">¶</a></h3>
+<p>The first part of Codegen is very simple: we just output the start
+expression for the loop value:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">Value</span> <span class="o">*</span><span class="n">ForExprAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="c1">// Emit the start code first, without 'variable' in scope.</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">StartVal</span> <span class="o">=</span> <span class="n">Start</span><span class="o">-></span><span class="n">Codegen</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">StartVal</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>With this out of the way, the next step is to set up the LLVM basic
+block for the start of the loop body. In the case above, the whole loop
+body is one block, but remember that the body code itself could consist
+of multiple blocks (e.g. if it contains an if/then/else or a for/in
+expression).</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">// Make the new basic block for the loop header, inserting after current</span>
+<span class="c1">// block.</span>
+<span class="n">Function</span> <span class="o">*</span><span class="n">TheFunction</span> <span class="o">=</span> <span class="n">Builder</span><span class="p">.</span><span class="n">GetInsertBlock</span><span class="p">()</span><span class="o">-></span><span class="n">getParent</span><span class="p">();</span>
+<span class="n">BasicBlock</span> <span class="o">*</span><span class="n">PreheaderBB</span> <span class="o">=</span> <span class="n">Builder</span><span class="p">.</span><span class="n">GetInsertBlock</span><span class="p">();</span>
+<span class="n">BasicBlock</span> <span class="o">*</span><span class="n">LoopBB</span> <span class="o">=</span> <span class="n">BasicBlock</span><span class="o">::</span><span class="n">Create</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">(),</span> <span class="s">"loop"</span><span class="p">,</span> <span class="n">TheFunction</span><span class="p">);</span>
+
+<span class="c1">// Insert an explicit fall through from the current block to the LoopBB.</span>
+<span class="n">Builder</span><span class="p">.</span><span class="n">CreateBr</span><span class="p">(</span><span class="n">LoopBB</span><span class="p">);</span>
+</pre></div>
+</div>
+<p>This code is similar to what we saw for if/then/else. Because we will
+need it to create the Phi node, we remember the block that falls through
+into the loop. Once we have that, we create the actual block that starts
+the loop and create an unconditional branch for the fall-through between
+the two blocks.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">// Start insertion in LoopBB.</span>
+<span class="n">Builder</span><span class="p">.</span><span class="n">SetInsertPoint</span><span class="p">(</span><span class="n">LoopBB</span><span class="p">);</span>
+
+<span class="c1">// Start the PHI node with an entry for Start.</span>
+<span class="n">PHINode</span> <span class="o">*</span><span class="n">Variable</span> <span class="o">=</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreatePHI</span><span class="p">(</span><span class="n">Type</span><span class="o">::</span><span class="n">getDoubleTy</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">()),</span> <span class="mi">2</span><span class="p">,</span> <span class="n">VarName</span><span class="p">.</span><span class="n">c_str</span><span class="p">());</span>
+<span class="n">Variable</span><span class="o">-></span><span class="n">addIncoming</span><span class="p">(</span><span class="n">StartVal</span><span class="p">,</span> <span class="n">PreheaderBB</span><span class="p">);</span>
+</pre></div>
+</div>
+<p>Now that the “preheader” for the loop is set up, we switch to emitting
+code for the loop body. To begin with, we move the insertion point and
+create the PHI node for the loop induction variable. Since we already
+know the incoming value for the starting value, we add it to the Phi
+node. Note that the Phi will eventually get a second value for the
+backedge, but we can’t set it up yet (because it doesn’t exist!).</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">// Within the loop, the variable is defined equal to the PHI node. If it</span>
+<span class="c1">// shadows an existing variable, we have to restore it, so save it now.</span>
+<span class="n">Value</span> <span class="o">*</span><span class="n">OldVal</span> <span class="o">=</span> <span class="n">NamedValues</span><span class="p">[</span><span class="n">VarName</span><span class="p">];</span>
+<span class="n">NamedValues</span><span class="p">[</span><span class="n">VarName</span><span class="p">]</span> <span class="o">=</span> <span class="n">Variable</span><span class="p">;</span>
+
+<span class="c1">// Emit the body of the loop. This, like any other expr, can change the</span>
+<span class="c1">// current BB. Note that we ignore the value computed by the body, but don't</span>
+<span class="c1">// allow an error.</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">Body</span><span class="o">-></span><span class="n">Codegen</span><span class="p">()</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>Now the code starts to get more interesting. Our ‘for’ loop introduces a
+new variable to the symbol table. This means that our symbol table can
+now contain either function arguments or loop variables. To handle this,
+before we codegen the body of the loop, we add the loop variable as the
+current value for its name. Note that it is possible that there is a
+variable of the same name in the outer scope. It would be easy to make
+this an error (emit an error and return null if there is already an
+entry for VarName) but we choose to allow shadowing of variables. In
+order to handle this correctly, we remember the Value that we are
+potentially shadowing in <tt class="docutils literal"><span class="pre">OldVal</span></tt> (which will be null if there is no
+shadowed variable).</p>
+<p>Once the loop variable is set into the symbol table, the code
+recursively codegen’s the body. This allows the body to use the loop
+variable: any references to it will naturally find it in the symbol
+table.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">// Emit the step value.</span>
+<span class="n">Value</span> <span class="o">*</span><span class="n">StepVal</span><span class="p">;</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">Step</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">StepVal</span> <span class="o">=</span> <span class="n">Step</span><span class="o">-></span><span class="n">Codegen</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">StepVal</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+ <span class="c1">// If not specified, use 1.0.</span>
+ <span class="n">StepVal</span> <span class="o">=</span> <span class="n">ConstantFP</span><span class="o">::</span><span class="n">get</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">(),</span> <span class="n">APFloat</span><span class="p">(</span><span class="mf">1.0</span><span class="p">));</span>
+<span class="p">}</span>
+
+<span class="n">Value</span> <span class="o">*</span><span class="n">NextVar</span> <span class="o">=</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateFAdd</span><span class="p">(</span><span class="n">Variable</span><span class="p">,</span> <span class="n">StepVal</span><span class="p">,</span> <span class="s">"nextvar"</span><span class="p">);</span>
+</pre></div>
+</div>
+<p>Now that the body is emitted, we compute the next value of the iteration
+variable by adding the step value, or 1.0 if it isn’t present.
+‘<tt class="docutils literal"><span class="pre">NextVar</span></tt>‘ will be the value of the loop variable on the next
+iteration of the loop.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">// Compute the end condition.</span>
+<span class="n">Value</span> <span class="o">*</span><span class="n">EndCond</span> <span class="o">=</span> <span class="n">End</span><span class="o">-></span><span class="n">Codegen</span><span class="p">();</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">EndCond</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="k">return</span> <span class="n">EndCond</span><span class="p">;</span>
+
+<span class="c1">// Convert condition to a bool by comparing equal to 0.0.</span>
+<span class="n">EndCond</span> <span class="o">=</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateFCmpONE</span><span class="p">(</span><span class="n">EndCond</span><span class="p">,</span>
+ <span class="n">ConstantFP</span><span class="o">::</span><span class="n">get</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">(),</span> <span class="n">APFloat</span><span class="p">(</span><span class="mf">0.0</span><span class="p">)),</span>
+ <span class="s">"loopcond"</span><span class="p">);</span>
+</pre></div>
+</div>
+<p>Finally, we evaluate the exit value of the loop, to determine whether
+the loop should exit. This mirrors the condition evaluation for the
+if/then/else statement.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">// Create the "after loop" block and insert it.</span>
+<span class="n">BasicBlock</span> <span class="o">*</span><span class="n">LoopEndBB</span> <span class="o">=</span> <span class="n">Builder</span><span class="p">.</span><span class="n">GetInsertBlock</span><span class="p">();</span>
+<span class="n">BasicBlock</span> <span class="o">*</span><span class="n">AfterBB</span> <span class="o">=</span> <span class="n">BasicBlock</span><span class="o">::</span><span class="n">Create</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">(),</span> <span class="s">"afterloop"</span><span class="p">,</span> <span class="n">TheFunction</span><span class="p">);</span>
+
+<span class="c1">// Insert the conditional branch into the end of LoopEndBB.</span>
+<span class="n">Builder</span><span class="p">.</span><span class="n">CreateCondBr</span><span class="p">(</span><span class="n">EndCond</span><span class="p">,</span> <span class="n">LoopBB</span><span class="p">,</span> <span class="n">AfterBB</span><span class="p">);</span>
+
+<span class="c1">// Any new code will be inserted in AfterBB.</span>
+<span class="n">Builder</span><span class="p">.</span><span class="n">SetInsertPoint</span><span class="p">(</span><span class="n">AfterBB</span><span class="p">);</span>
+</pre></div>
+</div>
+<p>With the code for the body of the loop complete, we just need to finish
+up the control flow for it. This code remembers the end block (for the
+phi node), then creates the block for the loop exit (“afterloop”). Based
+on the value of the exit condition, it creates a conditional branch that
+chooses between executing the loop again and exiting the loop. Any
+future code is emitted in the “afterloop” block, so it sets the
+insertion position to it.</p>
+<div class="highlight-c++"><div class="highlight"><pre> <span class="c1">// Add a new entry to the PHI node for the backedge.</span>
+ <span class="n">Variable</span><span class="o">-></span><span class="n">addIncoming</span><span class="p">(</span><span class="n">NextVar</span><span class="p">,</span> <span class="n">LoopEndBB</span><span class="p">);</span>
+
+ <span class="c1">// Restore the unshadowed variable.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">OldVal</span><span class="p">)</span>
+ <span class="n">NamedValues</span><span class="p">[</span><span class="n">VarName</span><span class="p">]</span> <span class="o">=</span> <span class="n">OldVal</span><span class="p">;</span>
+ <span class="k">else</span>
+ <span class="n">NamedValues</span><span class="p">.</span><span class="n">erase</span><span class="p">(</span><span class="n">VarName</span><span class="p">);</span>
+
+ <span class="c1">// for expr always returns 0.0.</span>
+ <span class="k">return</span> <span class="n">Constant</span><span class="o">::</span><span class="n">getNullValue</span><span class="p">(</span><span class="n">Type</span><span class="o">::</span><span class="n">getDoubleTy</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">()));</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>The final code handles various cleanups: now that we have the “NextVar”
+value, we can add the incoming value to the loop PHI node. After that,
+we remove the loop variable from the symbol table, so that it isn’t in
+scope after the for loop. Finally, code generation of the for loop
+always returns 0.0, so that is what we return from
+<tt class="docutils literal"><span class="pre">ForExprAST::Codegen</span></tt>.</p>
+<p>With this, we conclude the “adding control flow to Kaleidoscope” chapter
+of the tutorial. In this chapter we added two control flow constructs,
+and used them to motivate a couple of aspects of the LLVM IR that are
+important for front-end implementors to know. In the next chapter of our
+saga, we will get a bit crazier and add <a class="reference external" href="LangImpl6.html">user-defined
+operators</a> to our poor innocent language.</p>
+</div>
+</div>
+<div class="section" id="full-code-listing">
+<h2><a class="toc-backref" href="#id14">5.4. 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, enhanced with
+the if/then/else and for expressions.. To build this example, use:</p>
+<div class="highlight-bash"><div class="highlight"><pre><span class="c"># Compile</span>
+clang++ -g toy.cpp <span class="sb">`</span>llvm-config --cxxflags --ldflags --system-libs --libs core mcjit native<span class="sb">`</span> -O3 -o toy
+<span class="c"># Run</span>
+./toy
+</pre></div>
+</div>
+<p>Here is the code:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="cp">#include "llvm/ADT/STLExtras.h"</span>
+<span class="cp">#include "llvm/Analysis/Passes.h"</span>
+<span class="cp">#include "llvm/ExecutionEngine/ExecutionEngine.h"</span>
+<span class="cp">#include "llvm/ExecutionEngine/MCJIT.h"</span>
+<span class="cp">#include "llvm/ExecutionEngine/SectionMemoryManager.h"</span>
+<span class="cp">#include "llvm/IR/DataLayout.h"</span>
+<span class="cp">#include "llvm/IR/DerivedTypes.h"</span>
+<span class="cp">#include "llvm/IR/IRBuilder.h"</span>
+<span class="cp">#include "llvm/IR/LLVMContext.h"</span>
+<span class="cp">#include "llvm/IR/LegacyPassManager.h"</span>
+<span class="cp">#include "llvm/IR/Module.h"</span>
+<span class="cp">#include "llvm/IR/Verifier.h"</span>
+<span class="cp">#include "llvm/Support/TargetSelect.h"</span>
+<span class="cp">#include "llvm/Transforms/Scalar.h"</span>
+<span class="cp">#include <cctype></span>
+<span class="cp">#include <cstdio></span>
+<span class="cp">#include <map></span>
+<span class="cp">#include <string></span>
+<span class="cp">#include <vector></span>
+<span class="k">using</span> <span class="k">namespace</span> <span class="n">llvm</span><span class="p">;</span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// Lexer</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+
+<span class="c1">// The lexer returns tokens [0-255] if it is an unknown character, otherwise one</span>
+<span class="c1">// of these for known things.</span>
+<span class="k">enum</span> <span class="n">Token</span> <span class="p">{</span>
+ <span class="n">tok_eof</span> <span class="o">=</span> <span class="o">-</span><span class="mi">1</span><span class="p">,</span>
+
+ <span class="c1">// commands</span>
+ <span class="n">tok_def</span> <span class="o">=</span> <span class="o">-</span><span class="mi">2</span><span class="p">,</span>
+ <span class="n">tok_extern</span> <span class="o">=</span> <span class="o">-</span><span class="mi">3</span><span class="p">,</span>
+
+ <span class="c1">// primary</span>
+ <span class="n">tok_identifier</span> <span class="o">=</span> <span class="o">-</span><span class="mi">4</span><span class="p">,</span>
+ <span class="n">tok_number</span> <span class="o">=</span> <span class="o">-</span><span class="mi">5</span><span class="p">,</span>
+
+ <span class="c1">// control</span>
+ <span class="n">tok_if</span> <span class="o">=</span> <span class="o">-</span><span class="mi">6</span><span class="p">,</span>
+ <span class="n">tok_then</span> <span class="o">=</span> <span class="o">-</span><span class="mi">7</span><span class="p">,</span>
+ <span class="n">tok_else</span> <span class="o">=</span> <span class="o">-</span><span class="mi">8</span><span class="p">,</span>
+ <span class="n">tok_for</span> <span class="o">=</span> <span class="o">-</span><span class="mi">9</span><span class="p">,</span>
+ <span class="n">tok_in</span> <span class="o">=</span> <span class="o">-</span><span class="mi">10</span>
+<span class="p">};</span>
+
+<span class="k">static</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">IdentifierStr</span><span class="p">;</span> <span class="c1">// Filled in if tok_identifier</span>
+<span class="k">static</span> <span class="kt">double</span> <span class="n">NumVal</span><span class="p">;</span> <span class="c1">// Filled in if tok_number</span>
+
+<span class="c1">/// gettok - Return the next token from standard input.</span>
+<span class="k">static</span> <span class="kt">int</span> <span class="nf">gettok</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">static</span> <span class="kt">int</span> <span class="n">LastChar</span> <span class="o">=</span> <span class="sc">' '</span><span class="p">;</span>
+
+ <span class="c1">// Skip any whitespace.</span>
+ <span class="k">while</span> <span class="p">(</span><span class="n">isspace</span><span class="p">(</span><span class="n">LastChar</span><span class="p">))</span>
+ <span class="n">LastChar</span> <span class="o">=</span> <span class="n">getchar</span><span class="p">();</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">isalpha</span><span class="p">(</span><span class="n">LastChar</span><span class="p">))</span> <span class="p">{</span> <span class="c1">// identifier: [a-zA-Z][a-zA-Z0-9]*</span>
+ <span class="n">IdentifierStr</span> <span class="o">=</span> <span class="n">LastChar</span><span class="p">;</span>
+ <span class="k">while</span> <span class="p">(</span><span class="n">isalnum</span><span class="p">((</span><span class="n">LastChar</span> <span class="o">=</span> <span class="n">getchar</span><span class="p">())))</span>
+ <span class="n">IdentifierStr</span> <span class="o">+=</span> <span class="n">LastChar</span><span class="p">;</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"def"</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">tok_def</span><span class="p">;</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"extern"</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">tok_extern</span><span class="p">;</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"if"</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">tok_if</span><span class="p">;</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"then"</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">tok_then</span><span class="p">;</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"else"</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">tok_else</span><span class="p">;</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"for"</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">tok_for</span><span class="p">;</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">IdentifierStr</span> <span class="o">==</span> <span class="s">"in"</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">tok_in</span><span class="p">;</span>
+ <span class="k">return</span> <span class="n">tok_identifier</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">isdigit</span><span class="p">(</span><span class="n">LastChar</span><span class="p">)</span> <span class="o">||</span> <span class="n">LastChar</span> <span class="o">==</span> <span class="sc">'.'</span><span class="p">)</span> <span class="p">{</span> <span class="c1">// Number: [0-9.]+</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">NumStr</span><span class="p">;</span>
+ <span class="k">do</span> <span class="p">{</span>
+ <span class="n">NumStr</span> <span class="o">+=</span> <span class="n">LastChar</span><span class="p">;</span>
+ <span class="n">LastChar</span> <span class="o">=</span> <span class="n">getchar</span><span class="p">();</span>
+ <span class="p">}</span> <span class="k">while</span> <span class="p">(</span><span class="n">isdigit</span><span class="p">(</span><span class="n">LastChar</span><span class="p">)</span> <span class="o">||</span> <span class="n">LastChar</span> <span class="o">==</span> <span class="sc">'.'</span><span class="p">);</span>
+
+ <span class="n">NumVal</span> <span class="o">=</span> <span class="n">strtod</span><span class="p">(</span><span class="n">NumStr</span><span class="p">.</span><span class="n">c_str</span><span class="p">(),</span> <span class="mi">0</span><span class="p">);</span>
+ <span class="k">return</span> <span class="n">tok_number</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">LastChar</span> <span class="o">==</span> <span class="sc">'#'</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">// Comment until end of line.</span>
+ <span class="k">do</span>
+ <span class="n">LastChar</span> <span class="o">=</span> <span class="n">getchar</span><span class="p">();</span>
+ <span class="k">while</span> <span class="p">(</span><span class="n">LastChar</span> <span class="o">!=</span> <span class="n">EOF</span> <span class="o">&&</span> <span class="n">LastChar</span> <span class="o">!=</span> <span class="sc">'\n'</span> <span class="o">&&</span> <span class="n">LastChar</span> <span class="o">!=</span> <span class="sc">'\r'</span><span class="p">);</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">LastChar</span> <span class="o">!=</span> <span class="n">EOF</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">gettok</span><span class="p">();</span>
+ <span class="p">}</span>
+
+ <span class="c1">// Check for end of file. Don't eat the EOF.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">LastChar</span> <span class="o">==</span> <span class="n">EOF</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">tok_eof</span><span class="p">;</span>
+
+ <span class="c1">// Otherwise, just return the character as its ascii value.</span>
+ <span class="kt">int</span> <span class="n">ThisChar</span> <span class="o">=</span> <span class="n">LastChar</span><span class="p">;</span>
+ <span class="n">LastChar</span> <span class="o">=</span> <span class="n">getchar</span><span class="p">();</span>
+ <span class="k">return</span> <span class="n">ThisChar</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// Abstract Syntax Tree (aka Parse Tree)</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="k">namespace</span> <span class="p">{</span>
+<span class="c1">/// ExprAST - Base class for all expression nodes.</span>
+<span class="k">class</span> <span class="nc">ExprAST</span> <span class="p">{</span>
+<span class="nl">public:</span>
+ <span class="k">virtual</span> <span class="o">~</span><span class="n">ExprAST</span><span class="p">()</span> <span class="p">{}</span>
+ <span class="k">virtual</span> <span class="n">Value</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">()</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="c1">/// NumberExprAST - Expression class for numeric literals like "1.0".</span>
+<span class="k">class</span> <span class="nc">NumberExprAST</span> <span class="o">:</span> <span class="k">public</span> <span class="n">ExprAST</span> <span class="p">{</span>
+ <span class="kt">double</span> <span class="n">Val</span><span class="p">;</span>
+
+<span class="nl">public:</span>
+ <span class="n">NumberExprAST</span><span class="p">(</span><span class="kt">double</span> <span class="n">val</span><span class="p">)</span> <span class="o">:</span> <span class="n">Val</span><span class="p">(</span><span class="n">val</span><span class="p">)</span> <span class="p">{}</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">()</span> <span class="n">override</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="c1">/// VariableExprAST - Expression class for referencing a variable, like "a".</span>
+<span class="k">class</span> <span class="nc">VariableExprAST</span> <span class="o">:</span> <span class="k">public</span> <span class="n">ExprAST</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">Name</span><span class="p">;</span>
+
+<span class="nl">public:</span>
+ <span class="n">VariableExprAST</span><span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="o">&</span><span class="n">name</span><span class="p">)</span> <span class="o">:</span> <span class="n">Name</span><span class="p">(</span><span class="n">name</span><span class="p">)</span> <span class="p">{}</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">()</span> <span class="n">override</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="c1">/// BinaryExprAST - Expression class for a binary operator.</span>
+<span class="k">class</span> <span class="nc">BinaryExprAST</span> <span class="o">:</span> <span class="k">public</span> <span class="n">ExprAST</span> <span class="p">{</span>
+ <span class="kt">char</span> <span class="n">Op</span><span class="p">;</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">LHS</span><span class="p">,</span> <span class="o">*</span><span class="n">RHS</span><span class="p">;</span>
+
+<span class="nl">public:</span>
+ <span class="n">BinaryExprAST</span><span class="p">(</span><span class="kt">char</span> <span class="n">op</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">lhs</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">rhs</span><span class="p">)</span>
+ <span class="o">:</span> <span class="n">Op</span><span class="p">(</span><span class="n">op</span><span class="p">),</span> <span class="n">LHS</span><span class="p">(</span><span class="n">lhs</span><span class="p">),</span> <span class="n">RHS</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span> <span class="p">{}</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">()</span> <span class="n">override</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="c1">/// CallExprAST - Expression class for function calls.</span>
+<span class="k">class</span> <span class="nc">CallExprAST</span> <span class="o">:</span> <span class="k">public</span> <span class="n">ExprAST</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">Callee</span><span class="p">;</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">ExprAST</span> <span class="o">*></span> <span class="n">Args</span><span class="p">;</span>
+
+<span class="nl">public:</span>
+ <span class="n">CallExprAST</span><span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="o">&</span><span class="n">callee</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">ExprAST</span> <span class="o">*></span> <span class="o">&</span><span class="n">args</span><span class="p">)</span>
+ <span class="o">:</span> <span class="n">Callee</span><span class="p">(</span><span class="n">callee</span><span class="p">),</span> <span class="n">Args</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="p">{}</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">()</span> <span class="n">override</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="c1">/// IfExprAST - Expression class for if/then/else.</span>
+<span class="k">class</span> <span class="nc">IfExprAST</span> <span class="o">:</span> <span class="k">public</span> <span class="n">ExprAST</span> <span class="p">{</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Cond</span><span class="p">,</span> <span class="o">*</span><span class="n">Then</span><span class="p">,</span> <span class="o">*</span><span class="n">Else</span><span class="p">;</span>
+
+<span class="nl">public:</span>
+ <span class="n">IfExprAST</span><span class="p">(</span><span class="n">ExprAST</span> <span class="o">*</span><span class="n">cond</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">then</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">_else</span><span class="p">)</span>
+ <span class="o">:</span> <span class="n">Cond</span><span class="p">(</span><span class="n">cond</span><span class="p">),</span> <span class="n">Then</span><span class="p">(</span><span class="n">then</span><span class="p">),</span> <span class="n">Else</span><span class="p">(</span><span class="n">_else</span><span class="p">)</span> <span class="p">{}</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">()</span> <span class="n">override</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="c1">/// ForExprAST - Expression class for for/in.</span>
+<span class="k">class</span> <span class="nc">ForExprAST</span> <span class="o">:</span> <span class="k">public</span> <span class="n">ExprAST</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">VarName</span><span class="p">;</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Start</span><span class="p">,</span> <span class="o">*</span><span class="n">End</span><span class="p">,</span> <span class="o">*</span><span class="n">Step</span><span class="p">,</span> <span class="o">*</span><span class="n">Body</span><span class="p">;</span>
+
+<span class="nl">public:</span>
+ <span class="n">ForExprAST</span><span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="o">&</span><span class="n">varname</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">start</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">end</span><span class="p">,</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">step</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">body</span><span class="p">)</span>
+ <span class="o">:</span> <span class="n">VarName</span><span class="p">(</span><span class="n">varname</span><span class="p">),</span> <span class="n">Start</span><span class="p">(</span><span class="n">start</span><span class="p">),</span> <span class="n">End</span><span class="p">(</span><span class="n">end</span><span class="p">),</span> <span class="n">Step</span><span class="p">(</span><span class="n">step</span><span class="p">),</span> <span class="n">Body</span><span class="p">(</span><span class="n">body</span><span class="p">)</span> <span class="p">{}</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">()</span> <span class="n">override</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="c1">/// PrototypeAST - This class represents the "prototype" for a function,</span>
+<span class="c1">/// which captures its name, and its argument names (thus implicitly the number</span>
+<span class="c1">/// of arguments the function takes).</span>
+<span class="k">class</span> <span class="nc">PrototypeAST</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">Name</span><span class="p">;</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span> <span class="n">Args</span><span class="p">;</span>
+
+<span class="nl">public:</span>
+ <span class="n">PrototypeAST</span><span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="o">&</span><span class="n">name</span><span class="p">,</span> <span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span> <span class="o">&</span><span class="n">args</span><span class="p">)</span>
+ <span class="o">:</span> <span class="n">Name</span><span class="p">(</span><span class="n">name</span><span class="p">),</span> <span class="n">Args</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="p">{}</span>
+
+ <span class="n">Function</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">();</span>
+<span class="p">};</span>
+
+<span class="c1">/// FunctionAST - This class represents a function definition itself.</span>
+<span class="k">class</span> <span class="nc">FunctionAST</span> <span class="p">{</span>
+ <span class="n">PrototypeAST</span> <span class="o">*</span><span class="n">Proto</span><span class="p">;</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Body</span><span class="p">;</span>
+
+<span class="nl">public:</span>
+ <span class="n">FunctionAST</span><span class="p">(</span><span class="n">PrototypeAST</span> <span class="o">*</span><span class="n">proto</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">body</span><span class="p">)</span> <span class="o">:</span> <span class="n">Proto</span><span class="p">(</span><span class="n">proto</span><span class="p">),</span> <span class="n">Body</span><span class="p">(</span><span class="n">body</span><span class="p">)</span> <span class="p">{}</span>
+
+ <span class="n">Function</span> <span class="o">*</span><span class="n">Codegen</span><span class="p">();</span>
+<span class="p">};</span>
+<span class="p">}</span> <span class="c1">// end anonymous namespace</span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// Parser</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+
+<span class="c1">/// CurTok/getNextToken - Provide a simple token buffer. CurTok is the current</span>
+<span class="c1">/// token the parser is looking at. getNextToken reads another token from the</span>
+<span class="c1">/// lexer and updates CurTok with its results.</span>
+<span class="k">static</span> <span class="kt">int</span> <span class="n">CurTok</span><span class="p">;</span>
+<span class="k">static</span> <span class="kt">int</span> <span class="nf">getNextToken</span><span class="p">()</span> <span class="p">{</span> <span class="k">return</span> <span class="n">CurTok</span> <span class="o">=</span> <span class="n">gettok</span><span class="p">();</span> <span class="p">}</span>
+
+<span class="c1">/// BinopPrecedence - This holds the precedence for each binary operator that is</span>
+<span class="c1">/// defined.</span>
+<span class="k">static</span> <span class="n">std</span><span class="o">::</span><span class="n">map</span><span class="o"><</span><span class="kt">char</span><span class="p">,</span> <span class="kt">int</span><span class="o">></span> <span class="n">BinopPrecedence</span><span class="p">;</span>
+
+<span class="c1">/// GetTokPrecedence - Get the precedence of the pending binary operator token.</span>
+<span class="k">static</span> <span class="kt">int</span> <span class="nf">GetTokPrecedence</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">isascii</span><span class="p">(</span><span class="n">CurTok</span><span class="p">))</span>
+ <span class="k">return</span> <span class="o">-</span><span class="mi">1</span><span class="p">;</span>
+
+ <span class="c1">// Make sure it's a declared binop.</span>
+ <span class="kt">int</span> <span class="n">TokPrec</span> <span class="o">=</span> <span class="n">BinopPrecedence</span><span class="p">[</span><span class="n">CurTok</span><span class="p">];</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">TokPrec</span> <span class="o"><=</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="o">-</span><span class="mi">1</span><span class="p">;</span>
+ <span class="k">return</span> <span class="n">TokPrec</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">/// Error* - These are little helper functions for error handling.</span>
+<span class="n">ExprAST</span> <span class="o">*</span><span class="nf">Error</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">Str</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"Error: %s</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">Str</span><span class="p">);</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+<span class="n">PrototypeAST</span> <span class="o">*</span><span class="nf">ErrorP</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">Str</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">Error</span><span class="p">(</span><span class="n">Str</span><span class="p">);</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+<span class="n">FunctionAST</span> <span class="o">*</span><span class="nf">ErrorF</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">Str</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">Error</span><span class="p">(</span><span class="n">Str</span><span class="p">);</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseExpression</span><span class="p">();</span>
+
+<span class="c1">/// identifierexpr</span>
+<span class="c1">/// ::= identifier</span>
+<span class="c1">/// ::= identifier '(' expression* ')'</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseIdentifierExpr</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">IdName</span> <span class="o">=</span> <span class="n">IdentifierStr</span><span class="p">;</span>
+
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat identifier.</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">'('</span><span class="p">)</span> <span class="c1">// Simple variable ref.</span>
+ <span class="k">return</span> <span class="k">new</span> <span class="n">VariableExprAST</span><span class="p">(</span><span class="n">IdName</span><span class="p">);</span>
+
+ <span class="c1">// Call.</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat (</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">ExprAST</span> <span class="o">*></span> <span class="n">Args</span><span class="p">;</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">')'</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">while</span> <span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Arg</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">Arg</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="n">Args</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">Arg</span><span class="p">);</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">==</span> <span class="sc">')'</span><span class="p">)</span>
+ <span class="k">break</span><span class="p">;</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">','</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"Expected ')' or ',' in argument list"</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+
+ <span class="c1">// Eat the ')'.</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+
+ <span class="k">return</span> <span class="k">new</span> <span class="n">CallExprAST</span><span class="p">(</span><span class="n">IdName</span><span class="p">,</span> <span class="n">Args</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="c1">/// numberexpr ::= number</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseNumberExpr</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Result</span> <span class="o">=</span> <span class="k">new</span> <span class="n">NumberExprAST</span><span class="p">(</span><span class="n">NumVal</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// consume the number</span>
+ <span class="k">return</span> <span class="n">Result</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">/// parenexpr ::= '(' expression ')'</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseParenExpr</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat (.</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">V</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">V</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">')'</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"expected ')'"</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat ).</span>
+ <span class="k">return</span> <span class="n">V</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">/// ifexpr ::= 'if' expression 'then' expression 'else' expression</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseIfExpr</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat the if.</span>
+
+ <span class="c1">// condition.</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Cond</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">Cond</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="n">tok_then</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"expected then"</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat the then</span>
+
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Then</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">Then</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="n">tok_else</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"expected else"</span><span class="p">);</span>
+
+ <span class="n">getNextToken</span><span class="p">();</span>
+
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Else</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">Else</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">return</span> <span class="k">new</span> <span class="n">IfExprAST</span><span class="p">(</span><span class="n">Cond</span><span class="p">,</span> <span class="n">Then</span><span class="p">,</span> <span class="n">Else</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="c1">/// forexpr ::= 'for' identifier '=' expr ',' expr (',' expr)? 'in' expression</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseForExpr</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat the for.</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="n">tok_identifier</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"expected identifier after for"</span><span class="p">);</span>
+
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">IdName</span> <span class="o">=</span> <span class="n">IdentifierStr</span><span class="p">;</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat identifier.</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">'='</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"expected '=' after for"</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat '='.</span>
+
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Start</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">Start</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">','</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"expected ',' after for start value"</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">End</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">End</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="c1">// The step value is optional.</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Step</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">==</span> <span class="sc">','</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+ <span class="n">Step</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">Step</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="n">tok_in</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"expected 'in' after for"</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat 'in'.</span>
+
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">Body</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">Body</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">return</span> <span class="k">new</span> <span class="n">ForExprAST</span><span class="p">(</span><span class="n">IdName</span><span class="p">,</span> <span class="n">Start</span><span class="p">,</span> <span class="n">End</span><span class="p">,</span> <span class="n">Step</span><span class="p">,</span> <span class="n">Body</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="c1">/// primary</span>
+<span class="c1">/// ::= identifierexpr</span>
+<span class="c1">/// ::= numberexpr</span>
+<span class="c1">/// ::= parenexpr</span>
+<span class="c1">/// ::= ifexpr</span>
+<span class="c1">/// ::= forexpr</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParsePrimary</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">switch</span> <span class="p">(</span><span class="n">CurTok</span><span class="p">)</span> <span class="p">{</span>
+ <span class="nl">default:</span>
+ <span class="k">return</span> <span class="n">Error</span><span class="p">(</span><span class="s">"unknown token when expecting an expression"</span><span class="p">);</span>
+ <span class="k">case</span> <span class="n">tok_identifier</span>:
+ <span class="k">return</span> <span class="n">ParseIdentifierExpr</span><span class="p">();</span>
+ <span class="k">case</span> <span class="n">tok_number</span>:
+ <span class="k">return</span> <span class="n">ParseNumberExpr</span><span class="p">();</span>
+ <span class="k">case</span> <span class="sc">'('</span>:
+ <span class="k">return</span> <span class="n">ParseParenExpr</span><span class="p">();</span>
+ <span class="k">case</span> <span class="n">tok_if</span>:
+ <span class="k">return</span> <span class="n">ParseIfExpr</span><span class="p">();</span>
+ <span class="k">case</span> <span class="n">tok_for</span>:
+ <span class="k">return</span> <span class="n">ParseForExpr</span><span class="p">();</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="c1">/// binoprhs</span>
+<span class="c1">/// ::= ('+' primary)*</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseBinOpRHS</span><span class="p">(</span><span class="kt">int</span> <span class="n">ExprPrec</span><span class="p">,</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="n">LHS</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">// If this is a binop, find its precedence.</span>
+ <span class="k">while</span> <span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
+ <span class="kt">int</span> <span class="n">TokPrec</span> <span class="o">=</span> <span class="n">GetTokPrecedence</span><span class="p">();</span>
+
+ <span class="c1">// If this is a binop that binds at least as tightly as the current binop,</span>
+ <span class="c1">// consume it, otherwise we are done.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">TokPrec</span> <span class="o"><</span> <span class="n">ExprPrec</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">LHS</span><span class="p">;</span>
+
+ <span class="c1">// Okay, we know this is a binop.</span>
+ <span class="kt">int</span> <span class="n">BinOp</span> <span class="o">=</span> <span class="n">CurTok</span><span class="p">;</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat binop</span>
+
+ <span class="c1">// Parse the primary expression after the binary operator.</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">RHS</span> <span class="o">=</span> <span class="n">ParsePrimary</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">RHS</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="c1">// If BinOp binds less tightly with RHS than the operator after RHS, let</span>
+ <span class="c1">// the pending operator take RHS as its LHS.</span>
+ <span class="kt">int</span> <span class="n">NextPrec</span> <span class="o">=</span> <span class="n">GetTokPrecedence</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">TokPrec</span> <span class="o"><</span> <span class="n">NextPrec</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">RHS</span> <span class="o">=</span> <span class="n">ParseBinOpRHS</span><span class="p">(</span><span class="n">TokPrec</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="n">RHS</span><span class="p">);</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">RHS</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="c1">// Merge LHS/RHS.</span>
+ <span class="n">LHS</span> <span class="o">=</span> <span class="k">new</span> <span class="n">BinaryExprAST</span><span class="p">(</span><span class="n">BinOp</span><span class="p">,</span> <span class="n">LHS</span><span class="p">,</span> <span class="n">RHS</span><span class="p">);</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="c1">/// expression</span>
+<span class="c1">/// ::= primary binoprhs</span>
+<span class="c1">///</span>
+<span class="k">static</span> <span class="n">ExprAST</span> <span class="o">*</span><span class="nf">ParseExpression</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">ExprAST</span> <span class="o">*</span><span class="n">LHS</span> <span class="o">=</span> <span class="n">ParsePrimary</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">LHS</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">return</span> <span class="n">ParseBinOpRHS</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="n">LHS</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="c1">/// prototype</span>
+<span class="c1">/// ::= id '(' id* ')'</span>
+<span class="k">static</span> <span class="n">PrototypeAST</span> <span class="o">*</span><span class="nf">ParsePrototype</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="n">tok_identifier</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">ErrorP</span><span class="p">(</span><span class="s">"Expected function name in prototype"</span><span class="p">);</span>
+
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">FnName</span> <span class="o">=</span> <span class="n">IdentifierStr</span><span class="p">;</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">'('</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">ErrorP</span><span class="p">(</span><span class="s">"Expected '(' in prototype"</span><span class="p">);</span>
+
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span> <span class="n">ArgNames</span><span class="p">;</span>
+ <span class="k">while</span> <span class="p">(</span><span class="n">getNextToken</span><span class="p">()</span> <span class="o">==</span> <span class="n">tok_identifier</span><span class="p">)</span>
+ <span class="n">ArgNames</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">IdentifierStr</span><span class="p">);</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CurTok</span> <span class="o">!=</span> <span class="sc">')'</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">ErrorP</span><span class="p">(</span><span class="s">"Expected ')' in prototype"</span><span class="p">);</span>
+
+ <span class="c1">// success.</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat ')'.</span>
+
+ <span class="k">return</span> <span class="k">new</span> <span class="n">PrototypeAST</span><span class="p">(</span><span class="n">FnName</span><span class="p">,</span> <span class="n">ArgNames</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="c1">/// definition ::= 'def' prototype expression</span>
+<span class="k">static</span> <span class="n">FunctionAST</span> <span class="o">*</span><span class="nf">ParseDefinition</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat def.</span>
+ <span class="n">PrototypeAST</span> <span class="o">*</span><span class="n">Proto</span> <span class="o">=</span> <span class="n">ParsePrototype</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">Proto</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">ExprAST</span> <span class="o">*</span><span class="n">E</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">())</span>
+ <span class="k">return</span> <span class="k">new</span> <span class="n">FunctionAST</span><span class="p">(</span><span class="n">Proto</span><span class="p">,</span> <span class="n">E</span><span class="p">);</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">/// toplevelexpr ::= expression</span>
+<span class="k">static</span> <span class="n">FunctionAST</span> <span class="o">*</span><span class="nf">ParseTopLevelExpr</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">ExprAST</span> <span class="o">*</span><span class="n">E</span> <span class="o">=</span> <span class="n">ParseExpression</span><span class="p">())</span> <span class="p">{</span>
+ <span class="c1">// Make an anonymous proto.</span>
+ <span class="n">PrototypeAST</span> <span class="o">*</span><span class="n">Proto</span> <span class="o">=</span> <span class="k">new</span> <span class="n">PrototypeAST</span><span class="p">(</span><span class="s">""</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span><span class="p">());</span>
+ <span class="k">return</span> <span class="k">new</span> <span class="n">FunctionAST</span><span class="p">(</span><span class="n">Proto</span><span class="p">,</span> <span class="n">E</span><span class="p">);</span>
+ <span class="p">}</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">/// external ::= 'extern' prototype</span>
+<span class="k">static</span> <span class="n">PrototypeAST</span> <span class="o">*</span><span class="nf">ParseExtern</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">getNextToken</span><span class="p">();</span> <span class="c1">// eat extern.</span>
+ <span class="k">return</span> <span class="n">ParsePrototype</span><span class="p">();</span>
+<span class="p">}</span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// Code Generation</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+
+<span class="k">static</span> <span class="n">Module</span> <span class="o">*</span><span class="n">TheModule</span><span class="p">;</span>
+<span class="k">static</span> <span class="n">IRBuilder</span><span class="o"><></span> <span class="n">Builder</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">());</span>
+<span class="k">static</span> <span class="n">std</span><span class="o">::</span><span class="n">map</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">,</span> <span class="n">Value</span> <span class="o">*></span> <span class="n">NamedValues</span><span class="p">;</span>
+<span class="k">static</span> <span class="n">legacy</span><span class="o">::</span><span class="n">FunctionPassManager</span> <span class="o">*</span><span class="n">TheFPM</span><span class="p">;</span>
+
+<span class="n">Value</span> <span class="o">*</span><span class="nf">ErrorV</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">Str</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">Error</span><span class="p">(</span><span class="n">Str</span><span class="p">);</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="n">Value</span> <span class="o">*</span><span class="n">NumberExprAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="n">ConstantFP</span><span class="o">::</span><span class="n">get</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">(),</span> <span class="n">APFloat</span><span class="p">(</span><span class="n">Val</span><span class="p">));</span>
+<span class="p">}</span>
+
+<span class="n">Value</span> <span class="o">*</span><span class="n">VariableExprAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="c1">// Look this variable up in the function.</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">V</span> <span class="o">=</span> <span class="n">NamedValues</span><span class="p">[</span><span class="n">Name</span><span class="p">];</span>
+ <span class="k">return</span> <span class="n">V</span> <span class="o">?</span> <span class="n">V</span> <span class="o">:</span> <span class="n">ErrorV</span><span class="p">(</span><span class="s">"Unknown variable name"</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="n">Value</span> <span class="o">*</span><span class="n">BinaryExprAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">L</span> <span class="o">=</span> <span class="n">LHS</span><span class="o">-></span><span class="n">Codegen</span><span class="p">();</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">R</span> <span class="o">=</span> <span class="n">RHS</span><span class="o">-></span><span class="n">Codegen</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">L</span> <span class="o">==</span> <span class="mi">0</span> <span class="o">||</span> <span class="n">R</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="k">switch</span> <span class="p">(</span><span class="n">Op</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">case</span> <span class="sc">'+'</span>:
+ <span class="k">return</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateFAdd</span><span class="p">(</span><span class="n">L</span><span class="p">,</span> <span class="n">R</span><span class="p">,</span> <span class="s">"addtmp"</span><span class="p">);</span>
+ <span class="k">case</span> <span class="sc">'-'</span>:
+ <span class="k">return</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateFSub</span><span class="p">(</span><span class="n">L</span><span class="p">,</span> <span class="n">R</span><span class="p">,</span> <span class="s">"subtmp"</span><span class="p">);</span>
+ <span class="k">case</span> <span class="sc">'*'</span>:
+ <span class="k">return</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateFMul</span><span class="p">(</span><span class="n">L</span><span class="p">,</span> <span class="n">R</span><span class="p">,</span> <span class="s">"multmp"</span><span class="p">);</span>
+ <span class="k">case</span> <span class="sc">'<'</span>:
+ <span class="n">L</span> <span class="o">=</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateFCmpULT</span><span class="p">(</span><span class="n">L</span><span class="p">,</span> <span class="n">R</span><span class="p">,</span> <span class="s">"cmptmp"</span><span class="p">);</span>
+ <span class="c1">// Convert bool 0/1 to double 0.0 or 1.0</span>
+ <span class="k">return</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateUIToFP</span><span class="p">(</span><span class="n">L</span><span class="p">,</span> <span class="n">Type</span><span class="o">::</span><span class="n">getDoubleTy</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">()),</span>
+ <span class="s">"booltmp"</span><span class="p">);</span>
+ <span class="nl">default:</span>
+ <span class="k">return</span> <span class="nf">ErrorV</span><span class="p">(</span><span class="s">"invalid binary operator"</span><span class="p">);</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="n">Value</span> <span class="o">*</span><span class="n">CallExprAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="c1">// Look up the name in the global module table.</span>
+ <span class="n">Function</span> <span class="o">*</span><span class="n">CalleeF</span> <span class="o">=</span> <span class="n">TheModule</span><span class="o">-></span><span class="n">getFunction</span><span class="p">(</span><span class="n">Callee</span><span class="p">);</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CalleeF</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">ErrorV</span><span class="p">(</span><span class="s">"Unknown function referenced"</span><span class="p">);</span>
+
+ <span class="c1">// If argument mismatch error.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CalleeF</span><span class="o">-></span><span class="n">arg_size</span><span class="p">()</span> <span class="o">!=</span> <span class="n">Args</span><span class="p">.</span><span class="n">size</span><span class="p">())</span>
+ <span class="k">return</span> <span class="n">ErrorV</span><span class="p">(</span><span class="s">"Incorrect # arguments passed"</span><span class="p">);</span>
+
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">Value</span> <span class="o">*></span> <span class="n">ArgsV</span><span class="p">;</span>
+ <span class="k">for</span> <span class="p">(</span><span class="kt">unsigned</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">,</span> <span class="n">e</span> <span class="o">=</span> <span class="n">Args</span><span class="p">.</span><span class="n">size</span><span class="p">();</span> <span class="n">i</span> <span class="o">!=</span> <span class="n">e</span><span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">ArgsV</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">Args</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">-></span><span class="n">Codegen</span><span class="p">());</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">ArgsV</span><span class="p">.</span><span class="n">back</span><span class="p">()</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="k">return</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateCall</span><span class="p">(</span><span class="n">CalleeF</span><span class="p">,</span> <span class="n">ArgsV</span><span class="p">,</span> <span class="s">"calltmp"</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="n">Value</span> <span class="o">*</span><span class="n">IfExprAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">CondV</span> <span class="o">=</span> <span class="n">Cond</span><span class="o">-></span><span class="n">Codegen</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">CondV</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="c1">// Convert condition to a bool by comparing equal to 0.0.</span>
+ <span class="n">CondV</span> <span class="o">=</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateFCmpONE</span><span class="p">(</span>
+ <span class="n">CondV</span><span class="p">,</span> <span class="n">ConstantFP</span><span class="o">::</span><span class="n">get</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">(),</span> <span class="n">APFloat</span><span class="p">(</span><span class="mf">0.0</span><span class="p">)),</span> <span class="s">"ifcond"</span><span class="p">);</span>
+
+ <span class="n">Function</span> <span class="o">*</span><span class="n">TheFunction</span> <span class="o">=</span> <span class="n">Builder</span><span class="p">.</span><span class="n">GetInsertBlock</span><span class="p">()</span><span class="o">-></span><span class="n">getParent</span><span class="p">();</span>
+
+ <span class="c1">// Create blocks for the then and else cases. Insert the 'then' block at the</span>
+ <span class="c1">// end of the function.</span>
+ <span class="n">BasicBlock</span> <span class="o">*</span><span class="n">ThenBB</span> <span class="o">=</span>
+ <span class="n">BasicBlock</span><span class="o">::</span><span class="n">Create</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">(),</span> <span class="s">"then"</span><span class="p">,</span> <span class="n">TheFunction</span><span class="p">);</span>
+ <span class="n">BasicBlock</span> <span class="o">*</span><span class="n">ElseBB</span> <span class="o">=</span> <span class="n">BasicBlock</span><span class="o">::</span><span class="n">Create</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">(),</span> <span class="s">"else"</span><span class="p">);</span>
+ <span class="n">BasicBlock</span> <span class="o">*</span><span class="n">MergeBB</span> <span class="o">=</span> <span class="n">BasicBlock</span><span class="o">::</span><span class="n">Create</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">(),</span> <span class="s">"ifcont"</span><span class="p">);</span>
+
+ <span class="n">Builder</span><span class="p">.</span><span class="n">CreateCondBr</span><span class="p">(</span><span class="n">CondV</span><span class="p">,</span> <span class="n">ThenBB</span><span class="p">,</span> <span class="n">ElseBB</span><span class="p">);</span>
+
+ <span class="c1">// Emit then value.</span>
+ <span class="n">Builder</span><span class="p">.</span><span class="n">SetInsertPoint</span><span class="p">(</span><span class="n">ThenBB</span><span class="p">);</span>
+
+ <span class="n">Value</span> <span class="o">*</span><span class="n">ThenV</span> <span class="o">=</span> <span class="n">Then</span><span class="o">-></span><span class="n">Codegen</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">ThenV</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="n">Builder</span><span class="p">.</span><span class="n">CreateBr</span><span class="p">(</span><span class="n">MergeBB</span><span class="p">);</span>
+ <span class="c1">// Codegen of 'Then' can change the current block, update ThenBB for the PHI.</span>
+ <span class="n">ThenBB</span> <span class="o">=</span> <span class="n">Builder</span><span class="p">.</span><span class="n">GetInsertBlock</span><span class="p">();</span>
+
+ <span class="c1">// Emit else block.</span>
+ <span class="n">TheFunction</span><span class="o">-></span><span class="n">getBasicBlockList</span><span class="p">().</span><span class="n">push_back</span><span class="p">(</span><span class="n">ElseBB</span><span class="p">);</span>
+ <span class="n">Builder</span><span class="p">.</span><span class="n">SetInsertPoint</span><span class="p">(</span><span class="n">ElseBB</span><span class="p">);</span>
+
+ <span class="n">Value</span> <span class="o">*</span><span class="n">ElseV</span> <span class="o">=</span> <span class="n">Else</span><span class="o">-></span><span class="n">Codegen</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">ElseV</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="n">Builder</span><span class="p">.</span><span class="n">CreateBr</span><span class="p">(</span><span class="n">MergeBB</span><span class="p">);</span>
+ <span class="c1">// Codegen of 'Else' can change the current block, update ElseBB for the PHI.</span>
+ <span class="n">ElseBB</span> <span class="o">=</span> <span class="n">Builder</span><span class="p">.</span><span class="n">GetInsertBlock</span><span class="p">();</span>
+
+ <span class="c1">// Emit merge block.</span>
+ <span class="n">TheFunction</span><span class="o">-></span><span class="n">getBasicBlockList</span><span class="p">().</span><span class="n">push_back</span><span class="p">(</span><span class="n">MergeBB</span><span class="p">);</span>
+ <span class="n">Builder</span><span class="p">.</span><span class="n">SetInsertPoint</span><span class="p">(</span><span class="n">MergeBB</span><span class="p">);</span>
+ <span class="n">PHINode</span> <span class="o">*</span><span class="n">PN</span> <span class="o">=</span>
+ <span class="n">Builder</span><span class="p">.</span><span class="n">CreatePHI</span><span class="p">(</span><span class="n">Type</span><span class="o">::</span><span class="n">getDoubleTy</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">()),</span> <span class="mi">2</span><span class="p">,</span> <span class="s">"iftmp"</span><span class="p">);</span>
+
+ <span class="n">PN</span><span class="o">-></span><span class="n">addIncoming</span><span class="p">(</span><span class="n">ThenV</span><span class="p">,</span> <span class="n">ThenBB</span><span class="p">);</span>
+ <span class="n">PN</span><span class="o">-></span><span class="n">addIncoming</span><span class="p">(</span><span class="n">ElseV</span><span class="p">,</span> <span class="n">ElseBB</span><span class="p">);</span>
+ <span class="k">return</span> <span class="n">PN</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="n">Value</span> <span class="o">*</span><span class="n">ForExprAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="c1">// Output this as:</span>
+ <span class="c1">// ...</span>
+ <span class="c1">// start = startexpr</span>
+ <span class="c1">// goto loop</span>
+ <span class="c1">// loop:</span>
+ <span class="c1">// variable = phi [start, loopheader], [nextvariable, loopend]</span>
+ <span class="c1">// ...</span>
+ <span class="c1">// bodyexpr</span>
+ <span class="c1">// ...</span>
+ <span class="c1">// loopend:</span>
+ <span class="c1">// step = stepexpr</span>
+ <span class="c1">// nextvariable = variable + step</span>
+ <span class="c1">// endcond = endexpr</span>
+ <span class="c1">// br endcond, loop, endloop</span>
+ <span class="c1">// outloop:</span>
+
+ <span class="c1">// Emit the start code first, without 'variable' in scope.</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">StartVal</span> <span class="o">=</span> <span class="n">Start</span><span class="o">-></span><span class="n">Codegen</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">StartVal</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="c1">// Make the new basic block for the loop header, inserting after current</span>
+ <span class="c1">// block.</span>
+ <span class="n">Function</span> <span class="o">*</span><span class="n">TheFunction</span> <span class="o">=</span> <span class="n">Builder</span><span class="p">.</span><span class="n">GetInsertBlock</span><span class="p">()</span><span class="o">-></span><span class="n">getParent</span><span class="p">();</span>
+ <span class="n">BasicBlock</span> <span class="o">*</span><span class="n">PreheaderBB</span> <span class="o">=</span> <span class="n">Builder</span><span class="p">.</span><span class="n">GetInsertBlock</span><span class="p">();</span>
+ <span class="n">BasicBlock</span> <span class="o">*</span><span class="n">LoopBB</span> <span class="o">=</span>
+ <span class="n">BasicBlock</span><span class="o">::</span><span class="n">Create</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">(),</span> <span class="s">"loop"</span><span class="p">,</span> <span class="n">TheFunction</span><span class="p">);</span>
+
+ <span class="c1">// Insert an explicit fall through from the current block to the LoopBB.</span>
+ <span class="n">Builder</span><span class="p">.</span><span class="n">CreateBr</span><span class="p">(</span><span class="n">LoopBB</span><span class="p">);</span>
+
+ <span class="c1">// Start insertion in LoopBB.</span>
+ <span class="n">Builder</span><span class="p">.</span><span class="n">SetInsertPoint</span><span class="p">(</span><span class="n">LoopBB</span><span class="p">);</span>
+
+ <span class="c1">// Start the PHI node with an entry for Start.</span>
+ <span class="n">PHINode</span> <span class="o">*</span><span class="n">Variable</span> <span class="o">=</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreatePHI</span><span class="p">(</span><span class="n">Type</span><span class="o">::</span><span class="n">getDoubleTy</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">()),</span>
+ <span class="mi">2</span><span class="p">,</span> <span class="n">VarName</span><span class="p">.</span><span class="n">c_str</span><span class="p">());</span>
+ <span class="n">Variable</span><span class="o">-></span><span class="n">addIncoming</span><span class="p">(</span><span class="n">StartVal</span><span class="p">,</span> <span class="n">PreheaderBB</span><span class="p">);</span>
+
+ <span class="c1">// Within the loop, the variable is defined equal to the PHI node. If it</span>
+ <span class="c1">// shadows an existing variable, we have to restore it, so save it now.</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">OldVal</span> <span class="o">=</span> <span class="n">NamedValues</span><span class="p">[</span><span class="n">VarName</span><span class="p">];</span>
+ <span class="n">NamedValues</span><span class="p">[</span><span class="n">VarName</span><span class="p">]</span> <span class="o">=</span> <span class="n">Variable</span><span class="p">;</span>
+
+ <span class="c1">// Emit the body of the loop. This, like any other expr, can change the</span>
+ <span class="c1">// current BB. Note that we ignore the value computed by the body, but don't</span>
+ <span class="c1">// allow an error.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">Body</span><span class="o">-></span><span class="n">Codegen</span><span class="p">()</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="c1">// Emit the step value.</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">StepVal</span><span class="p">;</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">Step</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">StepVal</span> <span class="o">=</span> <span class="n">Step</span><span class="o">-></span><span class="n">Codegen</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">StepVal</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+ <span class="c1">// If not specified, use 1.0.</span>
+ <span class="n">StepVal</span> <span class="o">=</span> <span class="n">ConstantFP</span><span class="o">::</span><span class="n">get</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">(),</span> <span class="n">APFloat</span><span class="p">(</span><span class="mf">1.0</span><span class="p">));</span>
+ <span class="p">}</span>
+
+ <span class="n">Value</span> <span class="o">*</span><span class="n">NextVar</span> <span class="o">=</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateFAdd</span><span class="p">(</span><span class="n">Variable</span><span class="p">,</span> <span class="n">StepVal</span><span class="p">,</span> <span class="s">"nextvar"</span><span class="p">);</span>
+
+ <span class="c1">// Compute the end condition.</span>
+ <span class="n">Value</span> <span class="o">*</span><span class="n">EndCond</span> <span class="o">=</span> <span class="n">End</span><span class="o">-></span><span class="n">Codegen</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">EndCond</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="n">EndCond</span><span class="p">;</span>
+
+ <span class="c1">// Convert condition to a bool by comparing equal to 0.0.</span>
+ <span class="n">EndCond</span> <span class="o">=</span> <span class="n">Builder</span><span class="p">.</span><span class="n">CreateFCmpONE</span><span class="p">(</span>
+ <span class="n">EndCond</span><span class="p">,</span> <span class="n">ConstantFP</span><span class="o">::</span><span class="n">get</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">(),</span> <span class="n">APFloat</span><span class="p">(</span><span class="mf">0.0</span><span class="p">)),</span> <span class="s">"loopcond"</span><span class="p">);</span>
+
+ <span class="c1">// Create the "after loop" block and insert it.</span>
+ <span class="n">BasicBlock</span> <span class="o">*</span><span class="n">LoopEndBB</span> <span class="o">=</span> <span class="n">Builder</span><span class="p">.</span><span class="n">GetInsertBlock</span><span class="p">();</span>
+ <span class="n">BasicBlock</span> <span class="o">*</span><span class="n">AfterBB</span> <span class="o">=</span>
+ <span class="n">BasicBlock</span><span class="o">::</span><span class="n">Create</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">(),</span> <span class="s">"afterloop"</span><span class="p">,</span> <span class="n">TheFunction</span><span class="p">);</span>
+
+ <span class="c1">// Insert the conditional branch into the end of LoopEndBB.</span>
+ <span class="n">Builder</span><span class="p">.</span><span class="n">CreateCondBr</span><span class="p">(</span><span class="n">EndCond</span><span class="p">,</span> <span class="n">LoopBB</span><span class="p">,</span> <span class="n">AfterBB</span><span class="p">);</span>
+
+ <span class="c1">// Any new code will be inserted in AfterBB.</span>
+ <span class="n">Builder</span><span class="p">.</span><span class="n">SetInsertPoint</span><span class="p">(</span><span class="n">AfterBB</span><span class="p">);</span>
+
+ <span class="c1">// Add a new entry to the PHI node for the backedge.</span>
+ <span class="n">Variable</span><span class="o">-></span><span class="n">addIncoming</span><span class="p">(</span><span class="n">NextVar</span><span class="p">,</span> <span class="n">LoopEndBB</span><span class="p">);</span>
+
+ <span class="c1">// Restore the unshadowed variable.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">OldVal</span><span class="p">)</span>
+ <span class="n">NamedValues</span><span class="p">[</span><span class="n">VarName</span><span class="p">]</span> <span class="o">=</span> <span class="n">OldVal</span><span class="p">;</span>
+ <span class="k">else</span>
+ <span class="n">NamedValues</span><span class="p">.</span><span class="n">erase</span><span class="p">(</span><span class="n">VarName</span><span class="p">);</span>
+
+ <span class="c1">// for expr always returns 0.0.</span>
+ <span class="k">return</span> <span class="n">Constant</span><span class="o">::</span><span class="n">getNullValue</span><span class="p">(</span><span class="n">Type</span><span class="o">::</span><span class="n">getDoubleTy</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">()));</span>
+<span class="p">}</span>
+
+<span class="n">Function</span> <span class="o">*</span><span class="n">PrototypeAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="c1">// Make the function type: double(double,double) etc.</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">Type</span> <span class="o">*></span> <span class="n">Doubles</span><span class="p">(</span><span class="n">Args</span><span class="p">.</span><span class="n">size</span><span class="p">(),</span>
+ <span class="n">Type</span><span class="o">::</span><span class="n">getDoubleTy</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">()));</span>
+ <span class="n">FunctionType</span> <span class="o">*</span><span class="n">FT</span> <span class="o">=</span>
+ <span class="n">FunctionType</span><span class="o">::</span><span class="n">get</span><span class="p">(</span><span class="n">Type</span><span class="o">::</span><span class="n">getDoubleTy</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">()),</span> <span class="n">Doubles</span><span class="p">,</span> <span class="nb">false</span><span class="p">);</span>
+
+ <span class="n">Function</span> <span class="o">*</span><span class="n">F</span> <span class="o">=</span>
+ <span class="n">Function</span><span class="o">::</span><span class="n">Create</span><span class="p">(</span><span class="n">FT</span><span class="p">,</span> <span class="n">Function</span><span class="o">::</span><span class="n">ExternalLinkage</span><span class="p">,</span> <span class="n">Name</span><span class="p">,</span> <span class="n">TheModule</span><span class="p">);</span>
+
+ <span class="c1">// If F conflicted, there was already something named 'Name'. If it has a</span>
+ <span class="c1">// body, don't allow redefinition or reextern.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">F</span><span class="o">-></span><span class="n">getName</span><span class="p">()</span> <span class="o">!=</span> <span class="n">Name</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">// Delete the one we just made and get the existing one.</span>
+ <span class="n">F</span><span class="o">-></span><span class="n">eraseFromParent</span><span class="p">();</span>
+ <span class="n">F</span> <span class="o">=</span> <span class="n">TheModule</span><span class="o">-></span><span class="n">getFunction</span><span class="p">(</span><span class="n">Name</span><span class="p">);</span>
+
+ <span class="c1">// If F already has a body, reject this.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">F</span><span class="o">-></span><span class="n">empty</span><span class="p">())</span> <span class="p">{</span>
+ <span class="n">ErrorF</span><span class="p">(</span><span class="s">"redefinition of function"</span><span class="p">);</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="c1">// If F took a different number of args, reject.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">F</span><span class="o">-></span><span class="n">arg_size</span><span class="p">()</span> <span class="o">!=</span> <span class="n">Args</span><span class="p">.</span><span class="n">size</span><span class="p">())</span> <span class="p">{</span>
+ <span class="n">ErrorF</span><span class="p">(</span><span class="s">"redefinition of function with different # args"</span><span class="p">);</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+
+ <span class="c1">// Set names for all arguments.</span>
+ <span class="kt">unsigned</span> <span class="n">Idx</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="k">for</span> <span class="p">(</span><span class="n">Function</span><span class="o">::</span><span class="n">arg_iterator</span> <span class="n">AI</span> <span class="o">=</span> <span class="n">F</span><span class="o">-></span><span class="n">arg_begin</span><span class="p">();</span> <span class="n">Idx</span> <span class="o">!=</span> <span class="n">Args</span><span class="p">.</span><span class="n">size</span><span class="p">();</span>
+ <span class="o">++</span><span class="n">AI</span><span class="p">,</span> <span class="o">++</span><span class="n">Idx</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">AI</span><span class="o">-></span><span class="n">setName</span><span class="p">(</span><span class="n">Args</span><span class="p">[</span><span class="n">Idx</span><span class="p">]);</span>
+
+ <span class="c1">// Add arguments to variable symbol table.</span>
+ <span class="n">NamedValues</span><span class="p">[</span><span class="n">Args</span><span class="p">[</span><span class="n">Idx</span><span class="p">]]</span> <span class="o">=</span> <span class="n">AI</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="k">return</span> <span class="n">F</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="n">Function</span> <span class="o">*</span><span class="n">FunctionAST</span><span class="o">::</span><span class="n">Codegen</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">NamedValues</span><span class="p">.</span><span class="n">clear</span><span class="p">();</span>
+
+ <span class="n">Function</span> <span class="o">*</span><span class="n">TheFunction</span> <span class="o">=</span> <span class="n">Proto</span><span class="o">-></span><span class="n">Codegen</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">TheFunction</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="c1">// Create a new basic block to start insertion into.</span>
+ <span class="n">BasicBlock</span> <span class="o">*</span><span class="n">BB</span> <span class="o">=</span> <span class="n">BasicBlock</span><span class="o">::</span><span class="n">Create</span><span class="p">(</span><span class="n">getGlobalContext</span><span class="p">(),</span> <span class="s">"entry"</span><span class="p">,</span> <span class="n">TheFunction</span><span class="p">);</span>
+ <span class="n">Builder</span><span class="p">.</span><span class="n">SetInsertPoint</span><span class="p">(</span><span class="n">BB</span><span class="p">);</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">Value</span> <span class="o">*</span><span class="n">RetVal</span> <span class="o">=</span> <span class="n">Body</span><span class="o">-></span><span class="n">Codegen</span><span class="p">())</span> <span class="p">{</span>
+ <span class="c1">// Finish off the function.</span>
+ <span class="n">Builder</span><span class="p">.</span><span class="n">CreateRet</span><span class="p">(</span><span class="n">RetVal</span><span class="p">);</span>
+
+ <span class="c1">// Validate the generated code, checking for consistency.</span>
+ <span class="n">verifyFunction</span><span class="p">(</span><span class="o">*</span><span class="n">TheFunction</span><span class="p">);</span>
+
+ <span class="c1">// Optimize the function.</span>
+ <span class="n">TheFPM</span><span class="o">-></span><span class="n">run</span><span class="p">(</span><span class="o">*</span><span class="n">TheFunction</span><span class="p">);</span>
+
+ <span class="k">return</span> <span class="n">TheFunction</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="c1">// Error reading body, remove function.</span>
+ <span class="n">TheFunction</span><span class="o">-></span><span class="n">eraseFromParent</span><span class="p">();</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// Top-Level parsing and JIT Driver</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+
+<span class="k">static</span> <span class="n">ExecutionEngine</span> <span class="o">*</span><span class="n">TheExecutionEngine</span><span class="p">;</span>
+
+<span class="k">static</span> <span class="kt">void</span> <span class="nf">HandleDefinition</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">FunctionAST</span> <span class="o">*</span><span class="n">F</span> <span class="o">=</span> <span class="n">ParseDefinition</span><span class="p">())</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">Function</span> <span class="o">*</span><span class="n">LF</span> <span class="o">=</span> <span class="n">F</span><span class="o">-></span><span class="n">Codegen</span><span class="p">())</span> <span class="p">{</span>
+ <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"Read function definition:"</span><span class="p">);</span>
+ <span class="n">LF</span><span class="o">-></span><span class="n">dump</span><span class="p">();</span>
+ <span class="p">}</span>
+ <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+ <span class="c1">// Skip token for error recovery.</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="k">static</span> <span class="kt">void</span> <span class="nf">HandleExtern</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">PrototypeAST</span> <span class="o">*</span><span class="n">P</span> <span class="o">=</span> <span class="n">ParseExtern</span><span class="p">())</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">Function</span> <span class="o">*</span><span class="n">F</span> <span class="o">=</span> <span class="n">P</span><span class="o">-></span><span class="n">Codegen</span><span class="p">())</span> <span class="p">{</span>
+ <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"Read extern: "</span><span class="p">);</span>
+ <span class="n">F</span><span class="o">-></span><span class="n">dump</span><span class="p">();</span>
+ <span class="p">}</span>
+ <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+ <span class="c1">// Skip token for error recovery.</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="k">static</span> <span class="kt">void</span> <span class="nf">HandleTopLevelExpression</span><span class="p">()</span> <span class="p">{</span>
+ <span class="c1">// Evaluate a top-level expression into an anonymous function.</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">FunctionAST</span> <span class="o">*</span><span class="n">F</span> <span class="o">=</span> <span class="n">ParseTopLevelExpr</span><span class="p">())</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">Function</span> <span class="o">*</span><span class="n">LF</span> <span class="o">=</span> <span class="n">F</span><span class="o">-></span><span class="n">Codegen</span><span class="p">())</span> <span class="p">{</span>
+ <span class="n">TheExecutionEngine</span><span class="o">-></span><span class="n">finalizeObject</span><span class="p">();</span>
+ <span class="c1">// JIT the function, returning a function pointer.</span>
+ <span class="kt">void</span> <span class="o">*</span><span class="n">FPtr</span> <span class="o">=</span> <span class="n">TheExecutionEngine</span><span class="o">-></span><span class="n">getPointerToFunction</span><span class="p">(</span><span class="n">LF</span><span class="p">);</span>
+
+ <span class="c1">// Cast it to the right type (takes no arguments, returns a double) so we</span>
+ <span class="c1">// can call it as a native function.</span>
+ <span class="kt">double</span> <span class="p">(</span><span class="o">*</span><span class="n">FP</span><span class="p">)()</span> <span class="o">=</span> <span class="p">(</span><span class="kt">double</span> <span class="p">(</span><span class="o">*</span><span class="p">)())(</span><span class="kt">intptr_t</span><span class="p">)</span><span class="n">FPtr</span><span class="p">;</span>
+ <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"Evaluated to %f</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">FP</span><span class="p">());</span>
+ <span class="p">}</span>
+ <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+ <span class="c1">// Skip token for error recovery.</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="c1">/// top ::= definition | external | expression | ';'</span>
+<span class="k">static</span> <span class="kt">void</span> <span class="nf">MainLoop</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">while</span> <span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"ready> "</span><span class="p">);</span>
+ <span class="k">switch</span> <span class="p">(</span><span class="n">CurTok</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">case</span> <span class="n">tok_eof</span>:
+ <span class="k">return</span><span class="p">;</span>
+ <span class="k">case</span> <span class="sc">';'</span>:
+ <span class="n">getNextToken</span><span class="p">();</span>
+ <span class="k">break</span><span class="p">;</span> <span class="c1">// ignore top-level semicolons.</span>
+ <span class="k">case</span> <span class="n">tok_def</span>:
+ <span class="n">HandleDefinition</span><span class="p">();</span>
+ <span class="k">break</span><span class="p">;</span>
+ <span class="k">case</span> <span class="n">tok_extern</span>:
+ <span class="n">HandleExtern</span><span class="p">();</span>
+ <span class="k">break</span><span class="p">;</span>
+ <span class="nl">default:</span>
+ <span class="n">HandleTopLevelExpression</span><span class="p">();</span>
+ <span class="k">break</span><span class="p">;</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// "Library" functions that can be "extern'd" from user code.</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+
+<span class="c1">/// putchard - putchar that takes a double and returns 0.</span>
+<span class="k">extern</span> <span class="s">"C"</span> <span class="kt">double</span> <span class="n">putchard</span><span class="p">(</span><span class="kt">double</span> <span class="n">X</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">putchar</span><span class="p">((</span><span class="kt">char</span><span class="p">)</span><span class="n">X</span><span class="p">);</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+<span class="c1">// Main driver code.</span>
+<span class="c1">//===----------------------------------------------------------------------===//</span>
+
+<span class="kt">int</span> <span class="n">main</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">InitializeNativeTarget</span><span class="p">();</span>
+ <span class="n">InitializeNativeTargetAsmPrinter</span><span class="p">();</span>
+ <span class="n">InitializeNativeTargetAsmParser</span><span class="p">();</span>
+ <span class="n">LLVMContext</span> <span class="o">&</span><span class="n">Context</span> <span class="o">=</span> <span class="n">getGlobalContext</span><span class="p">();</span>
+
+ <span class="c1">// Install standard binary operators.</span>
+ <span class="c1">// 1 is lowest precedence.</span>
+ <span class="n">BinopPrecedence</span><span class="p">[</span><span class="sc">'<'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">10</span><span class="p">;</span>
+ <span class="n">BinopPrecedence</span><span class="p">[</span><span class="sc">'+'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">20</span><span class="p">;</span>
+ <span class="n">BinopPrecedence</span><span class="p">[</span><span class="sc">'-'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">20</span><span class="p">;</span>
+ <span class="n">BinopPrecedence</span><span class="p">[</span><span class="sc">'*'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">40</span><span class="p">;</span> <span class="c1">// highest.</span>
+
+ <span class="c1">// Prime the first token.</span>
+ <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"ready> "</span><span class="p">);</span>
+ <span class="n">getNextToken</span><span class="p">();</span>
+
+ <span class="c1">// Make the module, which holds all the code.</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">unique_ptr</span><span class="o"><</span><span class="n">Module</span><span class="o">></span> <span class="n">Owner</span> <span class="o">=</span> <span class="n">make_unique</span><span class="o"><</span><span class="n">Module</span><span class="o">></span><span class="p">(</span><span class="s">"my cool jit"</span><span class="p">,</span> <span class="n">Context</span><span class="p">);</span>
+ <span class="n">TheModule</span> <span class="o">=</span> <span class="n">Owner</span><span class="p">.</span><span class="n">get</span><span class="p">();</span>
+
+ <span class="c1">// Create the JIT. This takes ownership of the module.</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">ErrStr</span><span class="p">;</span>
+ <span class="n">TheExecutionEngine</span> <span class="o">=</span>
+ <span class="n">EngineBuilder</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">Owner</span><span class="p">))</span>
+ <span class="p">.</span><span class="n">setErrorStr</span><span class="p">(</span><span class="o">&</span><span class="n">ErrStr</span><span class="p">)</span>
+ <span class="p">.</span><span class="n">setMCJITMemoryManager</span><span class="p">(</span><span class="n">llvm</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">create</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">TheExecutionEngine</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">"Could not create ExecutionEngine: %s</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">ErrStr</span><span class="p">.</span><span class="n">c_str</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="n">legacy</span><span class="o">::</span><span class="n">FunctionPassManager</span> <span class="n">OurFPM</span><span class="p">(</span><span class="n">TheModule</span><span class="p">);</span>
+
+ <span class="c1">// Set up the optimizer pipeline. Start with registering info about how the</span>
+ <span class="c1">// target lays out data structures.</span>
+ <span class="n">TheModule</span><span class="o">-></span><span class="n">setDataLayout</span><span class="p">(</span><span class="o">*</span><span class="n">TheExecutionEngine</span><span class="o">-></span><span class="n">getDataLayout</span><span class="p">());</span>
+ <span class="c1">// Provide basic AliasAnalysis support for GVN.</span>
+ <span class="n">OurFPM</span><span class="p">.</span><span class="n">add</span><span class="p">(</span><span class="n">createBasicAliasAnalysisPass</span><span class="p">());</span>
+ <span class="c1">// Do simple "peephole" optimizations and bit-twiddling optzns.</span>
+ <span class="n">OurFPM</span><span class="p">.</span><span class="n">add</span><span class="p">(</span><span class="n">createInstructionCombiningPass</span><span class="p">());</span>
+ <span class="c1">// Reassociate expressions.</span>
+ <span class="n">OurFPM</span><span class="p">.</span><span class="n">add</span><span class="p">(</span><span class="n">createReassociatePass</span><span class="p">());</span>
+ <span class="c1">// Eliminate Common SubExpressions.</span>
+ <span class="n">OurFPM</span><span class="p">.</span><span class="n">add</span><span class="p">(</span><span class="n">createGVNPass</span><span class="p">());</span>
+ <span class="c1">// Simplify the control flow graph (deleting unreachable blocks, etc).</span>
+ <span class="n">OurFPM</span><span class="p">.</span><span class="n">add</span><span class="p">(</span><span class="n">createCFGSimplificationPass</span><span class="p">());</span>
+
+ <span class="n">OurFPM</span><span class="p">.</span><span class="n">doInitialization</span><span class="p">();</span>
+
+ <span class="c1">// Set the global so the code gen can use this.</span>
+ <span class="n">TheFPM</span> <span class="o">=</span> <span class="o">&</span><span class="n">OurFPM</span><span class="p">;</span>
+
+ <span class="c1">// Run the main "interpreter loop" now.</span>
+ <span class="n">MainLoop</span><span class="p">();</span>
+
+ <span class="n">TheFPM</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
+
+ <span class="c1">// Print out all of the generated code.</span>
+ <span class="n">TheModule</span><span class="o">-></span><span class="n">dump</span><span class="p">();</span>
+
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p><a class="reference external" href="LangImpl6.html">Next: Extending the language: user-defined operators</a></p>
+</div>
+</div>
+
+
+ </div>
+ </div>
+ <div class="clearer"></div>
+ </div>
+ <div class="related">
+ <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="LangImpl6.html" title="6. Kaleidoscope: Extending the Language: User-defined Operators"
+ >next</a> |</li>
+ <li class="right" >
+ <a href="LangImpl4.html" title="4. Kaleidoscope: Adding JIT and Optimizer Support"
+ >previous</a> |</li>
+ <li><a href="http://llvm.org/">LLVM Home</a> | </li>
+ <li><a href="../index.html">Documentation</a>»</li>
+
+ <li><a href="index.html" >LLVM Tutorial: Table of Contents</a> »</li>
+ </ul>
+ </div>
+ <div class="footer">
+ © Copyright 2003-2016, LLVM Project.
+ Last updated on 2016-01-04.
+ Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.2.3.
+ </div>
+ </body>
+</html>
\ No newline at end of file
More information about the llvm-commits
mailing list