mir/index.html - rust-lang/rustc-dev-guide - Git at Google

 <!DOCTYPE HTML>
 <html lang="en" class="light sidebar-visible" dir="ltr">
     <head>
         <!-- Book generated using mdBook -->
         <meta charset="UTF-8">
         <title>The MIR (Mid-level IR) - Rust Compiler Development Guide</title>


         <!-- Custom HTML head -->

         <meta name="description" content="A guide to developing the Rust compiler (rustc)">
         <meta name="viewport" content="width=device-width, initial-scale=1">
         <meta name="theme-color" content="#ffffff">

         <link rel="icon" href="../favicon.svg">
         <link rel="shortcut icon" href="../favicon.png">
         <link rel="stylesheet" href="../css/variables.css">
         <link rel="stylesheet" href="../css/general.css">
         <link rel="stylesheet" href="../css/chrome.css">
         <link rel="stylesheet" href="../css/print.css" media="print">

         <!-- Fonts -->
         <link rel="stylesheet" href="../FontAwesome/css/font-awesome.css">
         <link rel="stylesheet" href="../fonts/fonts.css">

         <!-- Highlight.js Stylesheets -->
         <link rel="stylesheet" id="highlight-css" href="../highlight.css">
         <link rel="stylesheet" id="tomorrow-night-css" href="../tomorrow-night.css">
         <link rel="stylesheet" id="ayu-highlight-css" href="../ayu-highlight.css">

         <!-- Custom theme stylesheets -->
         <link rel="stylesheet" href="../pagetoc.css">


         <!-- Provide site root and default themes to javascript -->
         <script>
             const path_to_root = "../";
             const default_light_theme = "light";
             const default_dark_theme = "navy";
             window.path_to_searchindex_js = "../searchindex.js";
         </script>
         <!-- Start loading toc.js asap -->
         <script src="../toc.js"></script>
     </head>
     <body>
     <div id="mdbook-help-container">
         <div id="mdbook-help-popup">
             <h2 class="mdbook-help-title">Keyboard shortcuts</h2>
             <div>
                 <p>Press <kbd>←</kbd> or <kbd>→</kbd> to navigate between chapters</p>
                 <p>Press <kbd>S</kbd> or <kbd>/</kbd> to search in the book</p>
                 <p>Press <kbd>?</kbd> to show this help</p>
                 <p>Press <kbd>Esc</kbd> to hide this help</p>
             </div>
         </div>
     </div>
     <div id="body-container">
         <!-- Work around some values being stored in localStorage wrapped in quotes -->
         <script>
             try {
                 let theme = localStorage.getItem('mdbook-theme');
                 let sidebar = localStorage.getItem('mdbook-sidebar');

                 if (theme.startsWith('"') && theme.endsWith('"')) {
                     localStorage.setItem('mdbook-theme', theme.slice(1, theme.length - 1));
                 }

                 if (sidebar.startsWith('"') && sidebar.endsWith('"')) {
                     localStorage.setItem('mdbook-sidebar', sidebar.slice(1, sidebar.length - 1));
                 }
             } catch (e) { }
         </script>

         <!-- Set the theme before any content is loaded, prevents flash -->
         <script>
             const default_theme = window.matchMedia("(prefers-color-scheme: dark)").matches ? default_dark_theme : default_light_theme;
             let theme;
             try { theme = localStorage.getItem('mdbook-theme'); } catch(e) { }
             if (theme === null || theme === undefined) { theme = default_theme; }
             const html = document.documentElement;
             html.classList.remove('light')
             html.classList.add(theme);
             html.classList.add("js");
         </script>

         <input type="checkbox" id="sidebar-toggle-anchor" class="hidden">

         <!-- Hide / unhide sidebar before it is displayed -->
         <script>
             let sidebar = null;
             const sidebar_toggle = document.getElementById("sidebar-toggle-anchor");
             if (document.body.clientWidth >= 1080) {
                 try { sidebar = localStorage.getItem('mdbook-sidebar'); } catch(e) { }
                 sidebar = sidebar || 'visible';
             } else {
                 sidebar = 'hidden';
                 sidebar_toggle.checked = false;
             }
             if (sidebar === 'visible') {
                 sidebar_toggle.checked = true;
             } else {
                 html.classList.remove('sidebar-visible');
             }
         </script>

         <nav id="sidebar" class="sidebar" aria-label="Table of contents">
             <!-- populated by js -->
             <mdbook-sidebar-scrollbox class="sidebar-scrollbox"></mdbook-sidebar-scrollbox>
             <noscript>
                 <iframe class="sidebar-iframe-outer" src="../toc.html"></iframe>
             </noscript>
             <div id="sidebar-resize-handle" class="sidebar-resize-handle">
                 <div class="sidebar-resize-indicator"></div>
             </div>
         </nav>

         <div id="page-wrapper" class="page-wrapper">

             <div class="page">
                 <div id="menu-bar-hover-placeholder"></div>
                 <div id="menu-bar" class="menu-bar sticky">
                     <div class="left-buttons">
                         <label id="sidebar-toggle" class="icon-button" for="sidebar-toggle-anchor" title="Toggle Table of Contents" aria-label="Toggle Table of Contents" aria-controls="sidebar">
                             <i class="fa fa-bars"></i>
                         </label>
                         <button id="theme-toggle" class="icon-button" type="button" title="Change theme" aria-label="Change theme" aria-haspopup="true" aria-expanded="false" aria-controls="theme-list">
                             <i class="fa fa-paint-brush"></i>
                         </button>
                         <ul id="theme-list" class="theme-popup" aria-label="Themes" role="menu">
                             <li role="none"><button role="menuitem" class="theme" id="default_theme">Auto</button></li>
                             <li role="none"><button role="menuitem" class="theme" id="light">Light</button></li>
                             <li role="none"><button role="menuitem" class="theme" id="rust">Rust</button></li>
                             <li role="none"><button role="menuitem" class="theme" id="coal">Coal</button></li>
                             <li role="none"><button role="menuitem" class="theme" id="navy">Navy</button></li>
                             <li role="none"><button role="menuitem" class="theme" id="ayu">Ayu</button></li>
                         </ul>
                         <button id="search-toggle" class="icon-button" type="button" title="Search (`/`)" aria-label="Toggle Searchbar" aria-expanded="false" aria-keyshortcuts="/ s" aria-controls="searchbar">
                             <i class="fa fa-search"></i>
                         </button>
                     </div>

                     <h1 class="menu-title">Rust Compiler Development Guide</h1>

                     <div class="right-buttons">
                         <a href="../print.html" title="Print this book" aria-label="Print this book">
                             <i id="print-button" class="fa fa-print"></i>
                         </a>
                         <a href="https://github.com/rust-lang/rustc-dev-guide" title="Git repository" aria-label="Git repository">
                             <i id="git-repository-button" class="fa fa-github"></i>
                         </a>
                         <a href="https://github.com/rust-lang/rustc-dev-guide/edit/main/src/mir/index.md" title="Suggest an edit" aria-label="Suggest an edit" rel="edit">
                             <i id="git-edit-button" class="fa fa-edit"></i>
                         </a>

                     </div>
                 </div>

                 <div id="search-wrapper" class="hidden">
                     <form id="searchbar-outer" class="searchbar-outer">
                         <div class="search-wrapper">
                             <input type="search" id="searchbar" name="searchbar" placeholder="Search this book ..." aria-controls="searchresults-outer" aria-describedby="searchresults-header">
                             <div class="spinner-wrapper">
                                 <i class="fa fa-spinner fa-spin"></i>
                             </div>
                         </div>
                     </form>
                     <div id="searchresults-outer" class="searchresults-outer hidden">
                         <div id="searchresults-header" class="searchresults-header"></div>
                         <ul id="searchresults">
                         </ul>
                     </div>
                 </div>

                 <!-- Apply ARIA attributes after the sidebar and the sidebar toggle button are added to the DOM -->
                 <script>
                     document.getElementById('sidebar-toggle').setAttribute('aria-expanded', sidebar === 'visible');
                     document.getElementById('sidebar').setAttribute('aria-hidden', sidebar !== 'visible');
                     Array.from(document.querySelectorAll('#sidebar a')).forEach(function(link) {
                         link.setAttribute('tabIndex', sidebar === 'visible' ? 0 : -1);
                     });
                 </script>

                 <div id="content" class="content">
                     <main>
                         <h1 id="the-mir-mid-level-ir"><a class="header" href="#the-mir-mid-level-ir">The MIR (Mid-level IR)</a></h1>
 <p>MIR is Rust's <em>Mid-level Intermediate Representation</em>. It is
 constructed from <a href="../hir.html">HIR</a>. MIR was introduced in
 <a href="https://rust-lang.github.io/rfcs/1211-mir.html">RFC 1211</a>. It is a radically simplified form of Rust that is used for
 certain flow-sensitive safety checks – notably the borrow checker! –
 and also for optimization and code generation.</p>
 <p>If you'd like a very high-level introduction to MIR, as well as some
 of the compiler concepts that it relies on (such as control-flow
 graphs and desugaring), you may enjoy the
 <a href="https://blog.rust-lang.org/2016/04/19/MIR.html">rust-lang blog post that introduced MIR</a>.</p>
 <h2 id="introduction-to-mir"><a class="header" href="#introduction-to-mir">Introduction to MIR</a></h2>
 <p>MIR is defined in the <a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/index.html"><code>compiler/rustc_middle/src/mir/</code></a> module, but much of the code
 that manipulates it is found in <a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_build/index.html"><code>compiler/rustc_mir_build</code></a>,
 <a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/index.html"><code>compiler/rustc_mir_transform</code></a>, and
 <a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/index.html"><code>compiler/rustc_mir_dataflow</code></a>.</p>
 <p>Some of the key characteristics of MIR are:</p>
 <ul>
 <li>It is based on a <a href="../appendix/background.html#cfg">control-flow graph</a>.</li>
 <li>It does not have nested expressions.</li>
 <li>All types in MIR are fully explicit.</li>
 </ul>
 <h2 id="key-mir-vocabulary"><a class="header" href="#key-mir-vocabulary">Key MIR vocabulary</a></h2>
 <p>This section introduces the key concepts of MIR, summarized here:</p>
 <ul>
 <li><strong>Basic blocks</strong>: units of the control-flow graph, consisting of:
 <ul>
 <li><strong>statements:</strong> actions with one successor</li>
 <li><strong>terminators:</strong> actions with potentially multiple successors; always at
 the end of a block</li>
 <li>(if you're not familiar with the term <em>basic block</em>, see the <a href="../appendix/background.html#cfg">background
 chapter</a>)</li>
 </ul>
 </li>
 <li><strong>Locals:</strong> Memory locations allocated on the stack (conceptually, at
 least), such as function arguments, local variables, and
 temporaries. These are identified by an index, written with a
 leading underscore, like <code>_1</code>. There is also a special "local"
 (<code>_0</code>) allocated to store the return value.</li>
 <li><strong>Places:</strong> expressions that identify a location in memory, like <code>_1</code> or
 <code>_1.f</code>.</li>
 <li><strong>Rvalues:</strong> expressions that produce a value. The "R" stands for
 the fact that these are the "right-hand side" of an assignment.
 <ul>
 <li><strong>Operands:</strong> the arguments to an rvalue, which can either be a
 constant (like <code>22</code>) or a place (like <code>_1</code>).</li>
 </ul>
 </li>
 </ul>
 <p>You can get a feeling for how MIR is constructed by translating simple
 programs into MIR and reading the pretty printed output. In fact, the
 playground makes this easy, since it supplies a MIR button that will
 show you the MIR for your program. Try putting this program into play
 (or <a href="https://play.rust-lang.org/?gist=30074856e62e74e91f06abd19bd72ece&amp;version=stable&amp;edition=2021">clicking on this link</a>), and then clicking the "MIR"
 button on the top:</p>
 <pre><pre class="playground"><code class="language-rust">fn main() {
     let mut vec = Vec::new();
     vec.push(1);
     vec.push(2);
 }</code></pre></pre>
 <p>You should see something like:</p>
 <pre><code class="language-mir">// WARNING: This output format is intended for human consumers only
 // and is subject to change without notice. Knock yourself out.
 fn main() -&gt; () {
     ...
 }
 </code></pre>
 <p>This is the MIR format for the <code>main</code> function.
 MIR shown by above link is optimized.
 Some statements like <code>StorageLive</code> are removed in optimization.
 This happens because the compiler notices the value is never accessed in the code.
 We can use <code>rustc [filename].rs -Z mir-opt-level=0 --emit mir</code> to view unoptimized MIR.
 This requires the nightly toolchain.</p>
 <p><strong>Variable declarations.</strong> If we drill in a bit, we'll see it begins
 with a bunch of variable declarations. They look like this:</p>
 <pre><code class="language-mir">let mut _0: ();                      // return place
 let mut _1: std::vec::Vec&lt;i32&gt;;      // in scope 0 at src/main.rs:2:9: 2:16
 let mut _2: ();
 let mut _3: &amp;mut std::vec::Vec&lt;i32&gt;;
 let mut _4: ();
 let mut _5: &amp;mut std::vec::Vec&lt;i32&gt;;
 </code></pre>
 <p>You can see that variables in MIR don't have names, they have indices,
 like <code>_0</code> or <code>_1</code>.  We also intermingle the user's variables (e.g.,
 <code>_1</code>) with temporary values (e.g., <code>_2</code> or <code>_3</code>). You can tell apart
 user-defined variables because they have debuginfo associated to them (see below).</p>
 <p><strong>User variable debuginfo.</strong> Below the variable declarations, we find the only
 hint that <code>_1</code> represents a user variable:</p>
 <pre><code class="language-mir">scope 1 {
     debug vec =&gt; _1;                 // in scope 1 at src/main.rs:2:9: 2:16
 }
 </code></pre>
 <p>Each <code>debug &lt;Name&gt; =&gt; &lt;Place&gt;;</code> annotation describes a named user variable,
 and where (i.e. the place) a debugger can find the data of that variable.
 Here the mapping is trivial, but optimizations may complicate the place,
 or lead to multiple user variables sharing the same place.
 Additionally, closure captures are described using the same system, and so
 they're complicated even without optimizations, e.g.: <code>debug x =&gt; (*((*_1).0: &amp;T));</code>.</p>
 <p>The "scope" blocks (e.g., <code>scope 1 { .. }</code>) describe the lexical structure of
 the source program (which names were in scope when), so any part of the program
 annotated with <code>// in scope 0</code> would be missing <code>vec</code>, if you were stepping
 through the code in a debugger, for example.</p>
 <p><strong>Basic blocks.</strong> Reading further, we see our first <strong>basic block</strong> (naturally
 it may look slightly different when you view it, and I am ignoring some of the
 comments):</p>
 <pre><code class="language-mir">bb0: {
     StorageLive(_1);
     _1 = const &lt;std::vec::Vec&lt;T&gt;&gt;::new() -&gt; bb2;
 }
 </code></pre>
 <p>A basic block is defined by a series of <strong>statements</strong> and a final
 <strong>terminator</strong>.  In this case, there is one statement:</p>
 <pre><code class="language-mir">StorageLive(_1);
 </code></pre>
 <p>This statement indicates that the variable <code>_1</code> is "live", meaning
 that it may be used later – this will persist until we encounter a
 <code>StorageDead(_1)</code> statement, which indicates that the variable <code>_1</code> is
 done being used. These "storage statements" are used by LLVM to
 allocate stack space.</p>
 <p>The <strong>terminator</strong> of the block <code>bb0</code> is the call to <code>Vec::new</code>:</p>
 <pre><code class="language-mir">_1 = const &lt;std::vec::Vec&lt;T&gt;&gt;::new() -&gt; bb2;
 </code></pre>
 <p>Terminators are different from statements because they can have more
 than one successor – that is, control may flow to different
 places. Function calls like the call to <code>Vec::new</code> are always
 terminators because of the possibility of unwinding, although in the
 case of <code>Vec::new</code> we are able to see that indeed unwinding is not
 possible, and hence we list only one successor block, <code>bb2</code>.</p>
 <p>If we look ahead to <code>bb2</code>, we will see it looks like this:</p>
 <pre><code class="language-mir">bb2: {
     StorageLive(_3);
     _3 = &amp;mut _1;
     _2 = const &lt;std::vec::Vec&lt;T&gt;&gt;::push(move _3, const 1i32) -&gt; [return: bb3, unwind: bb4];
 }
 </code></pre>
 <p>Here there are two statements: another <code>StorageLive</code>, introducing the <code>_3</code>
 temporary, and then an assignment:</p>
 <pre><code class="language-mir">_3 = &amp;mut _1;
 </code></pre>
 <p>Assignments in general have the form:</p>
 <pre><code class="language-text">&lt;Place&gt; = &lt;Rvalue&gt;
 </code></pre>
 <p>A place is an expression like <code>_3</code>, <code>_3.f</code> or <code>*_3</code> – it denotes a
 location in memory.  An <strong>Rvalue</strong> is an expression that creates a
 value: in this case, the rvalue is a mutable borrow expression, which
 looks like <code>&amp;mut &lt;Place&gt;</code>. So we can kind of define a grammar for
 rvalues like so:</p>
 <pre><code class="language-text">&lt;Rvalue&gt;  = &amp; (mut)? &lt;Place&gt;
           | &lt;Operand&gt; + &lt;Operand&gt;
           | &lt;Operand&gt; - &lt;Operand&gt;
           | ...

 &lt;Operand&gt; = Constant
           | copy Place
           | move Place
 </code></pre>
 <p>As you can see from this grammar, rvalues cannot be nested – they can
 only reference places and constants. Moreover, when you use a place,
 we indicate whether we are <strong>copying it</strong> (which requires that the
 place have a type <code>T</code> where <code>T: Copy</code>) or <strong>moving it</strong> (which works
 for a place of any type). So, for example, if we had the expression <code>x = a + b + c</code> in Rust, that would get compiled to two statements and a
 temporary:</p>
 <pre><code class="language-mir">TMP1 = a + b
 x = TMP1 + c
 </code></pre>
 <p>(<a href="https://play.rust-lang.org/?gist=1751196d63b2a71f8208119e59d8a5b6&amp;version=stable">Try it and see</a>, though you may want to do release mode to skip
 over the overflow checks.)</p>
 <h2 id="mir-data-types"><a class="header" href="#mir-data-types">MIR data types</a></h2>
 <p>The MIR data types are defined in the <a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/index.html"><code>compiler/rustc_middle/src/mir/</code></a>
 module. Each of the key concepts mentioned in the previous section
 maps in a fairly straightforward way to a Rust type.</p>
 <p>The main MIR data type is <a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.Body.html"><code>Body</code></a>. It contains the data for a single
 function (along with sub-instances of Mir for "promoted constants",
 but <a href="#promoted">you can read about those below</a>).</p>
 <ul>
 <li><strong>Basic blocks</strong>: The basic blocks are stored in the field
 <a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.Body.html#structfield.basic_blocks"><code>Body::basic_blocks</code></a>; this is a vector
 of <a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.BasicBlockData.html"><code>BasicBlockData</code></a> structures. Nobody ever references a
 basic block directly: instead, we pass around <a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.BasicBlock.html"><code>BasicBlock</code></a>
 values, which are <a href="../appendix/glossary.html#newtype">newtype'd</a> indices into this vector.</li>
 <li><strong>Statements</strong> are represented by the type <a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.Statement.html"><code>Statement</code></a>.</li>
 <li><strong>Terminators</strong> are represented by the <a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/terminator/struct.Terminator.html"><code>Terminator</code></a>.</li>
 <li><strong>Locals</strong> are represented by a <a href="../appendix/glossary.html#newtype">newtype'd</a> index type <a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.Local.html"><code>Local</code></a>.
 The data for a local variable is found in the
 <a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.Body.html#structfield.local_decls"><code>Body::local_decls</code></a> vector. There is also a special constant
 <a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/constant.RETURN_PLACE.html"><code>RETURN_PLACE</code></a> identifying the special "local" representing the return value.</li>
 <li><strong>Places</strong> are identified by the struct <a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.Place.html"><code>Place</code></a>. There are a few
 fields:
 <ul>
 <li>Local variables like <code>_1</code></li>
 <li><strong>Projections</strong>, which are fields or other things that "project
 out" from a base place. These are represented by the <a href="../appendix/glossary.html#newtype">newtype'd</a> type
 <a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/enum.ProjectionElem.html"><code>ProjectionElem</code></a>. So e.g. the place <code>_1.f</code> is a projection,
 with <code>f</code> being the "projection element" and <code>_1</code> being the base
 path. <code>*_1</code> is also a projection, with the <code>*</code> being represented
 by the <a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/enum.ProjectionElem.html#variant.Deref"><code>ProjectionElem::Deref</code></a> element.</li>
 </ul>
 </li>
 <li><strong>Rvalues</strong> are represented by the enum <a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/enum.Rvalue.html"><code>Rvalue</code></a>.</li>
 <li><strong>Operands</strong> are represented by the enum <a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/enum.Operand.html"><code>Operand</code></a>.</li>
 </ul>
 <h2 id="representing-constants"><a class="header" href="#representing-constants">Representing constants</a></h2>
 <p>When code has reached the MIR stage, constants can generally come in two forms:
 <em>MIR constants</em> (<a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/enum.Const.html"><code>mir::Constant</code></a>) and <em>type system constants</em> (<a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.Const.html"><code>ty::Const</code></a>).
 MIR constants are used as operands: in <code>x + CONST</code>, <code>CONST</code> is a MIR constant;
 similarly, in <code>x + 2</code>, <code>2</code> is a MIR constant. Type system constants are used in
 the type system, in particular for array lengths but also for const generics.</p>
 <p>Generally, both kinds of constants can be "unevaluated" or "already evaluated".
 An unevaluated constant simply stores the <code>DefId</code> of what needs to be evaluated
 to compute this result. An evaluated constant (a "value") has already been
 computed; their representation differs between type system constants and MIR
 constants: MIR constants evaluate to a <code>mir::ConstValue</code>; type system constants
 evaluate to a <code>ty::ValTree</code>.</p>
 <p>Type system constants have some more variants to support const generics: they
 can refer to local const generic parameters, and they are subject to inference.
 Furthermore, the <code>mir::Constant::Ty</code> variant lets us use an arbitrary type
 system constant as a MIR constant; this happens whenever a const generic
 parameter is used as an operand.</p>
 <h3 id="mir-constant-values"><a class="header" href="#mir-constant-values">MIR constant values</a></h3>
 <p>In general, a MIR constant value (<code>mir::ConstValue</code>) was computed by evaluating
 some constant the user wrote. This <a href="../const-eval.html">const evaluation</a> produces
 a very low-level representation of the result in terms of individual bytes. We
 call this an "indirect" constant (<code>mir::ConstValue::Indirect</code>) since the value
 is stored in-memory.</p>
 <p>However, storing everything in-memory would be awfully inefficient. Hence there
 are some other variants in <code>mir::ConstValue</code> that can represent certain simple
 and common values more efficiently. In particular, everything that can be
 directly written as a literal in Rust (integers, floats, chars, bools, but also
 <code>"string literals"</code> and <code>b"byte string literals"</code>) has an optimized variant that
 avoids the full overhead of the in-memory representation.</p>
 <h3 id="valtrees"><a class="header" href="#valtrees">ValTrees</a></h3>
 <p>An evaluated type system constant is a "valtree". The <code>ty::ValTree</code> datastructure
 allows us to represent</p>
 <ul>
 <li>arrays,</li>
 <li>many structs,</li>
 <li>tuples,</li>
 <li>enums and,</li>
 <li>most primitives.</li>
 </ul>
 <p>The most important rule for
 this representation is that every value must be uniquely represented. In other
 words: a specific value must only be representable in one specific way. For example: there is only
 one way to represent an array of two integers as a <code>ValTree</code>:
 <code>Branch([Leaf(first_int), Leaf(second_int)])</code>.
 Even though theoretically a <code>[u32; 2]</code> could be encoded in a <code>u64</code> and thus just be a
 <code>Leaf(bits_of_two_u32)</code>, that is not a legal construction of <code>ValTree</code>
 (and is very complex to do, so it is unlikely anyone is tempted to do so).</p>
 <p>These rules also mean that some values are not representable. There can be no <code>union</code>s in type
 level constants, as it is not clear how they should be represented, because their active variant
 is unknown. Similarly there is no way to represent raw pointers, as addresses are unknown at
 compile-time and thus we cannot make any assumptions about them. References on the other hand
 <em>can</em> be represented, as equality for references is defined as equality on their value, so we
 ignore their address and just look at the backing value. We must make sure that the pointer values
 of the references are not observable at compile time. We thus encode <code>&amp;42</code> exactly like <code>42</code>.
 Any conversion from
 valtree back to a MIR constant value must reintroduce an actual indirection. At codegen time the
 addresses may be deduplicated between multiple uses or not, entirely depending on arbitrary
 optimization choices.</p>
 <p>As a consequence, all decoding of <code>ValTree</code> must happen by matching on the type first and making
 decisions depending on that. The value itself gives no useful information without the type that
 belongs to it.</p>
 <p><a id="promoted"></a></p>
 <h3 id="promoted-constants"><a class="header" href="#promoted-constants">Promoted constants</a></h3>
 <p>See the const-eval WG's <a href="https://github.com/rust-lang/const-eval/blob/master/promotion.md">docs on promotion</a>.</p>

                     </main>

                     <nav class="nav-wrapper" aria-label="Page navigation">
                         <!-- Mobile navigation buttons -->
                             <a rel="prev" href="../thir.html" class="mobile-nav-chapters previous" title="Previous chapter" aria-label="Previous chapter" aria-keyshortcuts="Left">
                                 <i class="fa fa-angle-left"></i>
                             </a>

                             <a rel="next prefetch" href="../mir/construction.html" class="mobile-nav-chapters next" title="Next chapter" aria-label="Next chapter" aria-keyshortcuts="Right">
                                 <i class="fa fa-angle-right"></i>
                             </a>

                         <div style="clear: both"></div>
                     </nav>
                 </div>
             </div>

             <nav class="nav-wide-wrapper" aria-label="Page navigation">
                     <a rel="prev" href="../thir.html" class="nav-chapters previous" title="Previous chapter" aria-label="Previous chapter" aria-keyshortcuts="Left">
                         <i class="fa fa-angle-left"></i>
                     </a>

                     <a rel="next prefetch" href="../mir/construction.html" class="nav-chapters next" title="Next chapter" aria-label="Next chapter" aria-keyshortcuts="Right">
                         <i class="fa fa-angle-right"></i>
                     </a>
             </nav>

         </div>


         <script>
             window.playground_copyable = true;
         </script>


         <script src="../elasticlunr.min.js"></script>
         <script src="../mark.min.js"></script>
         <script src="../searcher.js"></script>

         <script src="../clipboard.min.js"></script>
         <script src="../highlight.js"></script>
         <script src="../book.js"></script>

         <!-- Custom JS scripts -->
         <script src="../mermaid.min.js"></script>
         <script src="../mermaid-init.js"></script>
         <script src="../pagetoc.js"></script>


     </div>
     </body>
 </html>