charon_lib/transform/
simplify_constants.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
//! The MIR constant expressions lead to a lot of duplication: there are
//! for instance constant ADTs which duplicate the "regular" aggregated
//! ADTs in the operands, constant references, etc. This reduces the number
//! of cases to handle and eases the function translation in Aeneas.
//!
//! This pass removes all those occurrences so that only the
//! [ConstantExpression::Literal]. It does so by introducing intermediate statements.
//!
//! A small remark about the intermediate statements we introduce for the globals:
//! we do so because, when evaluating the code in "concrete" mode, it allows to
//! handle the globals like function calls.

use crate::transform::TransformCtx;
use crate::ullbc_ast::*;

use super::ctx::UllbcPass;

/// If the constant value is a constant ADT, push `Assign::Aggregate` statements
/// to the vector of statements, that bind new variables to the ADT parts and
/// the variable assigned to the complete ADT.
///
/// Goes fom e.g. `f(T::A(x, y))` to `let a = T::A(x, y); f(a)`.
/// The function is recursively called on the aggregate fields (e.g. here x and y).
fn transform_constant_expr<F: FnMut(Ty) -> Place>(
    span: &Span,
    nst: &mut Vec<Statement>,
    val: ConstantExpr,
    make_new_var: &mut F,
) -> Operand {
    match val.value {
        RawConstantExpr::Literal(_)
        | RawConstantExpr::Var(_)
        | RawConstantExpr::TraitConst(..)
        | RawConstantExpr::FnPtr(..) => {
            // Nothing to do
            // TODO: for trait const: might come from a top-level impl, so we might
            // want to introduce an intermediate statement to be able to evaluate
            // it as a function call, like for globals.
            Operand::Const(val)
        }
        RawConstantExpr::Global(global_ref) => {
            // Introduce an intermediate statement
            let var = make_new_var(val.ty.clone());
            nst.push(Statement::new(
                *span,
                RawStatement::Assign(var.clone(), Rvalue::Global(global_ref)),
            ));
            Operand::Move(var)
        }
        RawConstantExpr::Ref(box bval) => {
            match bval.value {
                RawConstantExpr::Global(global_ref) => {
                    // Introduce an intermediate statement to borrow the static.
                    let ref_var = make_new_var(val.ty);
                    nst.push(Statement::new(
                        *span,
                        RawStatement::Assign(
                            ref_var.clone(),
                            Rvalue::GlobalRef(global_ref, RefKind::Shared),
                        ),
                    ));

                    // Return the new operand
                    Operand::Move(ref_var)
                }
                _ => {
                    // Recurse on the borrowed value
                    let bval_ty = bval.ty.clone();
                    let bval = transform_constant_expr(span, nst, bval, make_new_var);

                    // Introduce an intermediate statement to evaluate the referenced value
                    let bvar = make_new_var(bval_ty);
                    nst.push(Statement::new(
                        *span,
                        RawStatement::Assign(bvar.clone(), Rvalue::Use(bval)),
                    ));

                    // Introduce an intermediate statement to borrow the value
                    let ref_var = make_new_var(val.ty);
                    let rvalue = Rvalue::Ref(bvar, BorrowKind::Shared);
                    nst.push(Statement::new(
                        *span,
                        RawStatement::Assign(ref_var.clone(), rvalue),
                    ));

                    // Return the new operand
                    Operand::Move(ref_var)
                }
            }
        }
        RawConstantExpr::MutPtr(box bval) => {
            match bval.value {
                RawConstantExpr::Global(global_ref) => {
                    // Introduce an intermediate statement to borrow the static.
                    let ref_var = make_new_var(val.ty);
                    nst.push(Statement::new(
                        *span,
                        RawStatement::Assign(
                            ref_var.clone(),
                            Rvalue::GlobalRef(global_ref, RefKind::Mut),
                        ),
                    ));

                    // Return the new operand
                    Operand::Move(ref_var)
                }
                _ => {
                    // Recurse on the borrowed value
                    let bval_ty = bval.ty.clone();
                    let bval = transform_constant_expr(span, nst, bval, make_new_var);

                    // Introduce an intermediate statement to evaluate the referenced value
                    let bvar = make_new_var(bval_ty);
                    nst.push(Statement::new(
                        *span,
                        RawStatement::Assign(bvar.clone(), Rvalue::Use(bval)),
                    ));

                    // Introduce an intermediate statement to borrow the value
                    let ref_var = make_new_var(val.ty);
                    let rvalue = Rvalue::RawPtr(bvar, RefKind::Mut);
                    nst.push(Statement::new(
                        *span,
                        RawStatement::Assign(ref_var.clone(), rvalue),
                    ));

                    // Return the new operand
                    Operand::Move(ref_var)
                }
            }
        }
        RawConstantExpr::Adt(variant, fields) => {
            // Recurse on the fields
            let fields = fields
                .into_iter()
                .map(|f| transform_constant_expr(span, nst, f, make_new_var))
                .collect();

            // Introduce an intermediate assignment for the aggregated ADT
            let rval = {
                let (adt_kind, generics) = val.ty.kind().as_adt().unwrap();
                let aggregate_kind = AggregateKind::Adt(*adt_kind, variant, None, generics.clone());
                Rvalue::Aggregate(aggregate_kind, fields)
            };
            let var = make_new_var(val.ty);
            nst.push(Statement::new(
                *span,
                RawStatement::Assign(var.clone(), rval),
            ));

            // Return the new operand
            Operand::Move(var)
        }
    }
}

fn transform_operand<F: FnMut(Ty) -> Place>(
    span: &Span,
    nst: &mut Vec<Statement>,
    op: &mut Operand,
    f: &mut F,
) {
    // Transform the constant operands (otherwise do nothing)
    take_mut::take(op, |op| {
        if let Operand::Const(val) = op {
            transform_constant_expr(span, nst, val, f)
        } else {
            op
        }
    })
}

pub struct Transform;
impl UllbcPass for Transform {
    fn transform_body(&self, _ctx: &mut TransformCtx<'_>, b: &mut ExprBody) {
        let mut f = |ty| b.locals.new_var(None, ty);
        body_transform_operands(&mut b.body, &mut |span, nst, op| {
            transform_operand(span, nst, op, &mut f)
        });
    }
}