1 use rustc_data_structures::fx::FxHashSet;
2 use rustc_data_structures::sync::Lock;
3 use rustc_target::abi::{Align, Size};
4 use std::cmp::{self, Ordering};
6 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
7 pub struct VariantInfo {
8 pub name: Option<String>,
12 pub fields: Vec<FieldInfo>,
15 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
22 pub struct FieldInfo {
29 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30 pub enum DataTypeKind {
37 #[derive(PartialEq, Eq, Hash, Debug)]
38 pub struct TypeSizeInfo {
39 pub kind: DataTypeKind,
40 pub type_description: String,
42 pub overall_size: u64,
44 pub opt_discr_size: Option<u64>,
45 pub variants: Vec<VariantInfo>,
49 pub struct CodeStats {
50 type_sizes: Lock<FxHashSet<TypeSizeInfo>>,
54 pub fn record_type_size<S: ToString>(
61 opt_discr_size: Option<Size>,
62 mut variants: Vec<VariantInfo>,
64 // Sort variants so the largest ones are shown first. A stable sort is
65 // used here so that source code order is preserved for all variants
66 // that have the same size.
67 variants.sort_by(|info1, info2| info2.size.cmp(&info1.size));
68 let info = TypeSizeInfo {
70 type_description: type_desc.to_string(),
72 overall_size: overall_size.bytes(),
74 opt_discr_size: opt_discr_size.map(|s| s.bytes()),
77 self.type_sizes.borrow_mut().insert(info);
80 pub fn print_type_sizes(&self) {
81 let type_sizes = self.type_sizes.borrow();
82 let mut sorted: Vec<_> = type_sizes.iter().collect();
84 // Primary sort: large-to-small.
85 // Secondary sort: description (dictionary order)
86 sorted.sort_by(|info1, info2| {
87 // (reversing cmp order to get large-to-small ordering)
88 match info2.overall_size.cmp(&info1.overall_size) {
89 Ordering::Equal => info1.type_description.cmp(&info2.type_description),
95 let TypeSizeInfo { type_description, overall_size, align, kind, variants, .. } = info;
97 "print-type-size type: `{type_description}`: {overall_size} bytes, alignment: {align} bytes"
101 let discr_size = if let Some(discr_size) = info.opt_discr_size {
102 println!("print-type-size {indent}discriminant: {discr_size} bytes");
108 // We start this at discr_size (rather than 0) because
109 // things like C-enums do not have variants but we still
110 // want the max_variant_size at the end of the loop below
111 // to reflect the presence of the discriminant.
112 let mut max_variant_size = discr_size;
114 let struct_like = match kind {
115 DataTypeKind::Struct | DataTypeKind::Closure => true,
116 DataTypeKind::Enum | DataTypeKind::Union => false,
118 for (i, variant_info) in variants.into_iter().enumerate() {
119 let VariantInfo { ref name, kind: _, align: _, size, ref fields } = *variant_info;
120 let indent = if !struct_like {
121 let name = match name.as_ref() {
122 Some(name) => name.to_owned(),
123 None => i.to_string(),
126 "print-type-size {indent}variant `{name}`: {diff} bytes",
127 diff = size - discr_size
134 max_variant_size = cmp::max(max_variant_size, size);
136 let mut min_offset = discr_size;
138 // We want to print fields by increasing offset. We also want
139 // zero-sized fields before non-zero-sized fields, otherwise
140 // the loop below goes wrong; hence the `f.size` in the sort
142 let mut fields = fields.clone();
143 fields.sort_by_key(|f| (f.offset, f.size));
145 for field in fields {
146 let FieldInfo { ref name, offset, size, align } = field;
148 if offset > min_offset {
149 let pad = offset - min_offset;
150 println!("print-type-size {indent}padding: {pad} bytes");
153 if offset < min_offset {
154 // If this happens it's probably a union.
156 "print-type-size {indent}field `.{name}`: {size} bytes, \
157 offset: {offset} bytes, \
158 alignment: {align} bytes"
160 } else if info.packed || offset == min_offset {
161 println!("print-type-size {indent}field `.{name}`: {size} bytes");
163 // Include field alignment in output only if it caused padding injection
165 "print-type-size {indent}field `.{name}`: {size} bytes, \
166 alignment: {align} bytes"
170 min_offset = offset + size;
174 match overall_size.checked_sub(max_variant_size) {
175 None => panic!("max_variant_size {max_variant_size} > {overall_size} overall_size"),
176 Some(diff @ 1..) => println!("print-type-size {indent}end padding: {diff} bytes"),