rustc_abi/callconv.rs
1#[cfg(feature = "nightly")]
2use crate::{BackendRepr, FieldsShape, Primitive, Size, TyAbiInterface, TyAndLayout, Variants};
3
4mod reg;
5
6pub use reg::{Reg, RegKind};
7
8/// Return value from the `homogeneous_aggregate` test function.
9#[derive(Copy, Clone, Debug)]
10pub enum HomogeneousAggregate {
11 /// Yes, all the "leaf fields" of this struct are passed in the
12 /// same way (specified in the `Reg` value).
13 Homogeneous(Reg),
14
15 /// There are no leaf fields at all.
16 NoData,
17}
18
19/// Error from the `homogeneous_aggregate` test function, indicating
20/// there are distinct leaf fields passed in different ways,
21/// or this is uninhabited.
22#[derive(Copy, Clone, Debug)]
23pub struct Heterogeneous;
24
25impl HomogeneousAggregate {
26 /// If this is a homogeneous aggregate, returns the homogeneous
27 /// unit, else `None`.
28 pub fn unit(self) -> Option<Reg> {
29 match self {
30 HomogeneousAggregate::Homogeneous(reg) => Some(reg),
31 HomogeneousAggregate::NoData => None,
32 }
33 }
34
35 /// Try to combine two `HomogeneousAggregate`s, e.g. from two fields in
36 /// the same `struct`. Only succeeds if only one of them has any data,
37 /// or both units are identical.
38 fn merge(self, other: HomogeneousAggregate) -> Result<HomogeneousAggregate, Heterogeneous> {
39 match (self, other) {
40 (x, HomogeneousAggregate::NoData) | (HomogeneousAggregate::NoData, x) => Ok(x),
41
42 (HomogeneousAggregate::Homogeneous(a), HomogeneousAggregate::Homogeneous(b)) => {
43 if a != b {
44 return Err(Heterogeneous);
45 }
46 Ok(self)
47 }
48 }
49 }
50}
51
52#[cfg(feature = "nightly")]
53impl<'a, Ty> TyAndLayout<'a, Ty> {
54 /// Returns `Homogeneous` if this layout is an aggregate containing fields of
55 /// only a single type (e.g., `(u32, u32)`). Such aggregates are often
56 /// special-cased in ABIs.
57 ///
58 /// Note: We generally ignore 1-ZST fields when computing this value (see #56877).
59 ///
60 /// This is public so that it can be used in unit tests, but
61 /// should generally only be relevant to the ABI details of
62 /// specific targets.
63 pub fn homogeneous_aggregate<C>(&self, cx: &C) -> Result<HomogeneousAggregate, Heterogeneous>
64 where
65 Ty: TyAbiInterface<'a, C> + Copy,
66 {
67 match self.backend_repr {
68 // The primitive for this algorithm.
69 BackendRepr::Scalar(scalar) => {
70 let kind = match scalar.primitive() {
71 Primitive::Int(..) | Primitive::Pointer(_) => RegKind::Integer,
72 Primitive::Float(_) => RegKind::Float,
73 };
74 Ok(HomogeneousAggregate::Homogeneous(Reg { kind, size: self.size }))
75 }
76
77 BackendRepr::SimdVector { .. } => {
78 assert!(!self.is_zst());
79 Ok(HomogeneousAggregate::Homogeneous(Reg {
80 kind: RegKind::Vector,
81 size: self.size,
82 }))
83 }
84
85 BackendRepr::ScalarPair(..) | BackendRepr::Memory { sized: true } => {
86 // Helper for computing `homogeneous_aggregate`, allowing a custom
87 // starting offset (used below for handling variants).
88 let from_fields_at =
89 |layout: Self,
90 start: Size|
91 -> Result<(HomogeneousAggregate, Size), Heterogeneous> {
92 let is_union = match layout.fields {
93 FieldsShape::Primitive => {
94 unreachable!("aggregates can't have `FieldsShape::Primitive`")
95 }
96 FieldsShape::Array { count, .. } => {
97 assert_eq!(start, Size::ZERO);
98
99 let result = if count > 0 {
100 layout.field(cx, 0).homogeneous_aggregate(cx)?
101 } else {
102 HomogeneousAggregate::NoData
103 };
104 return Ok((result, layout.size));
105 }
106 FieldsShape::Union(_) => true,
107 FieldsShape::Arbitrary { .. } => false,
108 };
109
110 let mut result = HomogeneousAggregate::NoData;
111 let mut total = start;
112
113 for i in 0..layout.fields.count() {
114 let field = layout.field(cx, i);
115 if field.is_1zst() {
116 // No data here and no impact on layout, can be ignored.
117 // (We might be able to also ignore all aligned ZST but that's less clear.)
118 continue;
119 }
120
121 if !is_union && total != layout.fields.offset(i) {
122 // This field isn't just after the previous one we considered, abort.
123 return Err(Heterogeneous);
124 }
125
126 result = result.merge(field.homogeneous_aggregate(cx)?)?;
127
128 // Keep track of the offset (without padding).
129 let size = field.size;
130 if is_union {
131 total = total.max(size);
132 } else {
133 total += size;
134 }
135 }
136
137 Ok((result, total))
138 };
139
140 let (mut result, mut total) = from_fields_at(*self, Size::ZERO)?;
141
142 match &self.variants {
143 Variants::Single { .. } | Variants::Empty => {}
144 Variants::Multiple { variants, .. } => {
145 // Treat enum variants like union members.
146 // HACK(eddyb) pretend the `enum` field (discriminant)
147 // is at the start of every variant (otherwise the gap
148 // at the start of all variants would disqualify them).
149 //
150 // NB: for all tagged `enum`s (which include all non-C-like
151 // `enum`s with defined FFI representation), this will
152 // match the homogeneous computation on the equivalent
153 // `struct { tag; union { variant1; ... } }` and/or
154 // `union { struct { tag; variant1; } ... }`
155 // (the offsets of variant fields should be identical
156 // between the two for either to be a homogeneous aggregate).
157 let variant_start = total;
158 for variant_idx in variants.indices() {
159 let (variant_result, variant_total) =
160 from_fields_at(self.for_variant(cx, variant_idx), variant_start)?;
161
162 result = result.merge(variant_result)?;
163 total = total.max(variant_total);
164 }
165 }
166 }
167
168 // There needs to be no padding.
169 if total != self.size {
170 Err(Heterogeneous)
171 } else {
172 match result {
173 HomogeneousAggregate::Homogeneous(_) => {
174 assert_ne!(total, Size::ZERO);
175 }
176 HomogeneousAggregate::NoData => {
177 assert_eq!(total, Size::ZERO);
178 }
179 }
180 Ok(result)
181 }
182 }
183 BackendRepr::Memory { sized: false } => Err(Heterogeneous),
184 }
185 }
186}