compiler/rustc_passes/src/layout_test.rs

   1 use rustc_ast::Attribute;
   2 use rustc_hir as hir;
   3 use rustc_hir::def_id::LocalDefId;
   4 use rustc_hir::itemlikevisit::ItemLikeVisitor;
   5 use rustc_hir::ItemKind;
   6 use rustc_middle::ty::layout::{HasParamEnv, HasTyCtxt, TyAndLayout};
   7 use rustc_middle::ty::{ParamEnv, Ty, TyCtxt};
   8 use rustc_span::symbol::sym;
   9 use rustc_target::abi::{HasDataLayout, LayoutOf, TargetDataLayout};
  10
  11 pub fn test_layout(tcx: TyCtxt<'_>) {
  12     if tcx.features().rustc_attrs {
  13         // if the `rustc_attrs` feature is not enabled, don't bother testing layout
  14         tcx.hir().krate().visit_all_item_likes(&mut LayoutTest { tcx });
  15     }
  16 }
  17
  18 struct LayoutTest<'tcx> {
  19     tcx: TyCtxt<'tcx>,
  20 }
  21
  22 impl ItemLikeVisitor<'tcx> for LayoutTest<'tcx> {
  23     fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) {
  24         let item_def_id = self.tcx.hir().local_def_id(item.hir_id);
  25
  26         match item.kind {
  27             ItemKind::TyAlias(..)
  28             | ItemKind::Enum(..)
  29             | ItemKind::Struct(..)
  30             | ItemKind::Union(..) => {
  31                 for attr in self.tcx.get_attrs(item_def_id.to_def_id()).iter() {
  32                     if self.tcx.sess.check_name(attr, sym::rustc_layout) {
  33                         self.dump_layout_of(item_def_id, item, attr);
  34                     }
  35                 }
  36             }
  37             _ => {}
  38         }
  39     }
  40
  41     fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem<'tcx>) {}
  42     fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem<'tcx>) {}
  43     fn visit_foreign_item(&mut self, _: &'tcx hir::ForeignItem<'tcx>) {}
  44 }
  45
  46 impl LayoutTest<'tcx> {
  47     fn dump_layout_of(&self, item_def_id: LocalDefId, item: &hir::Item<'tcx>, attr: &Attribute) {
  48         let tcx = self.tcx;
  49         let param_env = self.tcx.param_env(item_def_id);
  50         let ty = self.tcx.type_of(item_def_id);
  51         match self.tcx.layout_of(param_env.and(ty)) {
  52             Ok(ty_layout) => {
  53                 // Check out the `#[rustc_layout(..)]` attribute to tell what to dump.
  54                 // The `..` are the names of fields to dump.
  55                 let meta_items = attr.meta_item_list().unwrap_or_default();
  56                 for meta_item in meta_items {
  57                     match meta_item.name_or_empty() {
  58                         sym::abi => {
  59                             self.tcx.sess.span_err(item.span, &format!("abi: {:?}", ty_layout.abi));
  60                         }
  61
  62                         sym::align => {
  63                             self.tcx
  64                                 .sess
  65                                 .span_err(item.span, &format!("align: {:?}", ty_layout.align));
  66                         }
  67
  68                         sym::size => {
  69                             self.tcx
  70                                 .sess
  71                                 .span_err(item.span, &format!("size: {:?}", ty_layout.size));
  72                         }
  73
  74                         sym::homogeneous_aggregate => {
  75                             self.tcx.sess.span_err(
  76                                 item.span,
  77                                 &format!(
  78                                     "homogeneous_aggregate: {:?}",
  79                                     ty_layout
  80                                         .homogeneous_aggregate(&UnwrapLayoutCx { tcx, param_env }),
  81                                 ),
  82                             );
  83                         }
  84
  85                         sym::debug => {
  86                             let normalized_ty = self.tcx.normalize_erasing_regions(
  87                                 param_env.with_reveal_all_normalized(self.tcx),
  88                                 ty,
  89                             );
  90                             self.tcx.sess.span_err(
  91                                 item.span,
  92                                 &format!("layout_of({:?}) = {:#?}", normalized_ty, *ty_layout),
  93                             );
  94                         }
  95
  96                         name => {
  97                             self.tcx.sess.span_err(
  98                                 meta_item.span(),
  99                                 &format!("unrecognized field name `{}`", name),
 100                             );
 101                         }
 102                     }
 103                 }
 104             }
 105
 106             Err(layout_error) => {
 107                 self.tcx.sess.span_err(item.span, &format!("layout error: {:?}", layout_error));
 108             }
 109         }
 110     }
 111 }
 112
 113 struct UnwrapLayoutCx<'tcx> {
 114     tcx: TyCtxt<'tcx>,
 115     param_env: ParamEnv<'tcx>,
 116 }
 117
 118 impl LayoutOf for UnwrapLayoutCx<'tcx> {
 119     type Ty = Ty<'tcx>;
 120     type TyAndLayout = TyAndLayout<'tcx>;
 121
 122     fn layout_of(&self, ty: Ty<'tcx>) -> Self::TyAndLayout {
 123         self.tcx.layout_of(self.param_env.and(ty)).unwrap()
 124     }
 125 }
 126
 127 impl HasTyCtxt<'tcx> for UnwrapLayoutCx<'tcx> {
 128     fn tcx(&self) -> TyCtxt<'tcx> {
 129         self.tcx
 130     }
 131 }
 132
 133 impl HasParamEnv<'tcx> for UnwrapLayoutCx<'tcx> {
 134     fn param_env(&self) -> ParamEnv<'tcx> {
 135         self.param_env
 136     }
 137 }
 138
 139 impl HasDataLayout for UnwrapLayoutCx<'tcx> {
 140     fn data_layout(&self) -> &TargetDataLayout {
 141         self.tcx.data_layout()
 142     }
 143 }