Struct InstSimplifyContext 

struct InstSimplifyContext<'a, 'tcx> {
    tcx: TyCtxt<'tcx>,
    local_decls: &'a LocalDecls<'tcx>,
    typing_env: TypingEnv<'tcx>,
}

Fields

tcx: TyCtxt<'tcx>

local_decls: &'a LocalDecls<'tcx>

typing_env: TypingEnv<'tcx>

Implementations

impl<'tcx> InstSimplifyContext<'_, 'tcx>

fn simplify_repeated_aggregate(&self, rvalue: &mut Rvalue<'tcx>)

Transform aggregates like [0, 0, 0, 0, 0] into [0; 5]. GVN can also do this optimization, but GVN is only run at mir-opt-level 2 so having this in InstSimplify helps unoptimized builds.

fn simplify_bool_cmp(&self, rvalue: &mut Rvalue<'tcx>)

Transform boolean comparisons into logical operations.

fn try_eval_bool(&self, a: &Operand<'_>) -> Option<bool>

fn simplify_ref_deref(&self, rvalue: &mut Rvalue<'tcx>)

Transform &(*a) ==> a.

fn simplify_ptr_aggregate(&self, rvalue: &mut Rvalue<'tcx>)

Transform Aggregate(RawPtr, [p, ()]) ==> Cast(PtrToPtr, p).

fn simplify_cast(&self, rvalue: &mut Rvalue<'tcx>)

fn simplify_repeat_once(&self, rvalue: &mut Rvalue<'tcx>)

Simplify [x; 1] to just [x].

fn simplify_primitive_clone( &self, terminator: &mut Terminator<'tcx>, statements: &mut Vec<Statement<'tcx>>, )

fn simplify_size_or_align_of_val( &self, terminator: &mut Terminator<'tcx>, statements: &mut Vec<Statement<'tcx>>, )

Simplify size_of_val and align_of_val if we don’t actually need to look at the value in order to calculate the result:

• For Sized types we can always do this for both,
• For align_of_val::<[T]> we can return align_of::<T>(), since it doesn’t depend on the slice’s length and the elements are sized.

This is here so it can run after inlining, where it’s more useful. (LowerIntrinsics is done in cleanup, before the optimization passes.)

Note that we intentionally just produce the lang item constants so this works on generic types and avoids any risk of layout calculation cycles.

fn simplify_nounwind_call(&self, terminator: &mut Terminator<'tcx>)

fn simplify_intrinsic_assert(&self, terminator: &mut Terminator<'tcx>)

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 48 bytes