bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

deduplicate a lot of code

Browse source
This commit is contained in:
b-naber 2022-04-21 19:35:06 +02:00
parent 28af967bb9
commit bc698c73e9
6 changed files with 119 additions and 244 deletions
Download patch file Download diff file Expand all files Collapse all files

333
compiler/rustc_const_eval/src/const_eval/valtrees.rs
View file

@ -2,16 +2,16 @@ use super::eval_queries::{mk_eval_cx, op_to_const};
use super::machine::CompileTimeEvalContext;
use crate::interpret::{
intern_const_alloc_recursive, ConstValue, ImmTy, Immediate, InternKind, MemoryKind, PlaceTy,
Pointer, Scalar, ScalarMaybeUninit,
Scalar, ScalarMaybeUninit,
};
use rustc_middle::mir::interpret::{ConstAlloc, GlobalAlloc};
use rustc_middle::mir::interpret::ConstAlloc;
use rustc_middle::mir::{Field, ProjectionElem};
use rustc_middle::ty::{self, ScalarInt, Ty, TyCtxt};
use rustc_span::source_map::DUMMY_SP;
use rustc_target::abi::VariantIdx;
use crate::interpret::visitor::Value;
use crate::interpret::MPlaceTy;
use crate::interpret::Value;
/// Convert an evaluated constant to a type level constant
#[instrument(skip(tcx), level = "debug")]
@ -54,6 +54,7 @@ fn branches<'tcx>(
Some(ty::ValTree::Branch(ecx.tcx.arena.alloc_from_iter(branches.collect::<Option<Vec<_>>>()?)))
}
#[instrument(skip(ecx), level = "debug")]
fn slice_branches<'tcx>(
ecx: &CompileTimeEvalContext<'tcx, 'tcx>,
place: &MPlaceTy<'tcx>,
@ -139,15 +140,44 @@ fn const_to_valtree_inner<'tcx>(
#[instrument(skip(ecx), level = "debug")]
fn create_mplace_from_layout<'tcx>(
ecx: &mut CompileTimeEvalContext<'tcx, 'tcx>,
param_env_ty: ty::ParamEnvAnd<'tcx, Ty<'tcx>>,
ty: Ty<'tcx>,
) -> MPlaceTy<'tcx> {
let tcx = ecx.tcx;
let layout = tcx.layout_of(param_env_ty).unwrap();
let param_env = ecx.param_env;
let layout = tcx.layout_of(param_env.and(ty)).unwrap();
debug!(?layout);
ecx.allocate(layout, MemoryKind::Stack).unwrap()
}
#[instrument(skip(ecx), level = "debug")]
fn create_pointee_place<'tcx>(
ecx: &mut CompileTimeEvalContext<'tcx, 'tcx>,
ty: Ty<'tcx>,
valtree: ty::ValTree<'tcx>,
) -> MPlaceTy<'tcx> {
let tcx = ecx.tcx.tcx;
match ty.kind() {
ty::Slice(_) | ty::Str => {
let slice_ty = match ty.kind() {
ty::Slice(slice_ty) => *slice_ty,
ty::Str => tcx.mk_ty(ty::Uint(ty::UintTy::U8)),
_ => bug!("expected ty::Slice | ty::Str"),
};
// Create a place for the underlying array
let len = valtree.unwrap_branch().len() as u64;
let arr_ty = tcx.mk_array(slice_ty, len as u64);
let place = create_mplace_from_layout(ecx, arr_ty);
debug!(?place);
place
}
_ => create_mplace_from_layout(ecx, ty),
}
}
/// Converts a `ValTree` to a `ConstValue`, which is needed after mir
/// construction has finished.
#[instrument(skip(tcx), level = "debug")]
@ -174,96 +204,28 @@ pub fn valtree_to_const_value<'tcx>(
),
},
ty::Ref(_, inner_ty, _) => {
match inner_ty.kind() {
ty::Slice(_) | ty::Str => {
let slice_ty = match inner_ty.kind() {
ty::Slice(slice_ty) => *slice_ty,
ty::Str => tcx.mk_ty(ty::Uint(ty::UintTy::U8)),
_ => bug!("expected ty::Slice | ty::Str"),
};
debug!(?slice_ty);
// create a place for the pointee
let mut pointee_place = create_pointee_place(&mut ecx, *inner_ty, valtree);
debug!(?pointee_place);
let valtrees = valtree.unwrap_branch();
// insert elements of valtree into `place`
fill_place_recursively(&mut ecx, &mut pointee_place, valtree);
dump_place(&ecx, pointee_place.into());
intern_const_alloc_recursive(&mut ecx, InternKind::Constant, &pointee_place).unwrap();
// Create a place for the underlying array
let len = valtrees.len();
let arr_ty = tcx.mk_array(slice_ty, len as u64);
let mut place =
create_mplace_from_layout(&mut ecx, ty::ParamEnv::empty().and(arr_ty));
debug!(?place);
let ref_place = pointee_place.to_ref(&tcx);
let imm = ImmTy::from_immediate(ref_place, tcx.layout_of(param_env_ty).unwrap());
// Insert elements of `arr_valtree` into `place`
fill_place_recursively(&mut ecx, &mut place, valtree, arr_ty);
dump_place(&ecx, place.into());
let const_val = op_to_const(&ecx, &imm.into());
debug!(?const_val);
// The allocation behind `place` is local, we need to intern it
intern_const_alloc_recursive(&mut ecx, InternKind::Constant, &place).unwrap();
// Now we need to get the Allocation
let alloc_id = place.mplace.ptr.provenance.unwrap();
debug!(?alloc_id);
let data = match tcx.get_global_alloc(alloc_id) {
Some(GlobalAlloc::Memory(const_alloc)) => const_alloc,
_ => bug!("expected memory allocation"),
};
debug!(?data);
return ConstValue::Slice { data, start: 0, end: len as usize };
}
_ => {
match valtree {
ty::ValTree::Branch(_) => {
// create a place for the pointee
let mut place = create_mplace_from_layout(
&mut ecx,
ty::ParamEnv::empty().and(*inner_ty),
);
debug!(?place);
// insert elements of valtree into `place`
fill_place_recursively(&mut ecx, &mut place, valtree, *inner_ty);
dump_place(&ecx, place.into());
intern_const_alloc_recursive(&mut ecx, InternKind::Constant, &place)
.unwrap();
let ref_place = place.mplace.to_ref(&tcx);
let imm = ImmTy::from_immediate(
ref_place,
tcx.layout_of(param_env_ty).unwrap(),
);
let const_val = op_to_const(&ecx, &imm.into());
debug!(?const_val);
const_val
}
ty::ValTree::Leaf(_) => {
let mut place = create_mplace_from_layout(
&mut ecx,
ty::ParamEnv::empty().and(*inner_ty),
);
fill_place_recursively(&mut ecx, &mut place, valtree, *inner_ty);
dump_place(&ecx, place.into());
let ref_place = place.mplace.to_ref(&tcx);
let imm = ImmTy::from_immediate(
ref_place,
tcx.layout_of(param_env_ty).unwrap(),
);
op_to_const(&ecx, &imm.into())
}
}
}
}
const_val
}
ty::Tuple(_) | ty::Array(_, _) | ty::Adt(..) => {
let mut place = create_mplace_from_layout(&mut ecx, param_env_ty);
let mut place = create_mplace_from_layout(&mut ecx, ty);
debug!(?place);
fill_place_recursively(&mut ecx, &mut place, valtree, ty);
fill_place_recursively(&mut ecx, &mut place, valtree);
dump_place(&ecx, place.into());
intern_const_alloc_recursive(&mut ecx, InternKind::Constant, &place).unwrap();
@ -301,12 +263,12 @@ fn fill_place_recursively<'tcx>(
ecx: &mut CompileTimeEvalContext<'tcx, 'tcx>,
place: &mut MPlaceTy<'tcx>,
valtree: ty::ValTree<'tcx>,
ty: Ty<'tcx>,
) {
// This will match on valtree and write the value(s) corresponding to the ValTree
// inside the place recursively.
let tcx = ecx.tcx.tcx;
let ty = place.layout.ty;
match ty.kind() {
ty::Bool | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Char => {
@ -319,161 +281,90 @@ fn fill_place_recursively<'tcx>(
.unwrap();
}
ty::Ref(_, inner_ty, _) => {
match inner_ty.kind() {
let mut pointee_place = create_pointee_place(ecx, *inner_ty, valtree);
debug!(?pointee_place);
fill_place_recursively(ecx, &mut pointee_place, valtree);
dump_place(ecx, pointee_place.into());
intern_const_alloc_recursive(ecx, InternKind::Constant, &pointee_place).unwrap();
let imm = match inner_ty.kind() {
ty::Slice(_) | ty::Str => {
let slice_ty = match inner_ty.kind() {
ty::Slice(slice_ty) => *slice_ty,
ty::Str => tcx.mk_ty(ty::Uint(ty::UintTy::U8)),
_ => bug!("expected ty::Slice | ty::Str"),
};
debug!(?slice_ty);
let valtrees = valtree.unwrap_branch();
debug!(?valtrees);
let len = valtrees.len();
debug!(?len);
// create a place for the underlying array
let arr_ty = tcx.mk_array(slice_ty, len as u64);
let mut arr_place =
create_mplace_from_layout(ecx, ty::ParamEnv::empty().and(arr_ty));
debug!(?arr_place);
// Insert elements of `arr_valtree` into `place`
fill_place_recursively(ecx, &mut arr_place, valtree, arr_ty);
dump_place(&ecx, arr_place.into());
// Now we need to create a `ScalarPair` from the filled `place`
// and write that into `place`
let (alloc_id, offset) = arr_place.mplace.ptr.into_parts();
debug!(?alloc_id, ?offset);
let unwrapped_ptr = Pointer { offset, provenance: alloc_id.unwrap() };
let len = valtree.unwrap_branch().len();
let len_scalar = ScalarMaybeUninit::Scalar(Scalar::from_u64(len as u64));
let imm = Immediate::ScalarPair(
ScalarMaybeUninit::from_pointer(unwrapped_ptr, &tcx),
Immediate::ScalarPair(
ScalarMaybeUninit::from_maybe_pointer((*pointee_place).ptr, &tcx),
len_scalar,
);
debug!(?imm);
// Now write the ScalarPair into the original place we wanted to fill
// in this call
let _ = ecx.write_immediate(imm, &(*place).into()).unwrap();
dump_place(&ecx, (*place).into());
)
}
_ => {
let mut pointee_place =
create_mplace_from_layout(ecx, ty::ParamEnv::empty().and(*inner_ty));
debug!(?pointee_place);
fill_place_recursively(ecx, &mut pointee_place, valtree, *inner_ty);
_ => pointee_place.to_ref(&tcx),
};
debug!(?imm);
dump_place(ecx, pointee_place.into());
intern_const_alloc_recursive(ecx, InternKind::Constant, &pointee_place)
.unwrap();
let imm = pointee_place.mplace.to_ref(&tcx);
debug!(?imm);
ecx.write_immediate(imm, &(*place).into()).unwrap();
}
}
ecx.write_immediate(imm, &(*place).into()).unwrap();
}
ty::Tuple(tuple_types) => {
ty::Adt(_, _) | ty::Tuple(_) | ty::Array(_, _) | ty::Str => {
let branches = valtree.unwrap_branch();
assert_eq!(tuple_types.len(), branches.len());
// Need to downcast place for enums
let (place_adjusted, branches, variant_idx) = match ty.kind() {
ty::Adt(def, _) if def.is_enum() => {
// First element of valtree corresponds to variant
let scalar_int = branches[0].unwrap_leaf();
let variant_idx = VariantIdx::from_u32(scalar_int.try_to_u32().unwrap());
let variant = def.variant(variant_idx);
debug!(?variant);
(
place.project_downcast(ecx, variant_idx).unwrap(),
&branches[1..],
Some(variant_idx),
)
}
_ => (*place, branches, None),
};
debug!(?place_adjusted, ?branches);
// Create the places for the fields and fill them recursively
for (i, inner_valtree) in branches.iter().enumerate() {
debug!(?i, ?inner_valtree);
let inner_ty = tuple_types.get(i).expect(&format!(
"expected to be able to index at position {} into {:?}",
i, tuple_types
));
debug!(?inner_ty);
// Create the mplace for the tuple element
let mut place_inner = ecx.mplace_field(place, i).unwrap();
let mut place_inner = match *ty.kind() {
ty::Adt(def, substs) if !def.is_enum() => {
let field = &def.variant(VariantIdx::from_usize(0)).fields[i];
let field_ty = field.ty(tcx, substs);
let projection_elem = ProjectionElem::Field(Field::from_usize(i), field_ty);
ecx.mplace_projection(&place_adjusted, projection_elem).unwrap()
}
ty::Adt(_, _) | ty::Tuple(_) => ecx.mplace_field(&place_adjusted, i).unwrap(),
ty::Array(_, _) | ty::Str => {
ecx.mplace_index(&place_adjusted, i as u64).unwrap()
}
_ => bug!(),
};
debug!(?place_inner);
// insert valtree corresponding to tuple element into place
fill_place_recursively(ecx, &mut place_inner, *inner_valtree, *inner_ty);
}
}
ty::Array(inner_ty, _) => {
let inner_valtrees = valtree.unwrap_branch();
for (i, inner_valtree) in inner_valtrees.iter().enumerate() {
debug!(?i, ?inner_valtree);
let mut place_inner = ecx.mplace_field(place, i).unwrap();
debug!(?place_inner);
fill_place_recursively(ecx, &mut place_inner, *inner_valtree, *inner_ty)
}
}
ty::Adt(def, substs) if def.is_enum() => {
debug!("enum, substs: {:?}", substs);
let inner_valtrees = valtree.unwrap_branch();
// First element of valtree corresponds to variant
let scalar_int = inner_valtrees[0].unwrap_leaf();
let variant_idx = VariantIdx::from_u32(scalar_int.try_to_u32().unwrap());
let variant = def.variant(variant_idx);
debug!(?variant);
// Need to downcast place
let place_downcast = place.project_downcast(ecx, variant_idx).unwrap();
debug!(?place_downcast);
// fill `place_downcast` with the valtree elements corresponding to
// the fields of the enum
let fields = &variant.fields;
let inner_valtrees = &inner_valtrees[1..];
for (i, field) in fields.iter().enumerate() {
debug!(?i, ?field);
let field_ty = field.ty(tcx, substs);
debug!(?field_ty);
let mut field_mplace = ecx.mplace_field(&place_downcast, i).unwrap();
debug!(?field_mplace);
let inner_valtree = inner_valtrees[i];
fill_place_recursively(ecx, &mut field_mplace, inner_valtree, field_ty);
dump_place(&ecx, field_mplace.into());
fill_place_recursively(ecx, &mut place_inner, *inner_valtree);
dump_place(&ecx, place_inner.into());
}
debug!("dump of place_downcast");
dump_place(ecx, place_downcast.into());
debug!("dump of place_adjusted:");
dump_place(ecx, place_adjusted.into());
if let Some(variant_idx) = variant_idx {
// don't forget filling the place with the discriminant of the enum
ecx.write_discriminant(variant_idx, &(*place).into()).unwrap();
}
// don't forget filling the place with the discriminant of the enum
ecx.write_discriminant(variant_idx, &(*place).into()).unwrap();
dump_place(ecx, (*place).into());
}
ty::Adt(def, substs) => {
debug!("Adt def: {:?} with substs: {:?}", def, substs);
let inner_valtrees = valtree.unwrap_branch();
debug!(?inner_valtrees);
let (fields, inner_valtrees) =
(&def.variant(VariantIdx::from_usize(0)).fields[..], inner_valtrees);
debug!("fields: {:?}", fields);
for (i, field) in fields.iter().enumerate() {
let field_ty = field.ty(tcx, substs);
debug!(?field_ty);
let old_field_ty = tcx.type_of(field.did);
debug!(?old_field_ty);
let projection_elem = ProjectionElem::Field(Field::from_usize(i), field_ty);
let mut field_place = ecx.mplace_projection(place, projection_elem).unwrap();
let inner_valtree = inner_valtrees[i];
fill_place_recursively(ecx, &mut field_place, inner_valtree, field_ty);
}
}
_ => {}
_ => bug!("shouldn't have created a ValTree for {:?}", ty),
}
}
fn dump_place<'tcx>(ecx: &CompileTimeEvalContext<'tcx, 'tcx>, place: PlaceTy<'tcx>) {
trace!("{:?}", ecx.dump_place(place.place));
trace!("{:?}", ecx.dump_place(*place));
}