1use itertools::Itertools;
14
15use crate::transform::TransformCtx;
16use crate::transform::ctx::{BodyTransformCtx, UllbcPass, UllbcStatementTransformCtx};
17use crate::ullbc_ast::*;
18
19fn 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
63fn 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 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 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 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 let bval = transform_constant_expr(ctx, bval.clone());
142
143 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 let mut rval = match (rk, metadata.clone().filter(|_| bval_is_sized)) {
180 (None, None) => ctx.borrow(place, BorrowKind::Shared),
182 (Some(rk), None) => ctx.raw_borrow(place, rk),
183 (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 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 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 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 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 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 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 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 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}