138 lines
4.7 KiB
Rust
138 lines
4.7 KiB
Rust
use rustc_ast::Attribute;
|
|
use rustc_hir::def::DefKind;
|
|
use rustc_hir::def_id::LocalDefId;
|
|
use rustc_middle::ty::layout::{HasParamEnv, HasTyCtxt, LayoutError, LayoutOfHelpers, TyAndLayout};
|
|
use rustc_middle::ty::{ParamEnv, Ty, TyCtxt};
|
|
use rustc_span::source_map::Spanned;
|
|
use rustc_span::symbol::sym;
|
|
use rustc_span::Span;
|
|
use rustc_target::abi::{HasDataLayout, TargetDataLayout};
|
|
|
|
use crate::errors::{Abi, Align, HomogeneousAggregate, LayoutOf, Size, UnrecognizedField};
|
|
|
|
pub fn test_layout(tcx: TyCtxt<'_>) {
|
|
if tcx.features().rustc_attrs {
|
|
// if the `rustc_attrs` feature is not enabled, don't bother testing layout
|
|
for id in tcx.hir().items() {
|
|
if matches!(
|
|
tcx.def_kind(id.owner_id),
|
|
DefKind::TyAlias | DefKind::Enum | DefKind::Struct | DefKind::Union
|
|
) {
|
|
for attr in tcx.get_attrs(id.owner_id.to_def_id(), sym::rustc_layout) {
|
|
dump_layout_of(tcx, id.owner_id.def_id, attr);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn dump_layout_of(tcx: TyCtxt<'_>, item_def_id: LocalDefId, attr: &Attribute) {
|
|
let tcx = tcx;
|
|
let param_env = tcx.param_env(item_def_id);
|
|
let ty = tcx.type_of(item_def_id).subst_identity();
|
|
match tcx.layout_of(param_env.and(ty)) {
|
|
Ok(ty_layout) => {
|
|
// Check out the `#[rustc_layout(..)]` attribute to tell what to dump.
|
|
// The `..` are the names of fields to dump.
|
|
let meta_items = attr.meta_item_list().unwrap_or_default();
|
|
for meta_item in meta_items {
|
|
match meta_item.name_or_empty() {
|
|
sym::abi => {
|
|
tcx.sess.emit_err(Abi {
|
|
span: tcx.def_span(item_def_id.to_def_id()),
|
|
abi: format!("{:?}", ty_layout.abi),
|
|
});
|
|
}
|
|
|
|
sym::align => {
|
|
tcx.sess.emit_err(Align {
|
|
span: tcx.def_span(item_def_id.to_def_id()),
|
|
align: format!("{:?}", ty_layout.align),
|
|
});
|
|
}
|
|
|
|
sym::size => {
|
|
tcx.sess.emit_err(Size {
|
|
span: tcx.def_span(item_def_id.to_def_id()),
|
|
size: format!("{:?}", ty_layout.size),
|
|
});
|
|
}
|
|
|
|
sym::homogeneous_aggregate => {
|
|
tcx.sess.emit_err(HomogeneousAggregate {
|
|
span: tcx.def_span(item_def_id.to_def_id()),
|
|
homogeneous_aggregate: format!(
|
|
"{:?}",
|
|
ty_layout.homogeneous_aggregate(&UnwrapLayoutCx { tcx, param_env })
|
|
),
|
|
});
|
|
}
|
|
|
|
sym::debug => {
|
|
let normalized_ty = format!(
|
|
"{:?}",
|
|
tcx.normalize_erasing_regions(
|
|
param_env.with_reveal_all_normalized(tcx),
|
|
ty,
|
|
)
|
|
);
|
|
let ty_layout = format!("{:#?}", *ty_layout);
|
|
tcx.sess.emit_err(LayoutOf {
|
|
span: tcx.def_span(item_def_id.to_def_id()),
|
|
normalized_ty,
|
|
ty_layout,
|
|
});
|
|
}
|
|
|
|
name => {
|
|
tcx.sess.emit_err(UnrecognizedField { span: meta_item.span(), name });
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Err(layout_error) => {
|
|
tcx.sess.emit_fatal(Spanned {
|
|
node: layout_error,
|
|
span: tcx.def_span(item_def_id.to_def_id()),
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
struct UnwrapLayoutCx<'tcx> {
|
|
tcx: TyCtxt<'tcx>,
|
|
param_env: ParamEnv<'tcx>,
|
|
}
|
|
|
|
impl<'tcx> LayoutOfHelpers<'tcx> for UnwrapLayoutCx<'tcx> {
|
|
type LayoutOfResult = TyAndLayout<'tcx>;
|
|
|
|
fn handle_layout_err(&self, err: LayoutError<'tcx>, span: Span, ty: Ty<'tcx>) -> ! {
|
|
span_bug!(
|
|
span,
|
|
"`#[rustc_layout(..)]` test resulted in `layout_of({}) = Err({})`",
|
|
ty,
|
|
err
|
|
);
|
|
}
|
|
}
|
|
|
|
impl<'tcx> HasTyCtxt<'tcx> for UnwrapLayoutCx<'tcx> {
|
|
fn tcx(&self) -> TyCtxt<'tcx> {
|
|
self.tcx
|
|
}
|
|
}
|
|
|
|
impl<'tcx> HasParamEnv<'tcx> for UnwrapLayoutCx<'tcx> {
|
|
fn param_env(&self) -> ParamEnv<'tcx> {
|
|
self.param_env
|
|
}
|
|
}
|
|
|
|
impl<'tcx> HasDataLayout for UnwrapLayoutCx<'tcx> {
|
|
fn data_layout(&self) -> &TargetDataLayout {
|
|
self.tcx.data_layout()
|
|
}
|
|
}
|