personal/_posts/2020-07-15-unused-data.md

   1 ---
   2 title: "Why even unused data needs to be valid"
   3 categories: rust
   4 ---
   5
   6 The Rust compiler has a few assumptions that it makes about the behavior of all code.
   7 Violations of those assumptions are referred to as [Undefined Behavior][ub].
   8 Since Rust is a safe-by-default language, programmers usually do not have to worry about those rules (the compiler and libraries ensure that safe code always satisfies the assumptions),
   9 but authors of `unsafe` code are themselves responsible for upholding these requirements.
  10
  11 Those assumptions are [listed in the Rust reference](https://doc.rust-lang.org/reference/behavior-considered-undefined.html).
  12 The one that seems to be most surprising to many people is the clause which says that unsafe code may not *produce* "[...] an invalid value, even in private fields and locals".
  13 The reference goes on to explain that "*producing* a value happens any time a value is assigned to or read from a place, passed to a function/primitive operation or returned from a function/primitive operation".
  14 In other words, even just *constructing*, for example, an invalid `bool`, is Undefined Behavior---no matter whether that `bool` is ever actually "used" by the program.
  15 The purpose of this post is to explain why that rule is so strict.
  16
  17 [ub]: https://rust-lang.github.io/unsafe-code-guidelines/glossary.html#undefined-behavior
  18
  19 <!-- MORE -->
  20
  21 First of all, let me clarify what is meant by "used" here, as that term is used to mean very different things.
  22 The following code "uses" `b`:
  23
  24 {% highlight rust %}
  25 fn example(b: bool) -> i32 {
  26   if b { 42 } else { 23 }
  27 }
  28 {% endhighlight %}
  29
  30 I hope it is not very surprising that calling `example` on, e.g., `3` transmuted to `bool` is Undefined Behavior (UB).
  31 When compiling `if`, the compiler assumes that `0` and `1` are the only possible values; there is no saying what could go wrong when that assumption is violated.
  32
  33 What is less obvious is why calling `example` on `3` is UB even when there is no such `if` being executed.
  34 To understand why that is important, let us consider the following example:
  35
  36 {% highlight rust %}
  37 fn example(b: bool, num: u32) -> i32 {
  38   let mut acc = 0;
  39   for _i in 0..num {
  40     acc += if b { 42 } else { 23 };
  41   }
  42   acc
  43 }
  44 {% endhighlight %}
  45
  46 Now assume we were working in a slightly different version of Rust, where transmuting `3` to a `bool` is fine as long as you do not "use" the `bool`.
  47 That would mean that calling `example(transmute(3u8), 0)` is actually allowed, because in that case the loop never gets executed, so we never "use" `b`.
  48
  49 However, this is a problem for a very important transformation called [loop-invariant code motion](https://en.wikipedia.org/wiki/Loop-invariant_code_motion).
  50 That transformation can be used to turn our `example` function into the following:
  51
  52 {% highlight rust %}
  53 fn example(b: bool, num: u32) -> i32 {
  54   let mut acc = 0;
  55   let incr = if b { 42 } else { 23 }
  56   for _i in 0..num {
  57     acc += incr;
  58   }
  59   acc
  60 }
  61 {% endhighlight %}
  62
  63 The increment `if b { 42 } else { 23 }`, now called `incr`, is "invariant" during the execution of the loop, and thus computing the increment can be moved out.
  64 Why is this a good transformation?
  65 Instead of determining the increment each time around the loop, we do that just once, thus saving a lot of conditional jumps that the CPU is unhappy about.
  66 This also enables further transformations down the road, e.g. the compiler could notice that this is just `num*incr`.
  67
  68 However, in our hypothetical Rust where "unused" values may be invalid, this important optimization is actually incorrect!
  69 To see why, consider again calling `example(transmute(3u8), 0)`.
  70 Before the optimization, that call was fine.
  71 After the optimization, that call is UB because we are doing `if b` where `b` is `3`.
  72
  73 This is because loop-invariant code motion makes dead code live when the loop is not actually executed.
  74 To fix this, we could require the compiler to prove that the loop runs at least once, but in general that will be hard (and in `example` it is impossible, since `num` can indeed be `0`).
  75 So the alternative that Rust uses is to require that even "unused" data satisfies some basic validity.
  76 That makes `example(transmute(3u8), 0)` UB in *both* versions of `example`, and as such the optimization is correct for this input (and indeed for all possible inputs).
  77
  78 Now, one might argue that `b` in the example here was not truly "unused", it was just "used in dead code".
  79 So instead of saying that `b` must be *always* valid, we could somehow try to make the use of `b` in dead code affect whether or not the program is UB.
  80 However, that is a huge can of worms.
  81 Right now, we have the fundamental principle that *dead code cannot affect program behavior*.
  82 This principle is crucial for tools like [Miri](https://github.com/rust-lang/miri/): since Miri is an interpreter, it never even sees dead code.
  83 I would argue that being able to have tools like Miri is hugely important, and it is worth having a semantics that enables such tools to exist.
  84 But this means our hands are pretty much tied: since we cannot take into account of `b` is "used in dead code", we simply have to require `b` to always be valid, no matter whether and where it is "used" or not.
  85 To support inlining and outlining, we also do not want the function boundary to be relevant, which ultimately leads us to the rule that Rust requires today: whenever data of a given type is *produced* anywhere, the data needs to be valid for that type.
  86
  87 I hope this post was helpful in explaining why Undefined Behavior in Rust is defined the way it is.
  88 As usual, if you have any comments or questions, let me know in the forums.