src/tools/miri/tex/final-presentation/slides.tex - toolchain/rustc - Git at Google

 \documentclass{beamer}
 \usecolortheme{beaver}
 \beamertemplatenavigationsymbolsempty

 % Fonts
 \usepackage{fontspec}
 \setmainfont{Source Serif Pro}[Ligatures=TeX]
 \setsansfont{Source Sans Pro}[Ligatures=TeX]
 \setmonofont{Source Code Pro}[
   BoldFont={* Medium},
   BoldItalicFont={* Medium Italic},
 ]

 \usepackage[outputdir=out]{minted}
 \usepackage{tikz}
 \usetikzlibrary{positioning, fit}

 \tikzset{
   invisible/.style={opacity=0,text opacity=0},
   highlight/.style={color=red},
   intro/.code args={<#1>}{%
     \only<#1>{\pgfkeysalso{highlight}}
     \alt<#1->{}{\pgfkeysalso{invisible}}
   },
 }

 \title{Miri}
 \subtitle{An interpreter for Rust's mid-level intermediate representation}
 \author{
   Scott Olson
   \texorpdfstring{\\ \scriptsize{Supervisor: Christopher Dutchyn}}{}
 }
 \institute{
   CMPT 400 \\
   University of Saskatchewan
 }
 \date{}
 \titlegraphic{
   \includegraphics[width=64px,height=64px]{rust-logo-512x512.png} \\
   \scriptsize{\url{https://www.rust-lang.org}}
 }

 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 % Intro slides
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

 \begin{document}

 \maketitle

 \begin{frame}[fragile]
   \frametitle{What is Rust? \small{[review]}}

   According to the website\dots

   \begin{quote}
     \textbf{Rust} is a systems programming language that runs blazingly fast,
     prevents nearly all segfaults, and guarantees thread safety.
   \end{quote}

   It's a new programming language from Mozilla, and it looks like this:

   \begin{minted}[
     autogobble,
     fontsize=\footnotesize,
     mathescape,
     xleftmargin=.3in,
   ]{rust}
     fn factorial(n: u64) -> u64 {
         (1..n).fold(1, |a, b| a * b)
     }

     fn main() {
         for x in 1..6 {
             println!("{}", factorial(x));
         }
         // $\Rightarrow$ 1
         // $\Rightarrow$ 1
         // $\Rightarrow$ 2
         // $\Rightarrow$ 6
         // $\Rightarrow$ 24
     }
   \end{minted}
 \end{frame}

 \begin{frame}
   \frametitle{How does Rust compile code? \onslide<-6>{\small{[review]}}}

   \begin{center}
     \begin{tikzpicture}[x=4cm, y=3.5cm, auto, rounded corners]
       \tikzstyle{basic-stage}=[rectangle, draw, thick, align=center]
       \tikzstyle{stage}=[basic-stage, font=\tiny]
       \tikzstyle{pass}=[thick, -stealth]
       \tikzstyle{pass-label}=[font=\footnotesize]

       \node[basic-stage] (src) at (0,0) {Source\\Code};
       \node[basic-stage] (mach) at (2,-1) {Machine\\Code};

       \draw<1>[pass, out=0, in=180]
         (src.east) to node[font=\Huge] {?} (mach.west);

       \node[stage, intro=<2>] (ast) at (1,0)
         {\normalsize{AST} \\ Abstract Syntax Tree};
       \draw[pass, intro=<2>]
         (src) -- node[pass-label] {Parse} (ast);

       \node[stage, intro=<3>] (hir) at (2,0)
         {\normalsize{HIR} \\ High-level Intermediate\\Representation};
       \draw[pass, intro=<3>]
         (ast) -- node[pass-label] {Simplify} (hir);

       \node[stage, intro=<4>] (mir) at (0,-1)
         {\normalsize{MIR} \\ Mid-level Intermediate\\Representation};
       \path (hir.south) -- coordinate (middle) (mir.north);
       \draw[pass, intro=<4>]
         (hir.south) |- (middle) -| (mir.north);
       \node[pass-label, above, intro=<4>] at (middle) {Lower};

       \node[stage, intro=<5>] (llvm) at (1,-1)
         {\normalsize{LLVM IR} \\ Low-level Intermediate\\Representation};
       \draw[pass, intro=<5>]
         (mir) -- node[pass-label] {Translate} (llvm);

       \draw<6->[pass, intro=<6>]
         (llvm) -- node[pass-label] {Magic} (mach);

       \node[stage, intro=<7>] (exec) at (1,-1.75)
         {\normalsize{Execution}};
       \draw[pass, intro=<7>]
         (mach) -- node[pass-label] {CPU} (exec);

       \draw[pass, intro=<8>]
         (mir) -- node[pass-label] {Miri} (exec);
     \end{tikzpicture}
   \end{center}
 \end{frame}

 \begin{frame}
   \frametitle{Why build Miri?}
   \begin{itemize}
     \item For fun and learning.

     \item I originally planned to use it for testing the compiler and execution
       of unsafe code, but shifted my goals along the way. \pause

     \item Now it serves as an experimental implementation of the upcoming
       compile-time function evaluation feature in Rust. \pause

       \begin{itemize}
         \item Similar to C++14's \mintinline{cpp}{constexpr} feature.

         \item You can do complicated calculations at compile time and compile
           their \emph{results} into the executable. \pause

         \item For example, you can compute a ``perfect hash function'' for a
           statically-known map at compile-time and have guaranteed no-collision
           lookup at runtime. \pause

         \item Miri actually supports far more of Rust than C++14's
           \mintinline{cpp}{constexpr} does of C++ --- even heap allocation and
           unsafe code.
       \end{itemize}
   \end{itemize}
 \end{frame}

 \begin{frame}
   \frametitle{How was it built?}

   At first I wrote a naive version with a number of downsides:

   \begin{itemize}
     \item represented values in a traditional dynamic language format, where
       every value was the same size.

     \item didn't work well for aggregates (structs, enums, arrays, etc.).

     \item made unsafe programming tricks that make assumptions about low-level
       value layout essentially impossible.
   \end{itemize}
 \end{frame}

 \begin{frame}
   \frametitle{How was it built?}
   \begin{itemize}
     \item Later, a Rust compiler team member proposed a ``Rust abstract
       machine'' with specialized value layout which solved my previous problems.
       \pause

     \item His proposal was intended for a compile-time function evaluator in the
       Rust compiler, so I effectively implemented an experimental version of
       that. \pause

     \item After this point, making Miri work well was primarily a software
       engineering problem.
   \end{itemize}
 \end{frame}

 \begin{frame}
   \frametitle{Data layout}
   \begin{itemize}
     \item Memory in Miri is literally a HashMap from ``allocation IDs'' to
       ``abstract allocations''.

     \item Allocations are represented by: \pause
       \begin{enumerate}
         \item An array of \textbf{raw bytes} with a size based on the type of
           the value \pause
         \item A set of \textbf{relocations} --- pointers into other abstract
           allocations \pause
         \item A mask determining which bytes are \textbf{undefined}
       \end{enumerate}
   \end{itemize}
 \end{frame}

 \begin{frame}[fragile]
   \frametitle{\texttt{square} example}
   \begin{center}
     \begin{minted}[autogobble,fontsize=\scriptsize]{rust}
       // Rust
       fn square(n: u64) -> u64 {
           n * n
       }

       // Generated MIR
       fn square(arg0: u64) -> u64 {
           let var0: u64; // n           // On function entry, Miri creates
                                         // virtual allocations for all the
                                         // arguments, variables, and
                                         // temporaries.

           bb0: {
               var0 = arg0;              // Copy the argument into `n`.
               return = Mul(var0, var0); // Multiply `n` with itself.
               goto -> bb1;              // Jump to basic block `bb1`.
           }

           bb1: {
               return;                   // Return from the current fn.
           }
       }
     \end{minted}
   \end{center}
 \end{frame}

 \begin{frame}[fragile]
   \frametitle{\texttt{sum} example}
   \begin{center}
     \begin{minted}[autogobble,fontsize=\tiny]{rust}
       // Rust
       fn sum() -> u64 {
           let mut sum = 0; let mut i = 0;
           while i < 10 { sum += i; i += 1; }
           sum
       }

       // Generated MIR
       fn sum() -> u64 {
           let mut var0: u64; // sum
           let mut var1: u64; // i
           let mut tmp0: bool;

           bb0: {
               // sum = 0; i = 0;
               var0 = const 0u64; var1 = const 0u64; goto -> bb1;
           }
           bb1: {
               // if i < 10 { goto bb2; } else { goto bb3; }
               tmp0 = Lt(var1, const 10u64);
               if(tmp0) -> [true: bb2, false: bb3];
           }
           bb2: {
               var0 = Add(var0, var1);       // sum = sum + i;
               var1 = Add(var1, const 1u64); // i = i + 1;
               goto -> bb1;
           }
           bb3: {
               return = var0; goto -> bb4;
           }
           bb4: { return; }
       }
     \end{minted}
   \end{center}
 \end{frame}

 \begin{frame}[fragile]
   \frametitle{Heap allocations!}
   \begin{minted}[autogobble,fontsize=\scriptsize]{rust}
     fn make_vec() -> Vec<u8> {
         // Empty array with space for 4 bytes - allocated on the heap!
         let mut vec = Vec::with_capacity(4);
         // Initialize the first two slots.
         vec.push(1);
         vec.push(2);
         vec
     }

     // For reference:
     //   struct Vec<T> { capacity: usize, data: *mut T, length: usize }

     // Resulting allocations (on 32-bit little-endian architectures):
     //   Region A:
     //     04 00 00 00  00 00 00 00  02 00 00 00
     //                  └───(B)───┘
     //
     //   Region B:
     //     01 02 __ __ (underscores denote undefined bytes)
   \end{minted}

   \footnotesize{Evaluating the above involves a number of compiler built-ins,
   ``unsafe'' code blocks, and more inside the standard library,
   but Miri handles it all.}
 \end{frame}

 \begin{frame}[fragile]
   \frametitle{Unsafe code!}
   \begin{minted}[autogobble,fontsize=\scriptsize]{rust}
     fn out_of_bounds() -> u8 {
         let mut vec = vec![1, 2]
         unsafe { *vec.get_unchecked(5) }
     }

     // test.rs:3: error: pointer offset outside bounds of allocation
     // test.rs:3:     unsafe { *vec.get_unchecked(5) }
     //                         ^~~~~~~~~~~~~~~~~~~~~

     fn undefined_bytes() -> u8 {
         let mut vec = Vec::with_capacity(10);
         unsafe { *vec.get_unchecked(5) }
     }

     // test.rs:3: error: attempted to read undefined bytes
     // test.rs:3:     unsafe { *vec.get_unchecked(5) }
     //                         ^~~~~~~~~~~~~~~~~~~~~
   \end{minted}
 \end{frame}

 \begin{frame}
   \frametitle{What can't Miri do?}
   \begin{itemize}
     \item Miri can't do all the stuff I didn't implement yet. :)
       \begin{itemize}
         \item non-trivial casts
         \item function pointers
         \item calling destructors and freeing memory
         \item taking target architecture endianess and alignment information
           into account when computing data layout
         \item handling all constants properly (but, well, Miri might be
           replacing the old constants system)
       \end{itemize}
       \pause

     \item Miri can't do foreign function calls (e.g. calling functions defined
       in C or C++), but there is a reasonable way it could be done with libffi.
       \begin{itemize}
         \item On the other hand, for constant evaluation in the compiler, you
           want the evaluator to be deterministic and safe, so FFI calls might be
           banned anyway.
       \end{itemize}
       \pause

     \item Without quite some effort, Miri will probably never handle inline
       assembly...
   \end{itemize}
 \end{frame}

 \begin{frame}
   \begin{center}
     \LARGE{Questions?}
   \end{center}
 \end{frame}

 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 % Extra slides
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

 \begin{frame}[fragile]
   \frametitle{\texttt{varN} vs. \texttt{argN}}
   \begin{center}
     \begin{minted}[autogobble,fontsize=\scriptsize]{rust}
       // Rust
       type Pair = (u64, u64);
       fn swap((a, b): Pair) -> Pair {
           (b, a)
       }

       // Generated MIR
       fn swap(arg0: (u64, u64)) -> (u64, u64) {
           let var0: u64; // a
           let var1: u64; // b

           bb0: {
               var0 = arg0.0;         // get the 1st part of the pair
               var1 = arg0.1;         // get the 2nd part of the pair
               return = (var1, var0); // build a new pair in the result
               goto -> bb1;
           }

           bb1: {
               return;
           }
       }
     \end{minted}
   \end{center}
 \end{frame}

 \begin{frame}[fragile]
   \frametitle{\texttt{factorial} example}
   \begin{center}
     \begin{minted}[autogobble,fontsize=\tiny]{rust}
       // Rust
       fn factorial(n: u64) -> u64 {
           (1..n).fold(1, |a, b| a * b)
       }

       // Generated MIR
       fn factorial(arg0: u64) -> u64 {
           let var0: u64; // n
           let mut tmp0: Range<u64>; // Miri calculates sizes for generics like Range<u64>.
           let mut tmp1: [closure];

           bb0: {
               var0 = arg0;

               // tmp0 = 1..n
               tmp0 = Range<u64> { start: const 1u64, end: var0 };

               // tmp1 = |a, b| a * b
               tmp1 = [closure];

               // This loads the MIR for the `fold` fn from the standard library.
               // In general, MIR for any function from any library can be loaded.
               // return tmp0.fold(1, tmp1)
               return = Range<u64>::fold(tmp0, const 1u64, tmp1) -> bb1;
           }

           bb1: {
               return;
           }
       }
     \end{minted}
   \end{center}
 \end{frame}

 \end{document}
	\documentclass{beamer}
	\usecolortheme{beaver}
	\beamertemplatenavigationsymbolsempty

	% Fonts
	\usepackage{fontspec}
	\setmainfont{Source Serif Pro}[Ligatures=TeX]
	\setsansfont{Source Sans Pro}[Ligatures=TeX]
	\setmonofont{Source Code Pro}[
	BoldFont={* Medium},
	BoldItalicFont={* Medium Italic},
	]

	\usepackage[outputdir=out]{minted}
	\usepackage{tikz}
	\usetikzlibrary{positioning, fit}

	\tikzset{
	invisible/.style={opacity=0,text opacity=0},
	highlight/.style={color=red},
	intro/.code args={<#1>}{%
	\only<#1>{\pgfkeysalso{highlight}}
	\alt<#1->{}{\pgfkeysalso{invisible}}
	},
	}

	\title{Miri}
	\subtitle{An interpreter for Rust's mid-level intermediate representation}
	\author{
	Scott Olson
	\texorpdfstring{\\ \scriptsize{Supervisor: Christopher Dutchyn}}{}
	}
	\institute{
	CMPT 400 \\
	University of Saskatchewan
	}
	\date{}
	\titlegraphic{
	\includegraphics[width=64px,height=64px]{rust-logo-512x512.png} \\
	\scriptsize{\url{https://www.rust-lang.org}}
	}

	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
	% Intro slides
	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

	\begin{document}

	\maketitle

	\begin{frame}[fragile]
	\frametitle{What is Rust? \small{[review]}}

	According to the website\dots

	\begin{quote}
	\textbf{Rust} is a systems programming language that runs blazingly fast,
	prevents nearly all segfaults, and guarantees thread safety.
	\end{quote}

	It's a new programming language from Mozilla, and it looks like this:

	\begin{minted}[
	autogobble,
	fontsize=\footnotesize,
	mathescape,
	xleftmargin=.3in,
	]{rust}
	fn factorial(n: u64) -> u64 {
	(1..n).fold(1, \|a, b\| a * b)
	}

	fn main() {
	for x in 1..6 {
	println!("{}", factorial(x));
	}
	// $\Rightarrow$ 1
	// $\Rightarrow$ 1
	// $\Rightarrow$ 2
	// $\Rightarrow$ 6
	// $\Rightarrow$ 24
	}
	\end{minted}
	\end{frame}

	\begin{frame}
	\frametitle{How does Rust compile code? \onslide<-6>{\small{[review]}}}

	\begin{center}
	\begin{tikzpicture}[x=4cm, y=3.5cm, auto, rounded corners]
	\tikzstyle{basic-stage}=[rectangle, draw, thick, align=center]
	\tikzstyle{stage}=[basic-stage, font=\tiny]
	\tikzstyle{pass}=[thick, -stealth]
	\tikzstyle{pass-label}=[font=\footnotesize]

	\node[basic-stage] (src) at (0,0) {Source\\Code};
	\node[basic-stage] (mach) at (2,-1) {Machine\\Code};

	\draw<1>[pass, out=0, in=180]
	(src.east) to node[font=\Huge] {?} (mach.west);

	\node[stage, intro=<2>] (ast) at (1,0)
	{\normalsize{AST} \\ Abstract Syntax Tree};
	\draw[pass, intro=<2>]
	(src) -- node[pass-label] {Parse} (ast);

	\node[stage, intro=<3>] (hir) at (2,0)
	{\normalsize{HIR} \\ High-level Intermediate\\Representation};
	\draw[pass, intro=<3>]
	(ast) -- node[pass-label] {Simplify} (hir);

	\node[stage, intro=<4>] (mir) at (0,-1)
	{\normalsize{MIR} \\ Mid-level Intermediate\\Representation};
	\path (hir.south) -- coordinate (middle) (mir.north);
	\draw[pass, intro=<4>]
	(hir.south) \|- (middle) -\| (mir.north);
	\node[pass-label, above, intro=<4>] at (middle) {Lower};

	\node[stage, intro=<5>] (llvm) at (1,-1)
	{\normalsize{LLVM IR} \\ Low-level Intermediate\\Representation};
	\draw[pass, intro=<5>]
	(mir) -- node[pass-label] {Translate} (llvm);

	\draw<6->[pass, intro=<6>]
	(llvm) -- node[pass-label] {Magic} (mach);

	\node[stage, intro=<7>] (exec) at (1,-1.75)
	{\normalsize{Execution}};
	\draw[pass, intro=<7>]
	(mach) -- node[pass-label] {CPU} (exec);

	\draw[pass, intro=<8>]
	(mir) -- node[pass-label] {Miri} (exec);
	\end{tikzpicture}
	\end{center}
	\end{frame}

	\begin{frame}
	\frametitle{Why build Miri?}
	\begin{itemize}
	\item For fun and learning.

	\item I originally planned to use it for testing the compiler and execution
	of unsafe code, but shifted my goals along the way. \pause

	\item Now it serves as an experimental implementation of the upcoming
	compile-time function evaluation feature in Rust. \pause

	\begin{itemize}
	\item Similar to C++14's \mintinline{cpp}{constexpr} feature.

	\item You can do complicated calculations at compile time and compile
	their \emph{results} into the executable. \pause

	\item For example, you can compute a ``perfect hash function'' for a
	statically-known map at compile-time and have guaranteed no-collision
	lookup at runtime. \pause

	\item Miri actually supports far more of Rust than C++14's
	\mintinline{cpp}{constexpr} does of C++ --- even heap allocation and
	unsafe code.
	\end{itemize}
	\end{itemize}
	\end{frame}

	\begin{frame}
	\frametitle{How was it built?}

	At first I wrote a naive version with a number of downsides:

	\begin{itemize}
	\item represented values in a traditional dynamic language format, where
	every value was the same size.

	\item didn't work well for aggregates (structs, enums, arrays, etc.).

	\item made unsafe programming tricks that make assumptions about low-level
	value layout essentially impossible.
	\end{itemize}
	\end{frame}

	\begin{frame}
	\frametitle{How was it built?}
	\begin{itemize}
	\item Later, a Rust compiler team member proposed a ``Rust abstract
	machine'' with specialized value layout which solved my previous problems.
	\pause

	\item His proposal was intended for a compile-time function evaluator in the
	Rust compiler, so I effectively implemented an experimental version of
	that. \pause

	\item After this point, making Miri work well was primarily a software
	engineering problem.
	\end{itemize}
	\end{frame}

	\begin{frame}
	\frametitle{Data layout}
	\begin{itemize}
	\item Memory in Miri is literally a HashMap from ``allocation IDs'' to
	``abstract allocations''.

	\item Allocations are represented by: \pause
	\begin{enumerate}
	\item An array of \textbf{raw bytes} with a size based on the type of
	the value \pause
	\item A set of \textbf{relocations} --- pointers into other abstract
	allocations \pause
	\item A mask determining which bytes are \textbf{undefined}
	\end{enumerate}
	\end{itemize}
	\end{frame}

	\begin{frame}[fragile]
	\frametitle{\texttt{square} example}
	\begin{center}
	\begin{minted}[autogobble,fontsize=\scriptsize]{rust}
	// Rust
	fn square(n: u64) -> u64 {
	n * n
	}

	// Generated MIR
	fn square(arg0: u64) -> u64 {
	let var0: u64; // n // On function entry, Miri creates
	// virtual allocations for all the
	// arguments, variables, and
	// temporaries.

	bb0: {
	var0 = arg0; // Copy the argument into `n`.
	return = Mul(var0, var0); // Multiply `n` with itself.
	goto -> bb1; // Jump to basic block `bb1`.
	}

	bb1: {
	return; // Return from the current fn.
	}
	}
	\end{minted}
	\end{center}
	\end{frame}

	\begin{frame}[fragile]
	\frametitle{\texttt{sum} example}
	\begin{center}
	\begin{minted}[autogobble,fontsize=\tiny]{rust}
	// Rust
	fn sum() -> u64 {
	let mut sum = 0; let mut i = 0;
	while i < 10 { sum += i; i += 1; }
	sum
	}

	// Generated MIR
	fn sum() -> u64 {
	let mut var0: u64; // sum
	let mut var1: u64; // i
	let mut tmp0: bool;

	bb0: {
	// sum = 0; i = 0;
	var0 = const 0u64; var1 = const 0u64; goto -> bb1;
	}
	bb1: {
	// if i < 10 { goto bb2; } else { goto bb3; }
	tmp0 = Lt(var1, const 10u64);
	if(tmp0) -> [true: bb2, false: bb3];
	}
	bb2: {
	var0 = Add(var0, var1); // sum = sum + i;
	var1 = Add(var1, const 1u64); // i = i + 1;
	goto -> bb1;
	}
	bb3: {
	return = var0; goto -> bb4;
	}
	bb4: { return; }
	}
	\end{minted}
	\end{center}
	\end{frame}

	\begin{frame}[fragile]
	\frametitle{Heap allocations!}
	\begin{minted}[autogobble,fontsize=\scriptsize]{rust}
	fn make_vec() -> Vec<u8> {
	// Empty array with space for 4 bytes - allocated on the heap!
	let mut vec = Vec::with_capacity(4);
	// Initialize the first two slots.
	vec.push(1);
	vec.push(2);
	vec
	}

	// For reference:
	// struct Vec<T> { capacity: usize, data: *mut T, length: usize }

	// Resulting allocations (on 32-bit little-endian architectures):
	// Region A:
	// 04 00 00 00 00 00 00 00 02 00 00 00
	// └───(B)───┘
	//
	// Region B:
	// 01 02 __ __ (underscores denote undefined bytes)
	\end{minted}

	\footnotesize{Evaluating the above involves a number of compiler built-ins,
	``unsafe'' code blocks, and more inside the standard library,
	but Miri handles it all.}
	\end{frame}

	\begin{frame}[fragile]
	\frametitle{Unsafe code!}
	\begin{minted}[autogobble,fontsize=\scriptsize]{rust}
	fn out_of_bounds() -> u8 {
	let mut vec = vec![1, 2]
	unsafe { *vec.get_unchecked(5) }
	}

	// test.rs:3: error: pointer offset outside bounds of allocation
	// test.rs:3: unsafe { *vec.get_unchecked(5) }
	// ^~~~~~~~~~~~~~~~~~~~~

	fn undefined_bytes() -> u8 {
	let mut vec = Vec::with_capacity(10);
	unsafe { *vec.get_unchecked(5) }
	}

	// test.rs:3: error: attempted to read undefined bytes
	// test.rs:3: unsafe { *vec.get_unchecked(5) }
	// ^~~~~~~~~~~~~~~~~~~~~
	\end{minted}
	\end{frame}

	\begin{frame}
	\frametitle{What can't Miri do?}
	\begin{itemize}
	\item Miri can't do all the stuff I didn't implement yet. :)
	\begin{itemize}
	\item non-trivial casts
	\item function pointers
	\item calling destructors and freeing memory
	\item taking target architecture endianess and alignment information
	into account when computing data layout
	\item handling all constants properly (but, well, Miri might be
	replacing the old constants system)
	\end{itemize}
	\pause

	\item Miri can't do foreign function calls (e.g. calling functions defined
	in C or C++), but there is a reasonable way it could be done with libffi.
	\begin{itemize}
	\item On the other hand, for constant evaluation in the compiler, you
	want the evaluator to be deterministic and safe, so FFI calls might be
	banned anyway.
	\end{itemize}
	\pause

	\item Without quite some effort, Miri will probably never handle inline
	assembly...
	\end{itemize}
	\end{frame}

	\begin{frame}
	\begin{center}
	\LARGE{Questions?}
	\end{center}
	\end{frame}

	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
	% Extra slides
	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

	\begin{frame}[fragile]
	\frametitle{\texttt{varN} vs. \texttt{argN}}
	\begin{center}
	\begin{minted}[autogobble,fontsize=\scriptsize]{rust}
	// Rust
	type Pair = (u64, u64);
	fn swap((a, b): Pair) -> Pair {
	(b, a)
	}

	// Generated MIR
	fn swap(arg0: (u64, u64)) -> (u64, u64) {
	let var0: u64; // a
	let var1: u64; // b

	bb0: {
	var0 = arg0.0; // get the 1st part of the pair
	var1 = arg0.1; // get the 2nd part of the pair
	return = (var1, var0); // build a new pair in the result
	goto -> bb1;
	}

	bb1: {
	return;
	}
	}
	\end{minted}
	\end{center}
	\end{frame}

	\begin{frame}[fragile]
	\frametitle{\texttt{factorial} example}
	\begin{center}
	\begin{minted}[autogobble,fontsize=\tiny]{rust}
	// Rust
	fn factorial(n: u64) -> u64 {
	(1..n).fold(1, \|a, b\| a * b)
	}

	// Generated MIR
	fn factorial(arg0: u64) -> u64 {
	let var0: u64; // n
	let mut tmp0: Range<u64>; // Miri calculates sizes for generics like Range<u64>.
	let mut tmp1: [closure];

	bb0: {
	var0 = arg0;

	// tmp0 = 1..n
	tmp0 = Range<u64> { start: const 1u64, end: var0 };

	// tmp1 = \|a, b\| a * b
	tmp1 = [closure];

	// This loads the MIR for the `fold` fn from the standard library.
	// In general, MIR for any function from any library can be loaded.
	// return tmp0.fold(1, tmp1)
	return = Range<u64>::fold(tmp0, const 1u64, tmp1) -> bb1;
	}

	bb1: {
	return;
	}
	}
	\end{minted}
	\end{center}
	\end{frame}

	\end{document}