Update memref type doc on aliasing guarantee across memory spaces

[bondhugula]

Summary

Update memref type doc to add that memrefs in different memory spaces
cannot alias with each other. This allows aliasing checks to be more
powerful and enforces a useful restriction/canonicalization.

While on this, fix a stale statement.

[bondhugula]

Fix stale statement.

[lattner]

Is this actually safe though? In LLVM, address spaces are allowed to alias. For example, you could have a hierarchy of memory regions, where some address spaces are a superset of the others (and thus can alias), and could even have the old x86-16 segment-offset style thing where you have pervasive aliases possible. I believe that LLVM pointer address spaces support this sort of thing.

[bondhugula]

In D121270#3377545, @lattner wrote:

Is this actually safe though? In LLVM, address spaces are allowed to alias. For example, you could have a hierarchy of memory regions, where some address spaces are a superset of the others (and thus can alias), and could even have the old x86-16 segment-offset style thing where you have pervasive aliases possible. I believe that LLVM pointer address spaces support this sort of thing.

Do you foresee needing such low-level abstractions and unrestricted generality on the memref type? The memref type is not used with the LLVM dialect - so you can still have such address space aliasing in the LLVM dialect or other similar dialects that are closer to the target.

[jrtc27]

Address spaces can also be used for the exact same memory but a different representation of the pointers, which can come with semantic differences; we use them in CHERI LLVM to differentiate between traditional integer addresses and CHERI capabilities, with the latter having associated bounds and permissions to provide spatial safety.

mlir/include/mlir/IR/BuiltinTypes.td

let description = [{
     The core syntax and representation of a layout specification is a
     [semi-affine map](Affine.md/#semi-affine-maps). Additionally,
     syntactic sugar is supported to make certain layout specifications more
     intuitive to read. For the moment, a `memref` supports parsing a strided
     form which is converted to a semi-affine map automatically.
 
     The memory space of a memref is specified by a target-specific attribute.
     It might be an integer value, string, dictionary or custom dialect attribute.
-    The empty memory space (attribute is None) is target specific.
+    The empty memory space (attribute is None) is target-specific. A memref in
+    one memory space cannot alias with a memref in a different memory space.
 
     The notionally dynamic value of a memref value includes the address of the
     buffer allocated, as well as the symbols referred to by the shape, layout
     map, and index maps.
 
-    Examples of memref static type
+    Examples of memref static type:
 
     ```mlir
     // Identity index/layout map
     #identity = affine_map<(d0, d1) -> (d0, d1)>
 
     // Column major layout.
     #col_major = affine_map<(d0, d1, d2) -> (d2, d1, d0)>