{%hackmd theme-dark %}

## #152 What about: volatile, concurrency, and interaction with untrusted threads

<https://github.com/rust-lang/unsafe-code-guidelines/issues/152>
## #201 Glossary unspecified/implementation-defined behavior

<https://github.com/rust-lang/unsafe-code-guidelines/issues/201>
## #215 Should Rust assume that there are unknown threads of execution?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/215>
## #216 Dereferencing raw pointer to invalid data?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/216>
## #224 Layout of pointers to slices of ZSTs

<https://github.com/rust-lang/unsafe-code-guidelines/issues/224>
## #227 Cast-to-raw: inherit permission from parent pointer?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/227>
## #231 Optimisations based on lifetimes

<https://github.com/rust-lang/unsafe-code-guidelines/issues/231>
## #236 Stacked Borrows: How precise should UnsafeCell be tracked?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/236>
## #237 Our floating point semantics were a mess

<https://github.com/rust-lang/unsafe-code-guidelines/issues/237>
## #239 What are the exact semantics of pointer comparison?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/239>
## #242 Semver guarantees for data layouts

<https://github.com/rust-lang/unsafe-code-guidelines/issues/242>
## #244 What about: splitting struct into separate fields despite escaped references (maybe even raw pointers)

<https://github.com/rust-lang/unsafe-code-guidelines/issues/244>
## #245 Validity of ManuallyDrop, or: ManuallyDrop<Box<_>> is strange

<https://github.com/rust-lang/unsafe-code-guidelines/issues/245>
## #251 Representation of and operations on pointers and usize

<https://github.com/rust-lang/unsafe-code-guidelines/issues/251>
## #252 SB: Allowing function argument references to dangle under some circumstances

<https://github.com/rust-lang/unsafe-code-guidelines/issues/252>
## #254 Status of Unsafe Code Guidelines Reference

<https://github.com/rust-lang/unsafe-code-guidelines/issues/254>
## #255 What about: "odd" pointer sizes

<https://github.com/rust-lang/unsafe-code-guidelines/issues/255>
## #256 Storing an object as &Header, but reading the data past the end of the header

<https://github.com/rust-lang/unsafe-code-guidelines/issues/256>
## #257 Differences between `*const T` and `*mut T`. Initially `*const T` pointers are forever read-only?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/257>
## #259 Are statics confined to the size indicated by their type?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/259>
## #260 Interaction between `volatile` and `fence`

<https://github.com/rust-lang/unsafe-code-guidelines/issues/260>
## #261 "_" patterns and validity invariants

<https://github.com/rust-lang/unsafe-code-guidelines/issues/261>
## #266 Transmute between functions with different return types, where one function never returns

<https://github.com/rust-lang/unsafe-code-guidelines/issues/266>
## #267 How deep do exception safety guarantees need to go in FFI/unsafe code?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/267>
## #269 Mutable statics are difficult to use correctly

<https://github.com/rust-lang/unsafe-code-guidelines/issues/269>
## #270 Is transmuting `&’a &’b T` to `&’a &’b mut T` sound or UB?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/270>
## #271 How to use PhantomData?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/271>
## #274 Stacked Borrows: `Disabled` has more effects than expected

<https://github.com/rust-lang/unsafe-code-guidelines/issues/274>
## #275 "Ticket-lock" mutexes motivate "interior concurrency," not just "interior mutability"

<https://github.com/rust-lang/unsafe-code-guidelines/issues/275>
## #276 Stacked Borrows cannot properly handle `extern type`

<https://github.com/rust-lang/unsafe-code-guidelines/issues/276>
## #277 Layout of multi-dimensional arrays

<https://github.com/rust-lang/unsafe-code-guidelines/issues/277>
## #278 Safety/soundness of macros

<https://github.com/rust-lang/unsafe-code-guidelines/issues/278>
## #281 Can a pointer obtained by casting `&UnsafeCell<T>` to `*mut T` be written to?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/281>
## #282 Transmuting the same trait object with different lifetimes

<https://github.com/rust-lang/unsafe-code-guidelines/issues/282>
## #283 Functions called by a may_dangle Drop impl

<https://github.com/rust-lang/unsafe-code-guidelines/issues/283>
## #285 Validity of pointers and references to memory not allocated by the compiler

<https://github.com/rust-lang/unsafe-code-guidelines/issues/285>
## #286 What about: Pointer-to-integer transmutes?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/286>
## #288 Cast to a DST pointer?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/288>
## #292 Tracking where we rely on LLVM giving more guarantees than C

<https://github.com/rust-lang/unsafe-code-guidelines/issues/292>
## #293 `Send` and `Sync`

<https://github.com/rust-lang/unsafe-code-guidelines/issues/293>
## #294 Document (for the purpose of education) cases where Rust gives unsafe code fewer guarantees than C/C++ code has come to rely on

<https://github.com/rust-lang/unsafe-code-guidelines/issues/294>
## #295 Why does stacked borrows treat reference parameters specially?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/295>
## #303 Stacked Borrows does not support &UnsafeCell pointing to read-only data

<https://github.com/rust-lang/unsafe-code-guidelines/issues/303>
## #302 ManuallyDrop layout guarantees?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/302>
## #305 A really sad solution to extern type: special case reference-to-ZST

<https://github.com/rust-lang/unsafe-code-guidelines/issues/305>
## #306 Is size guaranteed to be a multiple of alignment?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/306>
## #307 Are `Copy` implementations semantically relevant (besides specialization)?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/307>
## #313 What is the provenance of an int-to-ptr result for not strictly inbounds live pointers?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/313>
## #314 Using a ZST reference like a raw pointer to avoid asserting aliasing

<https://github.com/rust-lang/unsafe-code-guidelines/issues/314>
## #315 Does an empty struct have the same layout as the empty tuple?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/315>
## #316 About "unleaking": what is the required pointer provenance in `dealloc`?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/316>
## #318 What guarantees are provided by repr(packed)?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/318>
## #319 Should raw pointer deref/projections have to be in-bounds?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/319>
## #320 Documentation for mem::forget implies that it may invalidate raw pointers to heap allocations

<https://github.com/rust-lang/unsafe-code-guidelines/issues/320>
## #321 ## Pre-Pre-RFC: `core::arch::{load, store}` and stricter volatile semantics

<https://github.com/rust-lang/unsafe-code-guidelines/issues/321>
## #323 What about: seqlocks, load-release/store-acquire?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/323>
## #324 requirments of pointers in stacked borrows

<https://github.com/rust-lang/unsafe-code-guidelines/issues/324>
## #325 Can you transmute &ZST to &mut ZST

<https://github.com/rust-lang/unsafe-code-guidelines/issues/325>
## #326 What are the uniqueness guarantees of Box and Vec?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/326>
## #328 Removing allocations is technically unsound in OOM (out-of-memory) situations

<https://github.com/rust-lang/unsafe-code-guidelines/issues/328>
## #329 Layout guarantees for types with const generic parameters

<https://github.com/rust-lang/unsafe-code-guidelines/issues/329>
## #331 Can inline assembly reads read uninit and violate noalias?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/331>
## #337 Is it UB for a uninhibited type, like the never type, value to exist?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/337>
## #338 How are virtual function calls specced?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/338>
## #339 How does TypeId work in the AM?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/339>
## #340 Do function pointers behave like data pointers (wrt provenance and other aspects)?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/340>
## #342 `extern "C" fn` with zero-sized argument?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/342>
## #345 What about: mixed-size atomic accesses

<https://github.com/rust-lang/unsafe-code-guidelines/issues/345>
## #346 Document current justification for not requiring recursive reference validity (in particular, `&mut uninit` not being immediate UB)

<https://github.com/rust-lang/unsafe-code-guidelines/issues/346>
## #347 Does the concept of a compiler fence make any sense?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/347>
## #348 Support for Linux kernel memory model

<https://github.com/rust-lang/unsafe-code-guidelines/issues/348>
## #350 Can we weaken the requirements for `offset`? (Was: Should we / can we make all "getelementptr inbounds" into "getelementptr nowrap"?)

<https://github.com/rust-lang/unsafe-code-guidelines/issues/350>
## #351 Should a mutable reference which is only used for reads become invalid on reads through other ptrs?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/351>
## #352 What is the safety invariant, if any, for unions?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/352>
## #353 Offsets of union fields

<https://github.com/rust-lang/unsafe-code-guidelines/issues/353>
## #354 Do #[repr(Rust)] unions have internal padding?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/354>
## #355 Should atomic loads and failing atomic RMWs be writes for the purpose of the aliasing model and data races?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/355>
## #356 Allow references to extern types to be tagged pointers?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/356>
## #357 Pre-Pre-RFC: `&const` and `&shared` references

<https://github.com/rust-lang/unsafe-code-guidelines/issues/357>
## #360 What about: liveness? ("forward progress")

<https://github.com/rust-lang/unsafe-code-guidelines/issues/360>
## #362 Should we expose process-wide barriers?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/362>
## #363 Stacked Borrows: aliasing rules for local variables

<https://github.com/rust-lang/unsafe-code-guidelines/issues/363>
## #364 What is the value model/validity invariant for single-field transparent unions?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/364>
## #366 Can a manual trait upcast be safe?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/366>
## #367 Operational Semantics for Generators

<https://github.com/rust-lang/unsafe-code-guidelines/issues/367>
## #370 Alignment at const time?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/370>
## #371 Stacked Borrows: when exactly should we retag?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/371>
## #372 Stacked Borrows: do we even want protectors?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/372>
## #373 Should `drop_in_place` imply dereferencability?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/373>
## #374 Should 'dereferenceable' take into account the dynamic size information where possible?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/374>
## #375 Implication of layout equality for reference layout

<https://github.com/rust-lang/unsafe-code-guidelines/issues/375>
## #379 Soundness conflicts

<https://github.com/rust-lang/unsafe-code-guidelines/issues/379>
## #381 Self-referential generators vs `dereferenceable`

<https://github.com/rust-lang/unsafe-code-guidelines/issues/381>
## #384 Aliasing rules for `Unique`

<https://github.com/rust-lang/unsafe-code-guidelines/issues/384>
## #387 Invariant lifetime shrinks if reference is not dereferenced? (or: is it possible to safely use `ManuallyDrop::take()` in generic context?)

<https://github.com/rust-lang/unsafe-code-guidelines/issues/387>
## #388 Is a race between an unsynchronized read and write UB if the read value is always disregarded?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/388>
## #390 Unique reference pointer equality tests are not optimized

<https://github.com/rust-lang/unsafe-code-guidelines/issues/390>
## #391 Operational semantics of pre-drop-elab code?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/391>
## #392 The trouble with angelic choice (in int2ptr casts)

<https://github.com/rust-lang/unsafe-code-guidelines/issues/392>
## #394 Can Drop::drop invalidate the value? (i.e. can drop_in_place rely on the value staying valid-but-unusable)

<https://github.com/rust-lang/unsafe-code-guidelines/issues/394>
## #397 Must `static DATA: UnsafeCell = expr;` still `== expr` by `main()`?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/397>
## #398 Miri finds UB when `ManuallyDrop::take` safety invariants are not violated

<https://github.com/rust-lang/unsafe-code-guidelines/issues/398>
## #400 Must `let` variables (without `mut` or `UnsafeCell`) be read-only?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/400>
## #401 Is rustc guaranteed to reject code which "turns a pointer into raw bytes" in const code?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/401>
## #403 Tree Borrows: How would more precise UnsafeCell tracking work?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/403>
## #404 Is `longjmp` through rust code UB

<https://github.com/rust-lang/unsafe-code-guidelines/issues/404>
## #406 What are our guarantees regarding pointer identity on `const`s

<https://github.com/rust-lang/unsafe-code-guidelines/issues/406>
## #407 Does our UB have "time travel" semantics?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/407>
## #411 Can we have VolatileCell

<https://github.com/rust-lang/unsafe-code-guidelines/issues/411>
## #412 Do we have full recursive validity for references?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/412>
## #413 Can references to uninhabited types ever be valid?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/413>
## #414 Should validity of a reference depend on the *contents* of memory in any way?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/414>
## #416 What are the semantics of `move` operands?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/416>
## #417 What exactly is going on with return places and the LHS of assignments?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/417>
## #418 Validity invariant of places

<https://github.com/rust-lang/unsafe-code-guidelines/issues/418>
## #419 Should we have subobject provenance?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/419>
## #420 Is a read() of the last byte in the address space allowed?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/420>
## #424 Do aliasing requirements carry over from const-time to run-time?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/424>
## #425 Mutating the contents of `&&mut T`, without converting `&mut T` to `&T`

<https://github.com/rust-lang/unsafe-code-guidelines/issues/425>
## #426 Document the assumptions we make about the C standard library, that go beyond what C requires

<https://github.com/rust-lang/unsafe-code-guidelines/issues/426>
## #427 Can we require bounded stack consumption?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/427>
## #430 Can allocations have gaps? Can they be partially deallocated? Can they grow "in-place"?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/430>
## #431 Do default repr structs have a contiguous memory representation?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/431>
## #433 When are references allowed to be deallocated while a function they were passed to runs?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/433>
## #434 Determine and document the distinction between I/O safety and regular safety on unsafe stdlib APIs

<https://github.com/rust-lang/unsafe-code-guidelines/issues/434>
## #435 On the legality of introducing spurious loads of `&UnsafeCell` (aka: dereferenceable and noalias don't interact well)

<https://github.com/rust-lang/unsafe-code-guidelines/issues/435>
## #442 What about: custom allocators

<https://github.com/rust-lang/unsafe-code-guidelines/issues/442>
## #443 Layout and behavior of enums with uninhabited fields in some variants

<https://github.com/rust-lang/unsafe-code-guidelines/issues/443>
## #444 What is the opsem of signal/interrupt handlers.

<https://github.com/rust-lang/unsafe-code-guidelines/issues/444>
## #449 Operational semantics for `AtomicMaybeUninit::compare_exchange`

<https://github.com/rust-lang/unsafe-code-guidelines/issues/449>
## #450 Should `&mut`-derived pointers be permanently "separate" from their siblings?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/450>
## #451 Is it sound to field-project into a `Cell` or `UnsafeCell`?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/451>
## #455 Is it sound to produce `&[u8]` and `&UnsafeCell` to the same memory so long as the latter isn't "used"?

<https://github.com/rust-lang/unsafe-code-guidelines/issues/455>