unaligned → misaligned

src/behavior-considered-undefined.md

@@ -24,7 +24,7 @@ code.
 
 * Data races.
 * Accessing (loading from or storing to) a place that is [dangling] or [based on
-  an unaligned pointer].
+  a misaligned pointer].
 * Performing a place projection that violates the requirements of [in-bounds
   pointer arithmetic][offset]. A place projection is a [field
   expression][project-field], a [tuple index expression][project-tuple], or an
@@ -67,7 +67,7 @@ code.
   * A `!` (all values are invalid for this type).
   * An integer (`i*`/`u*`), floating point value (`f*`), or raw pointer obtained
     from [uninitialized memory][undef], or uninitialized memory in a `str`.
-  * A reference or `Box<T>` that is [dangling], unaligned, or points to an invalid value.
+  * A reference or `Box<T>` that is [dangling], misaligned, or points to an invalid value.
   * Invalid metadata in a wide reference, `Box<T>`, or raw pointer:
     * `dyn Trait` metadata is invalid if it is not a pointer to a vtable for
       `Trait` that matches the actual dynamic trait the pointer or reference points to.
@@ -101,17 +101,17 @@ reading uninitialized memory is permitted are inside `union`s and in "padding"
 
 The span of bytes a pointer or reference "points to" is determined by the pointer value and the size of the pointee type (using `size_of_val`).
 
-### Places based on unaligned pointers
-[based on an unaligned pointer]: #places-based-on-unaligned-pointers
+### Places based on misaligned pointers
+[based on a misaligned pointer]: #places-based-on-misaligned-pointers
 
-A place is said to be "based on an unaligned pointer" if the last `*` projection
+A place is said to be "based on a misaligned pointer" if the last `*` projection
 during place computation was performed on a pointer that was not aligned for its
 type. (If there is no `*` projection in the place expression, then this is
 accessing the field of a local and rustc will guarantee proper alignment.)
 
 For instance, if `ptr` has struct type `S` with a field `f` of type `u8`, but
 the alignment of `S` is 8, then `ptr` must be 8-aligned or else `(*ptr).f` is
-"based on an unaligned pointer". In other words, the alignment requirement
+"based on an misaligned pointer". In other words, the alignment requirement
 derives from the type of the pointer that was dereferenced, *not* the type of
 the field that is being accessed.