glossary: define place, value, representation

Author: RalfJung

reference/src/glossary.md

@@ -1,61 +1,5 @@
 ## Glossary
 
-#### Aliasing
-
-*Aliasing* occurs when one pointer or reference points to a "span" of memory
-that overlaps with the span of another pointer or reference. A span of memory is
-similar to how a slice works: there's a base byte address as well as a length in
-bytes.
-
-**Note**: a full aliasing model for Rust, defining when aliasing is allowed
-and when not, has not yet been defined. The purpose of this definition is to
-define when aliasing *happens*, not when it is *allowed*. The most developed
-potential aliasing model so far is known as "Stacked Borrows", and can be found
-[here](https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md).
-
-Consider the following example:
-
-```rust
-fn main() {
-    let u: u64 = 7_u64;
-    let r: &u64 = &u;
-    let s: &[u8] = unsafe {
-        core::slice::from_raw_parts(&u as *const u64 as *const u8, 8)
-    };
-    let (head, tail) = s.split_first().unwrap();
-}
-```
-
-In this case, both `r` and `s` alias each other, since they both point to all of
-the bytes of `u`.
-
-However, `head` and `tail` do not alias each other: `head` points to the first
-byte of `u` and `tail` points to the other seven bytes of `u` after it. Both `head`
-and `tail` alias `s`, any overlap is sufficient to count as an alias.
-
-The span of a pointer or reference is the size of the value being pointed to or referenced.
-Depending on the type, you can determine the size as follows:
-
-* For a type `T` that is [`Sized`](https://doc.rust-lang.org/core/marker/trait.Sized.html)
-  The span length of a pointer or reference to `T` is found with `size_of::<T>()`.
-* When `T` is not `Sized` the story is a little tricker:
-  * If you have a reference `r` you can use `size_of_val(r)` to determine the
-    span of the reference.
-  * If you have a pointer `p` you must unsafely convert that to a reference before
-    you can use `size_of_val`. There is not currently a safe way to determine the
-    span of a pointer to an unsized type.
-
-The [Data layout](./layout.md) chapter also has more information on the sizes of different types.
-
-One interesting side effect of these rules is that references and pointers to
-Zero Sized Types _never_ alias each other, because their span length is always 0
-bytes.
-
-It is also important to know that LLVM IR has a `noalias` attribute that works
-somewhat differently from this definition. However, that's considered a low
-level detail of a particular Rust implementation. When programming Rust, the
-Abstract Rust Machine is intended to operate according to the definition here.
-
 #### Interior mutability
 
 *Interior Mutation* means mutating memory where there also exists a live shared reference pointing to the same memory; or mutating memory through a pointer derived from a shared reference.
@@ -129,10 +73,44 @@ niches. For example, the "all bits uninitialized" is an invalid bit-pattern for
 `&mut T`, but this bit-pattern cannot be used by layout optimizations, and is not a
 niche.
 
+#### Place
+
+A *place* (called "lvalue" in C and "glvalue" in C++) is the result of computing a [*place expression*][place-value-expr].
+A place is basically a pointer (pointing to some location in memory, potentially carrying [provenance](#pointer-provenance)), but might contain more information such as size or alignment (the details will have to be determined as the Rust Abstract Machine gets specified more precisely).
+A place has a type.
+Places cannot be "stored" in memory, only [values](#value) can.
+
+The key operations on a place are:
+* storing a [value](#value) of the same type in it (when it is used on the left-hand side of an assignment),
+* turning it into a [pointer value](#value) (when it is used inside `&expr`),
+* and loading a [value](#value) of the same type from it (through the place-to-value coercion).
+
+
+#### Value
+
+A *value* (called "value of the expression" or "rvalue" in C and "prvalue" in C++) is what gets stored in a [place](#place), and also the result of computing a [*value expression*][place-value-expr].
+A value has a type, and it denotes the abstract mathematical concept that is represented by data in our programs.
+For example, a value of type `u8` is a mathematical integer in the range `0..256`.
+Values can be (according to their type) turned into a list of bytes, which is called a [representation](#representation) of the value.
+Values are ephemeral; they arise during the computation of an instruction but are only ever persisted in memory through their representation.
+(This is comparable to how run-time data in a program is ephemeral and is only ever persisted in serialized form.)
+
+#### Representation (relation)
+
+A *representation* of a [value](#value) is a list of bytes that is used to store or "represent" that value in memory.
+
+We also sometimes speak of the *representation of a type*; this should more correctly be called the *representation relation* as it relates values of this type to lists of bytes that represent this value.
+The term "relation" here is used in the mathematical sense: the representation relation is a predicate that, given a value and a list of bytes, says whether this value is represented by that list of bytes (`val -> list byte -> Prop`).
+
+The relation should be functional for a fixed list of bytes (i.e., every list of bytes has at most one associated representation).
+It is partial in both directions: not all values have a representation (e.g. the mathematical integer `300` has no representation at type `u8`), and not all lists of bytes correspond to a value of a specific type (e.g. lists of the wrong size correspond to no value, and the list consisting of the single byte `0x10` corresponds to no value of type `bool`).
+For a fixed value, there can be many representations (e.g., when considering type `#[repr(C)] Pair(u8, u16)`, the second byte is a padding byte so changing it does not affect the value represented by a list of bytes).
+
+See the [value domain][value-domain] for an example how values and representation relations can be made more precise.
 
 ### TODO
 
 * *tag*
-* *rvalue*
-* *lvalue*
-* *representation*
+
+[value-domain]: https://github.com/rust-lang/unsafe-code-guidelines/tree/master/wip/value-domain.md
+[place-value-expr]: https://doc.rust-lang.org/reference/expressions.html#place-expressions-and-value-expressions