Skip to main content

charon_lib/transform/simplify_output/
simplify_constants.rs

1//! The MIR constant expressions lead to a lot of duplication: there are
2//! for instance constant ADTs which duplicate the "regular" aggregated
3//! ADTs in the operands, constant references, etc. This reduces the number
4//! of cases to handle and eases the function translation in Aeneas.
5//!
6//! This pass removes all those occurrences, leaving only primitive constant expressions. It does
7//! so by introducing intermediate statements.
8//!
9//! A small remark about the intermediate statements we introduce for the globals:
10//! we do so because, when evaluating the code in "concrete" mode, it allows to
11//! handle the globals like function calls.
12
13use itertools::Itertools;
14
15use crate::transform::TransformCtx;
16use crate::transform::ctx::{BodyTransformCtx, UllbcPass, UllbcStatementTransformCtx};
17use crate::ullbc_ast::*;
18
19/// Add a global holding `value`, named like the promoted constants of the current item, and return its place.
20/// `ptr_metadata` is the metadata of pointers to the global.
21fn new_promoted_global(
22    ctx: &mut UllbcStatementTransformCtx<'_>,
23    value: ConstantExpr,
24    ptr_metadata: ConstantExpr,
25) -> GlobalDeclRef {
26    let krate = &mut ctx.ctx.translated;
27    let id = ItemId::Fun(*ctx.def_id);
28    let mut name = krate.item_names.get(&id).unwrap().clone();
29    let promoted_count = krate
30        .item_names
31        .values()
32        .filter_map(|n| n.name.split_last())
33        .filter(|(last, prefix)| {
34            matches!(last, PathElem::Builtin(BuiltinPathElem::PromotedConst, _))
35                && *prefix == name.name.as_slice()
36        })
37        .count();
38    let disambiguator = Disambiguator::new(promoted_count);
39    name.name.push(PathElem::Builtin(
40        BuiltinPathElem::PromotedConst,
41        disambiguator,
42    ));
43    let ty = value.ty().clone();
44    let id = krate.global_decls.push_with(|def_id| GlobalDecl {
45        def_id,
46        item_meta: ItemMeta::dummy_public(ctx.span, name.clone(), true, ItemOpacity::Transparent),
47        generics: GenericParams::empty(),
48        ty: ty.clone(),
49        size: Size::from_expr(SizeExpr::size_of(&ty)),
50        align: Size::from_expr(SizeExpr::align_of(&ty)),
51        ptr_metadata,
52        src: GlobalSource::Normal,
53        global_kind: GlobalKind::AnonConst,
54        value,
55    });
56    krate.item_names.insert(id.into(), name);
57    GlobalDeclRef {
58        id,
59        generics: Box::new(GenericArgs::empty()),
60    }
61}
62
63/// If the constant value is a constant ADT, push `Assign::Aggregate` statements
64/// to the vector of statements, that bind new variables to the ADT parts and
65/// the variable assigned to the complete ADT.
66///
67/// Goes fom e.g. `f(T::A(x, y))` to `let a = T::A(x, y); f(a)`.
68/// The function is recursively called on the aggregate fields (e.g. here x and y).
69fn transform_constant_expr(
70    ctx: &mut UllbcStatementTransformCtx<'_>,
71    mut val: ConstantExpr,
72) -> Operand {
73    let rval = match val.kind() {
74        ConstantExprKind::Global(global_ref) => {
75            return Operand::Read(Place::new_global(global_ref.clone(), val.ty().clone()));
76        }
77        ConstantExprKind::PtrNoProvenance(ptr) => {
78            let usize_ty = Ty::mk_usize();
79            let ptr_usize = ConstantExprKind::Integer(IntegerValue::Unsigned(UIntTy::Usize, *ptr));
80            let cast = UnOp::Cast(CastKind::RawPtr(val.ty().clone()));
81            Rvalue::UnaryOp(cast, Operand::Const(ConstantExpr::new(ptr_usize, usize_ty)))
82        }
83        cexpr @ (ConstantExprKind::Ref(gplace, metadata)
84        | ConstantExprKind::Ptr(_, gplace, metadata)) => {
85            let rk = cexpr.as_ptr().map(|(rk, _, _)| *rk);
86            let bval_is_sized = gplace.ty.get_ptr_metadata(ctx.get_crate()).is_none();
87
88            // Peel off the projections, from the outermost one.
89            let mut projs = vec![];
90            let mut base = gplace;
91            while let GlobalPlaceKind::Projection(sub, proj) = &base.kind {
92                projs.push((proj, &base.ty));
93                base = sub;
94            }
95            let mut place = match &base.kind {
96                // We view a vtable at type `()`, so we go through a pointer cast.
97                GlobalPlaceKind::Global(GlobalProvenance::Global(global_ref))
98                    if let Some(decl) = ctx.ctx.translated.global_decls.get(global_ref.id)
99                        && matches!(decl.src, GlobalSource::VTableInstance { .. }) =>
100                {
101                    let decl_ty = decl.ty.clone().substitute(&global_ref.generics);
102                    let vtable = Place::new_global(global_ref.clone(), decl_ty);
103                    let vtable_ptr = ctx.raw_borrow_to_new_var(vtable, RefKind::Shared, None);
104                    let ptr_ty = TyKind::RawPtr(base.ty.clone(), RefKind::Shared).into_ty();
105                    let cast = UnOp::Cast(CastKind::RawPtr(ptr_ty.clone()));
106                    let rval = Rvalue::UnaryOp(cast, Operand::Move(vtable_ptr));
107                    ctx.rval_to_place(rval, ptr_ty).deref()
108                }
109                GlobalPlaceKind::Global(GlobalProvenance::Global(global_ref)) => {
110                    Place::new_global(global_ref.clone(), base.ty.clone())
111                }
112                GlobalPlaceKind::Global(GlobalProvenance::Function(fn_ptr, fn_ptr_ty)) => {
113                    let fn_ptr = ConstantExpr::new(
114                        ConstantExprKind::FnPtr(fn_ptr.clone()),
115                        fn_ptr_ty.clone(),
116                    );
117                    let fn_ptr = transform_constant_expr(ctx, fn_ptr);
118                    let ptr_ty = TyKind::RawPtr(base.ty.clone(), RefKind::Shared).into_ty();
119                    let cast = UnOp::Cast(CastKind::RawPtr(ptr_ty.clone()));
120                    ctx.rval_to_place(Rvalue::UnaryOp(cast, fn_ptr), ptr_ty)
121                        .deref()
122                }
123                GlobalPlaceKind::Global(GlobalProvenance::TypeId(_)) => {
124                    let kind = ConstantExprKind::Opaque("pointer into a `TypeId`".into());
125                    return Operand::Const(ConstantExpr::new(kind, val.ty().clone()));
126                }
127                GlobalPlaceKind::Projection(..) => unreachable!(),
128                // A local can't be unsized, so we put it in a new global
129                GlobalPlaceKind::Value(bval) if !bval_is_sized => {
130                    let meta = match metadata.as_ref().unwrap() {
131                        UnsizingMetadata::Length(meta) | UnsizingMetadata::VTable(_, meta) => meta,
132                        UnsizingMetadata::VTableUpcast(..) | UnsizingMetadata::Unknown => {
133                            unreachable!("unexpected const metadata")
134                        }
135                    };
136                    let global_ref = new_promoted_global(ctx, bval.clone(), meta.clone());
137                    Place::new_global(global_ref, bval.ty().clone())
138                }
139                GlobalPlaceKind::Value(bval) => {
140                    // Recurse on the borrowed value
141                    let bval = transform_constant_expr(ctx, bval.clone());
142
143                    // Evaluate the referenced value
144                    let bval_ty = bval.ty().clone();
145                    ctx.rval_to_place(Rvalue::Use(bval, WithRetag::No), bval_ty)
146                }
147            };
148            for (proj, proj_ty) in projs.into_iter().rev() {
149                let op = |n: IntegerValue| Box::new(Operand::Const(n.to_constant()));
150                let proj = match *proj {
151                    ConstProjectionElem::Field(variant_id, field_id) => {
152                        ProjectionElem::Field(variant_id, field_id)
153                    }
154                    ConstProjectionElem::Index(i) => ProjectionElem::Index {
155                        offset: op(i),
156                        from_end: false,
157                    },
158                    ConstProjectionElem::Subslice { from, to } => ProjectionElem::Subslice {
159                        from: op(from),
160                        to: op(to),
161                        from_end: false,
162                    },
163                    ConstProjectionElem::Offset {
164                        count,
165                        ref ty,
166                        in_bounds,
167                        ref pointee_is_sized,
168                    } => ctx.offset_projection(
169                        *op(count),
170                        ty.as_ref(),
171                        in_bounds,
172                        proj_ty.clone(),
173                        pointee_is_sized.clone(),
174                    ),
175                };
176                place = place.project(proj, proj_ty.clone());
177            }
178            // A sized place is unsized after being borrowed, if there's metadata.
179            let mut rval = match (rk, metadata.clone().filter(|_| bval_is_sized)) {
180                // Borrow the place.
181                (None, None) => ctx.borrow(place, BorrowKind::Shared),
182                (Some(rk), None) => ctx.raw_borrow(place, rk),
183                // Unsizing borrow.
184                (None, Some(metadata)) => {
185                    let sized_ref = ctx.borrow_to_new_var(place, BorrowKind::Shared, None);
186                    Rvalue::UnaryOp(
187                        UnOp::Cast(CastKind::Unsize(val.ty().clone(), metadata, vec![])),
188                        Operand::Move(sized_ref),
189                    )
190                }
191                (Some(rk), Some(metadata)) => {
192                    let sized_raw_ref = ctx.raw_borrow_to_new_var(place, rk, None);
193                    Rvalue::UnaryOp(
194                        UnOp::Cast(CastKind::Unsize(val.ty().clone(), metadata, vec![])),
195                        Operand::Move(sized_raw_ref),
196                    )
197                }
198            };
199            // The metadata of an unsized global may be a vtable reference, which we lower too.
200            if let Rvalue::Ref { ptr_metadata, .. } | Rvalue::RawPtr { ptr_metadata, .. } =
201                &mut rval
202            {
203                transform_operand(ctx, ptr_metadata);
204            }
205            rval
206        }
207        ConstantExprKind::Adt(..) if val.ty().is_unit() => {
208            // Keep unit constants to avoid adding countless unit locals.
209            return Operand::Const(val);
210        }
211        ConstantExprKind::Adt(variant, fields) => {
212            let fields = fields
213                .iter()
214                .cloned()
215                .map(|x| transform_constant_expr(ctx, x))
216                .collect();
217
218            // Build an `Aggregate` rvalue.
219            let tref = val.ty().kind().as_adt().unwrap();
220            let aggregate_kind = AggregateKind::Adt(tref.clone(), *variant, None);
221            Rvalue::Aggregate(aggregate_kind, fields)
222        }
223        ConstantExprKind::Array(fields)
224            if let TyKind::Array(ty, _, ty_is_sized) = val.ty().kind() =>
225        {
226            let fields = fields
227                .iter()
228                .cloned()
229                .map(|x| transform_constant_expr(ctx, x))
230                .collect_vec();
231            let len = ConstantExpr::mk_usize(fields.len() as u128);
232            Rvalue::Aggregate(
233                AggregateKind::Array(ty.clone(), len, ty_is_sized.clone()),
234                fields,
235            )
236        }
237        ConstantExprKind::Cast(value, kind) => {
238            let value = transform_constant_expr(ctx, value.clone());
239            if let TyKind::Ref(_, pointee, rk) = val.ty().kind() {
240                // Cast to the corresponding raw pointer, then reborrow it as a reference.
241                let raw_ty = TyKind::RawPtr(pointee.clone(), *rk).into_ty();
242                let mut kind = kind.clone();
243                match &mut kind {
244                    CastKind::RawPtr(tgt) | CastKind::Unsize(tgt, ..) => *tgt = raw_ty.clone(),
245                    _ => unreachable!("unexpected cast to a reference: {kind:?}"),
246                }
247                let raw_ptr = ctx.rval_to_place(Rvalue::UnaryOp(UnOp::Cast(kind), value), raw_ty);
248                ctx.borrow(raw_ptr.deref(), (*rk).into())
249            } else {
250                Rvalue::UnaryOp(UnOp::Cast(kind.clone()), value)
251            }
252        }
253        ConstantExprKind::VTableRef(tref)
254            if let Some(vtable_ref) = tref.vtable_ref(&ctx.ctx.translated)
255                && let TyKind::Ref(_, vtable_ty, _) = val.ty().kind() =>
256        {
257            let inner = GlobalPlace::new_global(vtable_ref.clone(), vtable_ty.clone());
258            val.with_contents_mut(|kind, _| *kind = ConstantExprKind::Ref(inner, None));
259            // Normalize further into a place access.
260            return transform_constant_expr(ctx, val);
261        }
262        _ => return Operand::Const(val),
263    };
264    Operand::Move(ctx.rval_to_place(rval, val.ty().clone()))
265}
266
267fn transform_operand(ctx: &mut UllbcStatementTransformCtx<'_>, op: &mut Operand) {
268    // Transform the constant operands (otherwise do nothing)
269    take_mut::take(op, |op| {
270        if let Operand::Const(val) = op {
271            transform_constant_expr(ctx, val)
272        } else {
273            op
274        }
275    })
276}
277
278pub struct Transform;
279impl UllbcPass for Transform {
280    fn should_run(&self, options: &crate::options::TranslateOptions) -> bool {
281        !options.raw_consts
282    }
283
284    fn transform_function(&self, ctx: &mut TransformCtx, fun_decl: &mut FunDecl) {
285        fun_decl.transform_ullbc_statements(ctx, |ctx, st| {
286            let assigns_const = matches!(
287                st.kind,
288                StatementKind::Assign(_, Rvalue::Use(Operand::Const(_), _))
289            );
290            st.kind
291                .dyn_visit_in_body_mut(|op: &mut Operand| transform_operand(ctx, op));
292            // If we turned `x = const c` into `tmp = rval; x = move tmp`, assign `rval` directly.
293            if assigns_const
294                && let StatementKind::Assign(_, rval) = &mut st.kind
295                && let Rvalue::Use(Operand::Move(tmp), _) = rval
296                && let Some(last) = ctx.statements.last()
297                && let StatementKind::Assign(last_dest, last_rval) = &last.kind
298                && last_dest == tmp
299            {
300                *rval = last_rval.clone();
301                ctx.statements.pop();
302            }
303        });
304        fun_decl.transform_ullbc_terminators(ctx, |ctx, term| {
305            term.kind
306                .dyn_visit_in_body_mut(|op: &mut Operand| transform_operand(ctx, op));
307        });
308        if let Some(body) = fun_decl.body.as_unstructured_mut() {
309            for block in body.body.iter_mut() {
310                // Normalize unit constants into unit aggregates.
311                block.dyn_visit_in_body_mut(|rvalue: &mut Rvalue| {
312                    take_mut::take(rvalue, |rvalue| match rvalue {
313                        Rvalue::Use(Operand::Const(e), _)
314                            if e.kind().is_adt() && e.ty().is_unit() =>
315                        {
316                            Rvalue::unit_value()
317                        }
318                        _ => rvalue,
319                    });
320                });
321            }
322        }
323    }
324}