1 //! This defines the syntax of MIR, i.e., the set of available MIR operations, and other definitions
2 //! closely related to MIR semantics.
3 //! This is in a dedicated file so that changes to this file can be reviewed more carefully.
4 //! The intention is that this file only contains datatype declarations, no code.
6 use super::{BasicBlock, Constant, Field, Local, SwitchTargets, UserTypeProjection};
8 use crate::mir::coverage::{CodeRegion, CoverageKind};
9 use crate::traits::Reveal;
10 use crate::ty::adjustment::PointerCast;
11 use crate::ty::subst::SubstsRef;
12 use crate::ty::{self, List, Ty};
13 use crate::ty::{Region, UserTypeAnnotationIndex};
15 use rustc_ast::{InlineAsmOptions, InlineAsmTemplatePiece};
16 use rustc_hir::def_id::DefId;
17 use rustc_hir::{self as hir};
18 use rustc_hir::{self, GeneratorKind};
19 use rustc_target::abi::VariantIdx;
21 use rustc_ast::Mutability;
22 use rustc_span::def_id::LocalDefId;
23 use rustc_span::symbol::Symbol;
25 use rustc_target::asm::InlineAsmRegOrRegClass;
27 /// Represents the "flavors" of MIR.
29 /// All flavors of MIR use the same data structure, but there are some important differences. These
30 /// differences come in two forms: Dialects and phases.
32 /// Dialects represent a stronger distinction than phases. This is because the transitions between
33 /// dialects are semantic changes, and therefore technically *lowerings* between distinct IRs. In
34 /// other words, the same [`Body`](crate::mir::Body) might be well-formed for multiple dialects, but
35 /// have different semantic meaning and different behavior at runtime.
37 /// Each dialect additionally has a number of phases. However, phase changes never involve semantic
38 /// changes. If some MIR is well-formed both before and after a phase change, it is also guaranteed
39 /// that it has the same semantic meaning. In this sense, phase changes can only add additional
40 /// restrictions on what MIR is well-formed.
42 /// When adding phases, remember to update [`MirPhase::phase_index`].
43 #[derive(Copy, Clone, TyEncodable, TyDecodable, Debug, PartialEq, Eq, PartialOrd, Ord)]
46 /// The MIR that is generated by MIR building.
48 /// The only things that operate on this dialect are unsafeck, the various MIR lints, and const
51 /// This has no distinct phases.
53 /// The MIR used for most analysis.
55 /// The only semantic change between analysis and built MIR is constant promotion. In built MIR,
56 /// sequences of statements that would generally be subject to constant promotion are
57 /// semantically constants, while in analysis MIR all constants are explicit.
59 /// The result of const promotion is available from the `mir_promoted` and `promoted_mir` queries.
61 /// This is the version of MIR used by borrowck and friends.
62 Analysis(AnalysisPhase),
63 /// The MIR used for CTFE, optimizations, and codegen.
65 /// The semantic changes that occur in the lowering from analysis to runtime MIR are as follows:
67 /// - Drops: In analysis MIR, `Drop` terminators represent *conditional* drops; roughly speaking,
68 /// if dataflow analysis determines that the place being dropped is uninitialized, the drop will
69 /// not be executed. The exact semantics of this aren't written down anywhere, which means they
70 /// are essentially "what drop elaboration does." In runtime MIR, the drops are unconditional;
71 /// when a `Drop` terminator is reached, if the type has drop glue that drop glue is always
72 /// executed. This may be UB if the underlying place is not initialized.
73 /// - Packed drops: Places might in general be misaligned - in most cases this is UB, the exception
74 /// is fields of packed structs. In analysis MIR, `Drop(P)` for a `P` that might be misaligned
75 /// for this reason implicitly moves `P` to a temporary before dropping. Runtime MIR has no such
76 /// rules, and dropping a misaligned place is simply UB.
77 /// - Unwinding: in analysis MIR, unwinding from a function which may not unwind aborts. In runtime
79 /// - Retags: If `-Zmir-emit-retag` is enabled, analysis MIR has "implicit" retags in the same way
80 /// that Rust itself has them. Where exactly these are is generally subject to change, and so we
81 /// don't document this here. Runtime MIR has all retags explicit.
82 /// - Generator bodies: In analysis MIR, locals may actually be behind a pointer that user code has
83 /// access to. This occurs in generator bodies. Such locals do not behave like other locals,
84 /// because they eg may be aliased in surprising ways. Runtime MIR has no such special locals -
85 /// all generator bodies are lowered and so all places that look like locals really are locals.
87 /// Also note that the lint pass which reports eg `200_u8 + 200_u8` as an error is run as a part
88 /// of analysis to runtime MIR lowering. To ensure lints are reported reliably, this means that
89 /// transformations which may suppress such errors should not run on analysis MIR.
90 Runtime(RuntimePhase),
94 pub fn name(&self) -> &'static str {
96 MirPhase::Built => "built",
97 MirPhase::Analysis(AnalysisPhase::Initial) => "analysis",
98 MirPhase::Analysis(AnalysisPhase::PostCleanup) => "analysis-post-cleanup",
99 MirPhase::Runtime(RuntimePhase::Initial) => "runtime",
100 MirPhase::Runtime(RuntimePhase::PostCleanup) => "runtime-post-cleanup",
101 MirPhase::Runtime(RuntimePhase::Optimized) => "runtime-optimized",
105 pub fn reveal(&self) -> Reveal {
107 MirPhase::Built | MirPhase::Analysis(_) => Reveal::UserFacing,
108 MirPhase::Runtime(_) => Reveal::All,
113 /// See [`MirPhase::Analysis`].
114 #[derive(Copy, Clone, TyEncodable, TyDecodable, Debug, PartialEq, Eq, PartialOrd, Ord)]
115 #[derive(HashStable)]
116 pub enum AnalysisPhase {
118 /// Beginning in this phase, the following variants are disallowed:
119 /// * [`TerminatorKind::FalseUnwind`]
120 /// * [`TerminatorKind::FalseEdge`]
121 /// * [`StatementKind::FakeRead`]
122 /// * [`StatementKind::AscribeUserType`]
123 /// * [`Rvalue::Ref`] with `BorrowKind::Shallow`
125 /// Furthermore, `Deref` projections must be the first projection within any place (if they
130 /// See [`MirPhase::Runtime`].
131 #[derive(Copy, Clone, TyEncodable, TyDecodable, Debug, PartialEq, Eq, PartialOrd, Ord)]
132 #[derive(HashStable)]
133 pub enum RuntimePhase {
134 /// In addition to the semantic changes, beginning with this phase, the following variants are
136 /// * [`TerminatorKind::DropAndReplace`]
137 /// * [`TerminatorKind::Yield`]
138 /// * [`TerminatorKind::GeneratorDrop`]
139 /// * [`Rvalue::Aggregate`] for any `AggregateKind` except `Array`
141 /// And the following variants are allowed:
142 /// * [`StatementKind::Retag`]
143 /// * [`StatementKind::SetDiscriminant`]
144 /// * [`StatementKind::Deinit`]
146 /// Furthermore, `Copy` operands are allowed for non-`Copy` types.
148 /// Beginning with this phase, the following variant is disallowed:
149 /// * [`ProjectionElem::Deref`] of `Box`
154 ///////////////////////////////////////////////////////////////////////////
157 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, TyEncodable, TyDecodable)]
158 #[derive(Hash, HashStable)]
159 pub enum BorrowKind {
160 /// Data must be immutable and is aliasable.
163 /// The immediately borrowed place must be immutable, but projections from
164 /// it don't need to be. For example, a shallow borrow of `a.b` doesn't
165 /// conflict with a mutable borrow of `a.b.c`.
167 /// This is used when lowering matches: when matching on a place we want to
168 /// ensure that place have the same value from the start of the match until
169 /// an arm is selected. This prevents this code from compiling:
170 /// ```compile_fail,E0510
171 /// let mut x = &Some(0);
174 /// Some(_) if { x = &None; false } => (),
178 /// This can't be a shared borrow because mutably borrowing (*x as Some).0
179 /// should not prevent `if let None = x { ... }`, for example, because the
180 /// mutating `(*x as Some).0` can't affect the discriminant of `x`.
181 /// We can also report errors with this kind of borrow differently.
184 /// Data must be immutable but not aliasable. This kind of borrow
185 /// cannot currently be expressed by the user and is used only in
186 /// implicit closure bindings. It is needed when the closure is
187 /// borrowing or mutating a mutable referent, e.g.:
190 /// let x: &mut isize = &mut z;
191 /// let y = || *x += 5;
193 /// If we were to try to translate this closure into a more explicit
194 /// form, we'd encounter an error with the code as written:
195 /// ```compile_fail,E0594
196 /// struct Env<'a> { x: &'a &'a mut isize }
198 /// let x: &mut isize = &mut z;
199 /// let y = (&mut Env { x: &x }, fn_ptr); // Closure is pair of env and fn
200 /// fn fn_ptr(env: &mut Env) { **env.x += 5; }
202 /// This is then illegal because you cannot mutate an `&mut` found
203 /// in an aliasable location. To solve, you'd have to translate with
204 /// an `&mut` borrow:
205 /// ```compile_fail,E0596
206 /// struct Env<'a> { x: &'a mut &'a mut isize }
208 /// let x: &mut isize = &mut z;
209 /// let y = (&mut Env { x: &mut x }, fn_ptr); // changed from &x to &mut x
210 /// fn fn_ptr(env: &mut Env) { **env.x += 5; }
212 /// Now the assignment to `**env.x` is legal, but creating a
213 /// mutable pointer to `x` is not because `x` is not mutable. We
214 /// could fix this by declaring `x` as `let mut x`. This is ok in
215 /// user code, if awkward, but extra weird for closures, since the
216 /// borrow is hidden.
218 /// So we introduce a "unique imm" borrow -- the referent is
219 /// immutable, but not aliasable. This solves the problem. For
220 /// simplicity, we don't give users the way to express this
221 /// borrow, it's just used when translating closures.
224 /// Data is mutable and not aliasable.
226 /// `true` if this borrow arose from method-call auto-ref
227 /// (i.e., `adjustment::Adjust::Borrow`).
228 allow_two_phase_borrow: bool,
232 ///////////////////////////////////////////////////////////////////////////
235 /// The various kinds of statements that can appear in MIR.
237 /// Not all of these are allowed at every [`MirPhase`]. Check the documentation there to see which
238 /// ones you do not have to worry about. The MIR validator will generally enforce such restrictions,
239 /// causing an ICE if they are violated.
240 #[derive(Clone, Debug, PartialEq, TyEncodable, TyDecodable, Hash, HashStable)]
241 #[derive(TypeFoldable, TypeVisitable)]
242 pub enum StatementKind<'tcx> {
243 /// Assign statements roughly correspond to an assignment in Rust proper (`x = ...`) except
244 /// without the possibility of dropping the previous value (that must be done separately, if at
245 /// all). The *exact* way this works is undecided. It probably does something like evaluating
246 /// the LHS to a place and the RHS to a value, and then storing the value to the place. Various
247 /// parts of this may do type specific things that are more complicated than simply copying
250 /// **Needs clarification**: The implication of the above idea would be that assignment implies
251 /// that the resulting value is initialized. I believe we could commit to this separately from
252 /// committing to whatever part of the memory model we would need to decide on to make the above
253 /// paragragh precise. Do we want to?
255 /// Assignments in which the types of the place and rvalue differ are not well-formed.
257 /// **Needs clarification**: Do we ever want to worry about non-free (in the body) lifetimes for
258 /// the typing requirement in post drop-elaboration MIR? I think probably not - I'm not sure we
259 /// could meaningfully require this anyway. How about free lifetimes? Is ignoring this
260 /// interesting for optimizations? Do we want to allow such optimizations?
262 /// **Needs clarification**: We currently require that the LHS place not overlap with any place
263 /// read as part of computation of the RHS for some rvalues (generally those not producing
264 /// primitives). This requirement is under discussion in [#68364]. As a part of this discussion,
265 /// it is also unclear in what order the components are evaluated.
267 /// [#68364]: https://github.com/rust-lang/rust/issues/68364
269 /// See [`Rvalue`] documentation for details on each of those.
270 Assign(Box<(Place<'tcx>, Rvalue<'tcx>)>),
272 /// This represents all the reading that a pattern match may do (e.g., inspecting constants and
273 /// discriminant values), and the kind of pattern it comes from. This is in order to adapt
274 /// potential error messages to these specific patterns.
276 /// Note that this also is emitted for regular `let` bindings to ensure that locals that are
277 /// never accessed still get some sanity checks for, e.g., `let x: ! = ..;`
279 /// When executed at runtime this is a nop.
281 /// Disallowed after drop elaboration.
282 FakeRead(Box<(FakeReadCause, Place<'tcx>)>),
284 /// Write the discriminant for a variant to the enum Place.
286 /// This is permitted for both generators and ADTs. This does not necessarily write to the
287 /// entire place; instead, it writes to the minimum set of bytes as required by the layout for
289 SetDiscriminant { place: Box<Place<'tcx>>, variant_index: VariantIdx },
291 /// Deinitializes the place.
293 /// This writes `uninit` bytes to the entire place.
294 Deinit(Box<Place<'tcx>>),
296 /// `StorageLive` and `StorageDead` statements mark the live range of a local.
298 /// At any point during the execution of a function, each local is either allocated or
299 /// unallocated. Except as noted below, all locals except function parameters are initially
300 /// unallocated. `StorageLive` statements cause memory to be allocated for the local while
301 /// `StorageDead` statements cause the memory to be freed. Using a local in any way (not only
302 /// reading/writing from it) while it is unallocated is UB.
304 /// Some locals have no `StorageLive` or `StorageDead` statements within the entire MIR body.
305 /// These locals are implicitly allocated for the full duration of the function. There is a
306 /// convenience method at `rustc_mir_dataflow::storage::always_storage_live_locals` for
307 /// computing these locals.
309 /// If the local is already allocated, calling `StorageLive` again is UB. However, for an
310 /// unallocated local an additional `StorageDead` all is simply a nop.
313 /// See `StorageLive` above.
316 /// Retag references in the given place, ensuring they got fresh tags.
318 /// This is part of the Stacked Borrows model. These statements are currently only interpreted
319 /// by miri and only generated when `-Z mir-emit-retag` is passed. See
320 /// <https://internals.rust-lang.org/t/stacked-borrows-an-aliasing-model-for-rust/8153/> for
323 /// For code that is not specific to stacked borrows, you should consider retags to read and
324 /// modify the place in an opaque way.
326 /// Only `RetagKind::Default` and `RetagKind::FnEntry` are permitted.
327 Retag(RetagKind, Box<Place<'tcx>>),
329 /// Encodes a user's type ascription. These need to be preserved
330 /// intact so that NLL can respect them. For example:
331 /// ```ignore (illustrative)
334 /// The effect of this annotation is to relate the type `T_y` of the place `y`
335 /// to the user-given type `T`. The effect depends on the specified variance:
337 /// - `Covariant` -- requires that `T_y <: T`
338 /// - `Contravariant` -- requires that `T_y :> T`
339 /// - `Invariant` -- requires that `T_y == T`
340 /// - `Bivariant` -- no effect
342 /// When executed at runtime this is a nop.
344 /// Disallowed after drop elaboration.
345 AscribeUserType(Box<(Place<'tcx>, UserTypeProjection)>, ty::Variance),
347 /// Marks the start of a "coverage region", injected with '-Cinstrument-coverage'. A
348 /// `Coverage` statement carries metadata about the coverage region, used to inject a coverage
349 /// map into the binary. If `Coverage::kind` is a `Counter`, the statement also generates
350 /// executable code, to increment a counter variable at runtime, each time the code region is
352 Coverage(Box<Coverage>),
354 /// Denotes a call to an intrinsic that does not require an unwind path and always returns.
355 /// This avoids adding a new block and a terminator for simple intrinsics.
356 Intrinsic(Box<NonDivergingIntrinsic<'tcx>>),
358 /// No-op. Useful for deleting instructions without affecting statement indices.
373 pub enum NonDivergingIntrinsic<'tcx> {
374 /// Denotes a call to the intrinsic function `assume`.
376 /// The operand must be a boolean. Optimizers may use the value of the boolean to backtrack its
377 /// computation to infer information about other variables. So if the boolean came from a
378 /// `x < y` operation, subsequent operations on `x` and `y` could elide various bound checks.
379 /// If the argument is `false`, this operation is equivalent to `TerminatorKind::Unreachable`.
380 Assume(Operand<'tcx>),
382 /// Denotes a call to the intrinsic function `copy_nonoverlapping`.
384 /// First, all three operands are evaluated. `src` and `dest` must each be a reference, pointer,
385 /// or `Box` pointing to the same type `T`. `count` must evaluate to a `usize`. Then, `src` and
386 /// `dest` are dereferenced, and `count * size_of::<T>()` bytes beginning with the first byte of
387 /// the `src` place are copied to the contiguous range of bytes beginning with the first byte
390 /// **Needs clarification**: In what order are operands computed and dereferenced? It should
391 /// probably match the order for assignment, but that is also undecided.
393 /// **Needs clarification**: Is this typed or not, ie is there a typed load and store involved?
394 /// I vaguely remember Ralf saying somewhere that he thought it should not be.
395 CopyNonOverlapping(CopyNonOverlapping<'tcx>),
398 impl std::fmt::Display for NonDivergingIntrinsic<'_> {
399 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
401 Self::Assume(op) => write!(f, "assume({op:?})"),
402 Self::CopyNonOverlapping(CopyNonOverlapping { src, dst, count }) => {
403 write!(f, "copy_nonoverlapping(dst = {dst:?}, src = {src:?}, count = {count:?})")
409 /// Describes what kind of retag is to be performed.
410 #[derive(Copy, Clone, TyEncodable, TyDecodable, Debug, PartialEq, Eq, Hash, HashStable)]
411 #[rustc_pass_by_value]
413 /// The initial retag of arguments when entering a function.
415 /// Retag preparing for a two-phase borrow.
417 /// Retagging raw pointers.
419 /// A "normal" retag.
423 /// The `FakeReadCause` describes the type of pattern why a FakeRead statement exists.
424 #[derive(Copy, Clone, TyEncodable, TyDecodable, Debug, Hash, HashStable, PartialEq)]
425 pub enum FakeReadCause {
426 /// Inject a fake read of the borrowed input at the end of each guards
429 /// This should ensure that you cannot change the variant for an enum while
430 /// you are in the midst of matching on it.
433 /// `let x: !; match x {}` doesn't generate any read of x so we need to
434 /// generate a read of x to check that it is initialized and safe.
436 /// If a closure pattern matches a Place starting with an Upvar, then we introduce a
437 /// FakeRead for that Place outside the closure, in such a case this option would be
438 /// Some(closure_def_id).
439 /// Otherwise, the value of the optional LocalDefId will be None.
441 // We can use LocalDefId here since fake read statements are removed
442 // before codegen in the `CleanupNonCodegenStatements` pass.
443 ForMatchedPlace(Option<LocalDefId>),
445 /// A fake read of the RefWithinGuard version of a bind-by-value variable
446 /// in a match guard to ensure that its value hasn't change by the time
447 /// we create the OutsideGuard version.
450 /// Officially, the semantics of
452 /// `let pattern = <expr>;`
454 /// is that `<expr>` is evaluated into a temporary and then this temporary is
455 /// into the pattern.
457 /// However, if we see the simple pattern `let var = <expr>`, we optimize this to
458 /// evaluate `<expr>` directly into the variable `var`. This is mostly unobservable,
459 /// but in some cases it can affect the borrow checker, as in #53695.
460 /// Therefore, we insert a "fake read" here to ensure that we get
461 /// appropriate errors.
463 /// If a closure pattern matches a Place starting with an Upvar, then we introduce a
464 /// FakeRead for that Place outside the closure, in such a case this option would be
465 /// Some(closure_def_id).
466 /// Otherwise, the value of the optional DefId will be None.
467 ForLet(Option<LocalDefId>),
469 /// If we have an index expression like
471 /// (*x)[1][{ x = y; 4}]
473 /// then the first bounds check is invalidated when we evaluate the second
474 /// index expression. Thus we create a fake borrow of `x` across the second
475 /// indexer, which will cause a borrow check error.
479 #[derive(Clone, Debug, PartialEq, TyEncodable, TyDecodable, Hash, HashStable)]
480 #[derive(TypeFoldable, TypeVisitable)]
481 pub struct Coverage {
482 pub kind: CoverageKind,
483 pub code_region: Option<CodeRegion>,
486 #[derive(Clone, Debug, PartialEq, TyEncodable, TyDecodable, Hash, HashStable)]
487 #[derive(TypeFoldable, TypeVisitable)]
488 pub struct CopyNonOverlapping<'tcx> {
489 pub src: Operand<'tcx>,
490 pub dst: Operand<'tcx>,
491 /// Number of elements to copy from src to dest, not bytes.
492 pub count: Operand<'tcx>,
495 ///////////////////////////////////////////////////////////////////////////
498 /// The various kinds of terminators, representing ways of exiting from a basic block.
500 /// A note on unwinding: Panics may occur during the execution of some terminators. Depending on the
501 /// `-C panic` flag, this may either cause the program to abort or the call stack to unwind. Such
502 /// terminators have a `cleanup: Option<BasicBlock>` field on them. If stack unwinding occurs, then
503 /// once the current function is reached, execution continues at the given basic block, if any. If
504 /// `cleanup` is `None` then no cleanup is performed, and the stack continues unwinding. This is
505 /// equivalent to the execution of a `Resume` terminator.
507 /// The basic block pointed to by a `cleanup` field must have its `cleanup` flag set. `cleanup`
508 /// basic blocks have a couple restrictions:
509 /// 1. All `cleanup` fields in them must be `None`.
510 /// 2. `Return` terminators are not allowed in them. `Abort` and `Unwind` terminators are.
511 /// 3. All other basic blocks (in the current body) that are reachable from `cleanup` basic blocks
512 /// must also be `cleanup`. This is a part of the type system and checked statically, so it is
513 /// still an error to have such an edge in the CFG even if it's known that it won't be taken at
515 /// 4. The control flow between cleanup blocks must look like an upside down tree. Roughly
516 /// speaking, this means that control flow that looks like a V is allowed, while control flow
517 /// that looks like a W is not. This is necessary to ensure that landing pad information can be
518 /// correctly codegened on MSVC. More precisely:
520 /// Begin with the standard control flow graph `G`. Modify `G` as follows: for any two cleanup
521 /// vertices `u` and `v` such that `u` dominates `v`, contract `u` and `v` into a single vertex,
522 /// deleting self edges and duplicate edges in the process. Now remove all vertices from `G`
523 /// that are not cleanup vertices or are not reachable. The resulting graph must be an inverted
524 /// tree, that is each vertex may have at most one successor and there may be no cycles.
525 #[derive(Clone, TyEncodable, TyDecodable, Hash, HashStable, PartialEq, TypeFoldable, TypeVisitable)]
526 pub enum TerminatorKind<'tcx> {
527 /// Block has one successor; we continue execution there.
528 Goto { target: BasicBlock },
530 /// Switches based on the computed value.
532 /// First, evaluates the `discr` operand. The type of the operand must be a signed or unsigned
533 /// integer, char, or bool, and must match the given type. Then, if the list of switch targets
534 /// contains the computed value, continues execution at the associated basic block. Otherwise,
535 /// continues execution at the "otherwise" basic block.
537 /// Target values may not appear more than once.
539 /// The discriminant value being tested.
540 discr: Operand<'tcx>,
541 targets: SwitchTargets,
544 /// Indicates that the landing pad is finished and that the process should continue unwinding.
546 /// Like a return, this marks the end of this invocation of the function.
548 /// Only permitted in cleanup blocks. `Resume` is not permitted with `-C unwind=abort` after
549 /// deaggregation runs.
552 /// Indicates that the landing pad is finished and that the process should abort.
554 /// Used to prevent unwinding for foreign items or with `-C unwind=abort`. Only permitted in
558 /// Returns from the function.
560 /// Like function calls, the exact semantics of returns in Rust are unclear. Returning very
561 /// likely at least assigns the value currently in the return place (`_0`) to the place
562 /// specified in the associated `Call` terminator in the calling function, as if assigned via
563 /// `dest = move _0`. It might additionally do other things, like have side-effects in the
566 /// If the body is a generator body, this has slightly different semantics; it instead causes a
567 /// `GeneratorState::Returned(_0)` to be created (as if by an `Aggregate` rvalue) and assigned
568 /// to the return place.
571 /// Indicates a terminator that can never be reached.
573 /// Executing this terminator is UB.
576 /// The behavior of this statement differs significantly before and after drop elaboration.
578 /// After drop elaboration: `Drop` terminators are a complete nop for types that have no drop
579 /// glue. For other types, `Drop` terminators behave exactly like a call to
580 /// `core::mem::drop_in_place` with a pointer to the given place.
582 /// `Drop` before drop elaboration is a *conditional* execution of the drop glue. Specifically,
583 /// the `Drop` will be executed if...
585 /// **Needs clarification**: End of that sentence. This in effect should document the exact
586 /// behavior of drop elaboration. The following sounds vaguely right, but I'm not quite sure:
588 /// > The drop glue is executed if, among all statements executed within this `Body`, an assignment to
589 /// > the place or one of its "parents" occurred more recently than a move out of it. This does not
590 /// > consider indirect assignments.
591 Drop { place: Place<'tcx>, target: BasicBlock, unwind: Option<BasicBlock> },
593 /// Drops the place and assigns a new value to it.
595 /// This first performs the exact same operation as the pre drop-elaboration `Drop` terminator;
596 /// it then additionally assigns the `value` to the `place` as if by an assignment statement.
597 /// This assignment occurs both in the unwind and the regular code paths. The semantics are best
598 /// explained by the elaboration:
602 /// DropAndReplace(P <- V, goto BB1, unwind BB2)
610 /// Drop(P, goto BB1, unwind BB2)
613 /// // P is now uninitialized
617 /// // P is now uninitialized -- its dtor panicked
622 /// Disallowed after drop elaboration.
625 value: Operand<'tcx>,
627 unwind: Option<BasicBlock>,
630 /// Roughly speaking, evaluates the `func` operand and the arguments, and starts execution of
631 /// the referred to function. The operand types must match the argument types of the function.
632 /// The return place type must match the return type. The type of the `func` operand must be
633 /// callable, meaning either a function pointer, a function type, or a closure type.
635 /// **Needs clarification**: The exact semantics of this. Current backends rely on `move`
636 /// operands not aliasing the return place. It is unclear how this is justified in MIR, see
639 /// [#71117]: https://github.com/rust-lang/rust/issues/71117
641 /// The function that’s being called.
643 /// Arguments the function is called with.
644 /// These are owned by the callee, which is free to modify them.
645 /// This allows the memory occupied by "by-value" arguments to be
646 /// reused across function calls without duplicating the contents.
647 args: Vec<Operand<'tcx>>,
648 /// Where the returned value will be written
649 destination: Place<'tcx>,
650 /// Where to go after this call returns. If none, the call necessarily diverges.
651 target: Option<BasicBlock>,
652 /// Cleanups to be done if the call unwinds.
653 cleanup: Option<BasicBlock>,
654 /// `true` if this is from a call in HIR rather than from an overloaded
655 /// operator. True for overloaded function call.
657 /// This `Span` is the span of the function, without the dot and receiver
658 /// (e.g. `foo(a, b)` in `x.foo(a, b)`
662 /// Evaluates the operand, which must have type `bool`. If it is not equal to `expected`,
663 /// initiates a panic. Initiating a panic corresponds to a `Call` terminator with some
664 /// unspecified constant as the function to call, all the operands stored in the `AssertMessage`
665 /// as parameters, and `None` for the destination. Keep in mind that the `cleanup` path is not
666 /// necessarily executed even in the case of a panic, for example in `-C panic=abort`. If the
667 /// assertion does not fail, execution continues at the specified basic block.
671 msg: AssertMessage<'tcx>,
673 cleanup: Option<BasicBlock>,
676 /// Marks a suspend point.
678 /// Like `Return` terminators in generator bodies, this computes `value` and then a
679 /// `GeneratorState::Yielded(value)` as if by `Aggregate` rvalue. That value is then assigned to
680 /// the return place of the function calling this one, and execution continues in the calling
681 /// function. When next invoked with the same first argument, execution of this function
682 /// continues at the `resume` basic block, with the second argument written to the `resume_arg`
683 /// place. If the generator is dropped before then, the `drop` basic block is invoked.
685 /// Not permitted in bodies that are not generator bodies, or after generator lowering.
687 /// **Needs clarification**: What about the evaluation order of the `resume_arg` and `value`?
689 /// The value to return.
690 value: Operand<'tcx>,
691 /// Where to resume to.
693 /// The place to store the resume argument in.
694 resume_arg: Place<'tcx>,
695 /// Cleanup to be done if the generator is dropped at this suspend point.
696 drop: Option<BasicBlock>,
699 /// Indicates the end of dropping a generator.
701 /// Semantically just a `return` (from the generators drop glue). Only permitted in the same situations
704 /// **Needs clarification**: Is that even correct? The generator drop code is always confusing
705 /// to me, because it's not even really in the current body.
707 /// **Needs clarification**: Are there type system constraints on these terminators? Should
708 /// there be a "block type" like `cleanup` blocks for them?
711 /// A block where control flow only ever takes one real path, but borrowck needs to be more
714 /// At runtime this is semantically just a goto.
716 /// Disallowed after drop elaboration.
718 /// The target normal control flow will take.
719 real_target: BasicBlock,
720 /// A block control flow could conceptually jump to, but won't in
722 imaginary_target: BasicBlock,
725 /// A terminator for blocks that only take one path in reality, but where we reserve the right
726 /// to unwind in borrowck, even if it won't happen in practice. This can arise in infinite loops
727 /// with no function calls for example.
729 /// At runtime this is semantically just a goto.
731 /// Disallowed after drop elaboration.
733 /// The target normal control flow will take.
734 real_target: BasicBlock,
735 /// The imaginary cleanup block link. This particular path will never be taken
736 /// in practice, but in order to avoid fragility we want to always
737 /// consider it in borrowck. We don't want to accept programs which
738 /// pass borrowck only when `panic=abort` or some assertions are disabled
739 /// due to release vs. debug mode builds. This needs to be an `Option` because
740 /// of the `remove_noop_landing_pads` and `abort_unwinding_calls` passes.
741 unwind: Option<BasicBlock>,
744 /// Block ends with an inline assembly block. This is a terminator since
745 /// inline assembly is allowed to diverge.
747 /// The template for the inline assembly, with placeholders.
748 template: &'tcx [InlineAsmTemplatePiece],
750 /// The operands for the inline assembly, as `Operand`s or `Place`s.
751 operands: Vec<InlineAsmOperand<'tcx>>,
753 /// Miscellaneous options for the inline assembly.
754 options: InlineAsmOptions,
756 /// Source spans for each line of the inline assembly code. These are
757 /// used to map assembler errors back to the line in the source code.
758 line_spans: &'tcx [Span],
760 /// Destination block after the inline assembly returns, unless it is
761 /// diverging (InlineAsmOptions::NORETURN).
762 destination: Option<BasicBlock>,
764 /// Cleanup to be done if the inline assembly unwinds. This is present
765 /// if and only if InlineAsmOptions::MAY_UNWIND is set.
766 cleanup: Option<BasicBlock>,
770 /// Information about an assertion failure.
771 #[derive(Clone, TyEncodable, TyDecodable, Hash, HashStable, PartialEq, TypeFoldable, TypeVisitable)]
772 pub enum AssertKind<O> {
773 BoundsCheck { len: O, index: O },
774 Overflow(BinOp, O, O),
778 ResumedAfterReturn(GeneratorKind),
779 ResumedAfterPanic(GeneratorKind),
782 #[derive(Clone, Debug, PartialEq, TyEncodable, TyDecodable, Hash, HashStable)]
783 #[derive(TypeFoldable, TypeVisitable)]
784 pub enum InlineAsmOperand<'tcx> {
786 reg: InlineAsmRegOrRegClass,
787 value: Operand<'tcx>,
790 reg: InlineAsmRegOrRegClass,
792 place: Option<Place<'tcx>>,
795 reg: InlineAsmRegOrRegClass,
797 in_value: Operand<'tcx>,
798 out_place: Option<Place<'tcx>>,
801 value: Box<Constant<'tcx>>,
804 value: Box<Constant<'tcx>>,
811 /// Type for MIR `Assert` terminator error messages.
812 pub type AssertMessage<'tcx> = AssertKind<Operand<'tcx>>;
814 ///////////////////////////////////////////////////////////////////////////
817 /// Places roughly correspond to a "location in memory." Places in MIR are the same mathematical
818 /// object as places in Rust. This of course means that what exactly they are is undecided and part
819 /// of the Rust memory model. However, they will likely contain at least the following pieces of
820 /// information in some form:
822 /// 1. The address in memory that the place refers to.
823 /// 2. The provenance with which the place is being accessed.
824 /// 3. The type of the place and an optional variant index. See [`PlaceTy`][super::tcx::PlaceTy].
825 /// 4. Optionally, some metadata. This exists if and only if the type of the place is not `Sized`.
827 /// We'll give a description below of how all pieces of the place except for the provenance are
828 /// calculated. We cannot give a description of the provenance, because that is part of the
829 /// undecided aliasing model - we only include it here at all to acknowledge its existence.
831 /// Each local naturally corresponds to the place `Place { local, projection: [] }`. This place has
832 /// the address of the local's allocation and the type of the local.
834 /// **Needs clarification:** Unsized locals seem to present a bit of an issue. Their allocation
835 /// can't actually be created on `StorageLive`, because it's unclear how big to make the allocation.
836 /// Furthermore, MIR produces assignments to unsized locals, although that is not permitted under
837 /// `#![feature(unsized_locals)]` in Rust. Besides just putting "unsized locals are special and
838 /// different" in a bunch of places, I (JakobDegen) don't know how to incorporate this behavior into
839 /// the current MIR semantics in a clean way - possibly this needs some design work first.
841 /// For places that are not locals, ie they have a non-empty list of projections, we define the
842 /// values as a function of the parent place, that is the place with its last [`ProjectionElem`]
843 /// stripped. The way this is computed of course depends on the kind of that last projection
846 /// - [`Downcast`](ProjectionElem::Downcast): This projection sets the place's variant index to the
847 /// given one, and makes no other changes. A `Downcast` projection on a place with its variant
848 /// index already set is not well-formed.
849 /// - [`Field`](ProjectionElem::Field): `Field` projections take their parent place and create a
850 /// place referring to one of the fields of the type. The resulting address is the parent
851 /// address, plus the offset of the field. The type becomes the type of the field. If the parent
852 /// was unsized and so had metadata associated with it, then the metadata is retained if the
853 /// field is unsized and thrown out if it is sized.
855 /// These projections are only legal for tuples, ADTs, closures, and generators. If the ADT or
856 /// generator has more than one variant, the parent place's variant index must be set, indicating
857 /// which variant is being used. If it has just one variant, the variant index may or may not be
858 /// included - the single possible variant is inferred if it is not included.
859 /// - [`OpaqueCast`](ProjectionElem::OpaqueCast): This projection changes the place's type to the
860 /// given one, and makes no other changes. A `OpaqueCast` projection on any type other than an
861 /// opaque type from the current crate is not well-formed.
862 /// - [`ConstantIndex`](ProjectionElem::ConstantIndex): Computes an offset in units of `T` into the
863 /// place as described in the documentation for the `ProjectionElem`. The resulting address is
864 /// the parent's address plus that offset, and the type is `T`. This is only legal if the parent
865 /// place has type `[T; N]` or `[T]` (*not* `&[T]`). Since such a `T` is always sized, any
866 /// resulting metadata is thrown out.
867 /// - [`Subslice`](ProjectionElem::Subslice): This projection calculates an offset and a new
868 /// address in a similar manner as `ConstantIndex`. It is also only legal on `[T; N]` and `[T]`.
869 /// However, this yields a `Place` of type `[T]`, and additionally sets the metadata to be the
870 /// length of the subslice.
871 /// - [`Index`](ProjectionElem::Index): Like `ConstantIndex`, only legal on `[T; N]` or `[T]`.
872 /// However, `Index` additionally takes a local from which the value of the index is computed at
873 /// runtime. Computing the value of the index involves interpreting the `Local` as a
874 /// `Place { local, projection: [] }`, and then computing its value as if done via
875 /// [`Operand::Copy`]. The array/slice is then indexed with the resulting value. The local must
876 /// have type `usize`.
877 /// - [`Deref`](ProjectionElem::Deref): Derefs are the last type of projection, and the most
878 /// complicated. They are only legal on parent places that are references, pointers, or `Box`. A
879 /// `Deref` projection begins by loading a value from the parent place, as if by
880 /// [`Operand::Copy`]. It then dereferences the resulting pointer, creating a place of the
881 /// pointee's type. The resulting address is the address that was stored in the pointer. If the
882 /// pointee type is unsized, the pointer additionally stored the value of the metadata.
884 /// Computing a place may cause UB. One possibility is that the pointer used for a `Deref` may not
885 /// be suitably aligned. Another possibility is that the place is not in bounds, meaning it does not
886 /// point to an actual allocation.
888 /// However, if this is actually UB and when the UB kicks in is undecided. This is being discussed
889 /// in [UCG#319]. The options include that every place must obey those rules, that only some places
890 /// must obey them, or that places impose no rules of their own.
892 /// [UCG#319]: https://github.com/rust-lang/unsafe-code-guidelines/issues/319
894 /// Rust currently requires that every place obey those two rules. This is checked by MIRI and taken
895 /// advantage of by codegen (via `gep inbounds`). That is possibly subject to change.
896 #[derive(Copy, Clone, PartialEq, Eq, Hash, TyEncodable, HashStable, TypeFoldable, TypeVisitable)]
897 pub struct Place<'tcx> {
900 /// projection out of a place (access a field, deref a pointer, etc)
901 pub projection: &'tcx List<PlaceElem<'tcx>>,
904 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
905 #[derive(TyEncodable, TyDecodable, HashStable, TypeFoldable, TypeVisitable)]
906 pub enum ProjectionElem<V, T> {
909 /// Index into a slice/array.
911 /// Note that this does not also dereference, and so it does not exactly correspond to slice
912 /// indexing in Rust. In other words, in the below Rust code:
915 /// let x = &[1, 2, 3, 4];
920 /// The `x[i]` is turned into a `Deref` followed by an `Index`, not just an `Index`. The same
921 /// thing is true of the `ConstantIndex` and `Subslice` projections below.
924 /// These indices are generated by slice patterns. Easiest to explain
927 /// ```ignore (illustrative)
928 /// [X, _, .._, _, _] => { offset: 0, min_length: 4, from_end: false },
929 /// [_, X, .._, _, _] => { offset: 1, min_length: 4, from_end: false },
930 /// [_, _, .._, X, _] => { offset: 2, min_length: 4, from_end: true },
931 /// [_, _, .._, _, X] => { offset: 1, min_length: 4, from_end: true },
934 /// index or -index (in Python terms), depending on from_end
936 /// The thing being indexed must be at least this long. For arrays this
937 /// is always the exact length.
939 /// Counting backwards from end? This is always false when indexing an
944 /// These indices are generated by slice patterns.
946 /// If `from_end` is true `slice[from..slice.len() - to]`.
947 /// Otherwise `array[from..to]`.
951 /// Whether `to` counts from the start or end of the array/slice.
952 /// For `PlaceElem`s this is `true` if and only if the base is a slice.
953 /// For `ProjectionKind`, this can also be `true` for arrays.
957 /// "Downcast" to a variant of an enum or a generator.
959 /// The included Symbol is the name of the variant, used for printing MIR.
960 Downcast(Option<Symbol>, VariantIdx),
962 /// Like an explicit cast from an opaque type to a concrete type, but without
963 /// requiring an intermediate variable.
967 /// Alias for projections as they appear in places, where the base is a place
968 /// and the index is a local.
969 pub type PlaceElem<'tcx> = ProjectionElem<Local, Ty<'tcx>>;
971 ///////////////////////////////////////////////////////////////////////////
974 /// An operand in MIR represents a "value" in Rust, the definition of which is undecided and part of
975 /// the memory model. One proposal for a definition of values can be found [on UCG][value-def].
977 /// [value-def]: https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/value-domain.md
979 /// The most common way to create values is via loading a place. Loading a place is an operation
980 /// which reads the memory of the place and converts it to a value. This is a fundamentally *typed*
981 /// operation. The nature of the value produced depends on the type of the conversion. Furthermore,
982 /// there may be other effects: if the type has a validity constraint loading the place might be UB
983 /// if the validity constraint is not met.
985 /// **Needs clarification:** Ralf proposes that loading a place not have side-effects.
986 /// This is what is implemented in miri today. Are these the semantics we want for MIR? Is this
987 /// something we can even decide without knowing more about Rust's memory model?
989 /// **Needs clarifiation:** Is loading a place that has its variant index set well-formed? Miri
990 /// currently implements it, but it seems like this may be something to check against in the
992 #[derive(Clone, PartialEq, TyEncodable, TyDecodable, Hash, HashStable, TypeFoldable, TypeVisitable)]
993 pub enum Operand<'tcx> {
994 /// Creates a value by loading the given place.
996 /// Before drop elaboration, the type of the place must be `Copy`. After drop elaboration there
997 /// is no such requirement.
1000 /// Creates a value by performing loading the place, just like the `Copy` operand.
1002 /// This *may* additionally overwrite the place with `uninit` bytes, depending on how we decide
1003 /// in [UCG#188]. You should not emit MIR that may attempt a subsequent second load of this
1004 /// place without first re-initializing it.
1006 /// [UCG#188]: https://github.com/rust-lang/unsafe-code-guidelines/issues/188
1009 /// Constants are already semantically values, and remain unchanged.
1010 Constant(Box<Constant<'tcx>>),
1013 ///////////////////////////////////////////////////////////////////////////
1016 /// The various kinds of rvalues that can appear in MIR.
1018 /// Not all of these are allowed at every [`MirPhase`] - when this is the case, it's stated below.
1020 /// Computing any rvalue begins by evaluating the places and operands in some order (**Needs
1021 /// clarification**: Which order?). These are then used to produce a "value" - the same kind of
1022 /// value that an [`Operand`] produces.
1023 #[derive(Clone, TyEncodable, TyDecodable, Hash, HashStable, PartialEq, TypeFoldable, TypeVisitable)]
1024 pub enum Rvalue<'tcx> {
1025 /// Yields the operand unchanged
1028 /// Creates an array where each element is the value of the operand.
1030 /// This is the cause of a bug in the case where the repetition count is zero because the value
1031 /// is not dropped, see [#74836].
1033 /// Corresponds to source code like `[x; 32]`.
1035 /// [#74836]: https://github.com/rust-lang/rust/issues/74836
1036 Repeat(Operand<'tcx>, ty::Const<'tcx>),
1038 /// Creates a reference of the indicated kind to the place.
1040 /// There is not much to document here, because besides the obvious parts the semantics of this
1041 /// are essentially entirely a part of the aliasing model. There are many UCG issues discussing
1042 /// exactly what the behavior of this operation should be.
1044 /// `Shallow` borrows are disallowed after drop lowering.
1045 Ref(Region<'tcx>, BorrowKind, Place<'tcx>),
1047 /// Creates a pointer/reference to the given thread local.
1049 /// The yielded type is a `*mut T` if the static is mutable, otherwise if the static is extern a
1050 /// `*const T`, and if neither of those apply a `&T`.
1052 /// **Note:** This is a runtime operation that actually executes code and is in this sense more
1053 /// like a function call. Also, eliminating dead stores of this rvalue causes `fn main() {}` to
1054 /// SIGILL for some reason that I (JakobDegen) never got a chance to look into.
1056 /// **Needs clarification**: Are there weird additional semantics here related to the runtime
1057 /// nature of this operation?
1058 ThreadLocalRef(DefId),
1060 /// Creates a pointer with the indicated mutability to the place.
1062 /// This is generated by pointer casts like `&v as *const _` or raw address of expressions like
1063 /// `&raw v` or `addr_of!(v)`.
1065 /// Like with references, the semantics of this operation are heavily dependent on the aliasing
1067 AddressOf(Mutability, Place<'tcx>),
1069 /// Yields the length of the place, as a `usize`.
1071 /// If the type of the place is an array, this is the array length. For slices (`[T]`, not
1072 /// `&[T]`) this accesses the place's metadata to determine the length. This rvalue is
1073 /// ill-formed for places of other types.
1076 /// Performs essentially all of the casts that can be performed via `as`.
1078 /// This allows for casts from/to a variety of types.
1080 /// **FIXME**: Document exactly which `CastKind`s allow which types of casts. Figure out why
1081 /// `ArrayToPointer` and `MutToConstPointer` are special.
1082 Cast(CastKind, Operand<'tcx>, Ty<'tcx>),
1084 /// * `Offset` has the same semantics as [`offset`](pointer::offset), except that the second
1085 /// parameter may be a `usize` as well.
1086 /// * The comparison operations accept `bool`s, `char`s, signed or unsigned integers, floats,
1087 /// raw pointers, or function pointers and return a `bool`. The types of the operands must be
1088 /// matching, up to the usual caveat of the lifetimes in function pointers.
1089 /// * Left and right shift operations accept signed or unsigned integers not necessarily of the
1090 /// same type and return a value of the same type as their LHS. Like in Rust, the RHS is
1091 /// truncated as needed.
1092 /// * The `Bit*` operations accept signed integers, unsigned integers, or bools with matching
1093 /// types and return a value of that type.
1094 /// * The remaining operations accept signed integers, unsigned integers, or floats with
1095 /// matching types and return a value of that type.
1096 BinaryOp(BinOp, Box<(Operand<'tcx>, Operand<'tcx>)>),
1098 /// Same as `BinaryOp`, but yields `(T, bool)` with a `bool` indicating an error condition.
1100 /// When overflow checking is disabled and we are generating run-time code, the error condition
1101 /// is false. Otherwise, and always during CTFE, the error condition is determined as described
1104 /// For addition, subtraction, and multiplication on integers the error condition is set when
1105 /// the infinite precision result would be unequal to the actual result.
1107 /// For shift operations on integers the error condition is set when the value of right-hand
1108 /// side is greater than or equal to the number of bits in the type of the left-hand side, or
1109 /// when the value of right-hand side is negative.
1111 /// Other combinations of types and operators are unsupported.
1112 CheckedBinaryOp(BinOp, Box<(Operand<'tcx>, Operand<'tcx>)>),
1114 /// Computes a value as described by the operation.
1115 NullaryOp(NullOp, Ty<'tcx>),
1117 /// Exactly like `BinaryOp`, but less operands.
1119 /// Also does two's-complement arithmetic. Negation requires a signed integer or a float;
1120 /// bitwise not requires a signed integer, unsigned integer, or bool. Both operation kinds
1121 /// return a value with the same type as their operand.
1122 UnaryOp(UnOp, Operand<'tcx>),
1124 /// Computes the discriminant of the place, returning it as an integer of type
1125 /// [`discriminant_ty`]. Returns zero for types without discriminant.
1127 /// The validity requirements for the underlying value are undecided for this rvalue, see
1128 /// [#91095]. Note too that the value of the discriminant is not the same thing as the
1129 /// variant index; use [`discriminant_for_variant`] to convert.
1131 /// [`discriminant_ty`]: crate::ty::Ty::discriminant_ty
1132 /// [#91095]: https://github.com/rust-lang/rust/issues/91095
1133 /// [`discriminant_for_variant`]: crate::ty::Ty::discriminant_for_variant
1134 Discriminant(Place<'tcx>),
1136 /// Creates an aggregate value, like a tuple or struct.
1138 /// This is needed because dataflow analysis needs to distinguish
1139 /// `dest = Foo { x: ..., y: ... }` from `dest.x = ...; dest.y = ...;` in the case that `Foo`
1140 /// has a destructor.
1142 /// Disallowed after deaggregation for all aggregate kinds except `Array` and `Generator`. After
1143 /// generator lowering, `Generator` aggregate kinds are disallowed too.
1144 Aggregate(Box<AggregateKind<'tcx>>, Vec<Operand<'tcx>>),
1146 /// Transmutes a `*mut u8` into shallow-initialized `Box<T>`.
1148 /// This is different from a normal transmute because dataflow analysis will treat the box as
1149 /// initialized but its content as uninitialized. Like other pointer casts, this in general
1150 /// affects alias analysis.
1151 ShallowInitBox(Operand<'tcx>, Ty<'tcx>),
1153 /// A CopyForDeref is equivalent to a read from a place at the
1154 /// codegen level, but is treated specially by drop elaboration. When such a read happens, it
1155 /// is guaranteed (via nature of the mir_opt `Derefer` in rustc_mir_transform/src/deref_separator)
1156 /// that the only use of the returned value is a deref operation, immediately
1157 /// followed by one or more projections. Drop elaboration treats this rvalue as if the
1158 /// read never happened and just projects further. This allows simplifying various MIR
1159 /// optimizations and codegen backends that previously had to handle deref operations anywhere
1161 CopyForDeref(Place<'tcx>),
1164 #[derive(Clone, Copy, Debug, PartialEq, Eq, TyEncodable, TyDecodable, Hash, HashStable)]
1166 /// An exposing pointer to address cast. A cast between a pointer and an integer type, or
1167 /// between a function pointer and an integer type.
1168 /// See the docs on `expose_addr` for more details.
1169 PointerExposeAddress,
1170 /// An address-to-pointer cast that picks up an exposed provenance.
1171 /// See the docs on `from_exposed_addr` for more details.
1172 PointerFromExposedAddress,
1173 /// All sorts of pointer-to-pointer casts. Note that reference-to-raw-ptr casts are
1174 /// translated into `&raw mut/const *r`, i.e., they are not actually casts.
1175 Pointer(PointerCast),
1176 /// Cast into a dyn* object.
1186 #[derive(Clone, Debug, PartialEq, Eq, TyEncodable, TyDecodable, Hash, HashStable)]
1187 #[derive(TypeFoldable, TypeVisitable)]
1188 pub enum AggregateKind<'tcx> {
1189 /// The type is of the element
1193 /// The second field is the variant index. It's equal to 0 for struct
1194 /// and union expressions. The fourth field is
1195 /// active field number and is present only for union expressions
1196 /// -- e.g., for a union expression `SomeUnion { c: .. }`, the
1197 /// active field index would identity the field `c`
1198 Adt(DefId, VariantIdx, SubstsRef<'tcx>, Option<UserTypeAnnotationIndex>, Option<usize>),
1200 // Note: We can use LocalDefId since closures and generators a deaggregated
1202 Closure(LocalDefId, SubstsRef<'tcx>),
1203 Generator(LocalDefId, SubstsRef<'tcx>, hir::Movability),
1206 #[derive(Copy, Clone, Debug, PartialEq, Eq, TyEncodable, TyDecodable, Hash, HashStable)]
1208 /// Returns the size of a value of that type
1210 /// Returns the minimum alignment of a type
1214 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
1215 #[derive(HashStable, TyEncodable, TyDecodable, TypeFoldable, TypeVisitable)]
1217 /// The `!` operator for logical inversion
1219 /// The `-` operator for negation
1223 #[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Ord, Eq, Hash)]
1224 #[derive(TyEncodable, TyDecodable, HashStable, TypeFoldable, TypeVisitable)]
1226 /// The `+` operator (addition)
1228 /// The `-` operator (subtraction)
1230 /// The `*` operator (multiplication)
1232 /// The `/` operator (division)
1234 /// Division by zero is UB, because the compiler should have inserted checks
1237 /// The `%` operator (modulus)
1239 /// Using zero as the modulus (second operand) is UB, because the compiler
1240 /// should have inserted checks prior to this.
1242 /// The `^` operator (bitwise xor)
1244 /// The `&` operator (bitwise and)
1246 /// The `|` operator (bitwise or)
1248 /// The `<<` operator (shift left)
1250 /// The offset is truncated to the size of the first operand before shifting.
1252 /// The `>>` operator (shift right)
1254 /// The offset is truncated to the size of the first operand before shifting.
1256 /// The `==` operator (equality)
1258 /// The `<` operator (less than)
1260 /// The `<=` operator (less than or equal to)
1262 /// The `!=` operator (not equal to)
1264 /// The `>=` operator (greater than or equal to)
1266 /// The `>` operator (greater than)
1268 /// The `ptr.offset` operator
1272 // Some nodes are used a lot. Make sure they don't unintentionally get bigger.
1273 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
1276 // tidy-alphabetical-start
1277 static_assert_size!(AggregateKind<'_>, 40);
1278 static_assert_size!(Operand<'_>, 24);
1279 static_assert_size!(Place<'_>, 16);
1280 static_assert_size!(PlaceElem<'_>, 24);
1281 static_assert_size!(Rvalue<'_>, 40);
1282 // tidy-alphabetical-end