Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit cb140dc

Browse files
matthiaskrgrmatthiaskrgr
authoredOct 14, 2024
Rollup merge of #131473 - workingjubilee:move-that-abi-up, r=saethlin
compiler: `{TyAnd,}Layout` comes home The `Layout` and `TyAndLayout` types are heavily abstract and have no particular target-specific qualities, though we do use them to answer questions particular to targets. We can keep it that way if we simply move them out of `rustc_target` and into `rustc_abi`. They bring a small entourage of connected types with them, but that's fine. This will allow us to strengthen a few abstraction barriers over time and thus make the notoriously gnarly layout code easier to refactor. For now, we don't need to worry about that and deliberately use reexports to minimize this particular diff.
2 parents cc5d86a + 1072190 commit cb140dc

32 files changed

+285
-261
lines changed
 

‎compiler/rustc_abi/src/callconv.rs

Lines changed: 254 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,254 @@
1+
mod abi {
2+
pub(crate) use crate::Primitive::*;
3+
pub(crate) use crate::Variants;
4+
}
5+
6+
use rustc_macros::HashStable_Generic;
7+
8+
use crate::{Abi, Align, FieldsShape, HasDataLayout, Size, TyAbiInterface, TyAndLayout};
9+
10+
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, HashStable_Generic)]
11+
pub enum RegKind {
12+
Integer,
13+
Float,
14+
Vector,
15+
}
16+
17+
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, HashStable_Generic)]
18+
pub struct Reg {
19+
pub kind: RegKind,
20+
pub size: Size,
21+
}
22+
23+
macro_rules! reg_ctor {
24+
($name:ident, $kind:ident, $bits:expr) => {
25+
pub fn $name() -> Reg {
26+
Reg { kind: RegKind::$kind, size: Size::from_bits($bits) }
27+
}
28+
};
29+
}
30+
31+
impl Reg {
32+
reg_ctor!(i8, Integer, 8);
33+
reg_ctor!(i16, Integer, 16);
34+
reg_ctor!(i32, Integer, 32);
35+
reg_ctor!(i64, Integer, 64);
36+
reg_ctor!(i128, Integer, 128);
37+
38+
reg_ctor!(f32, Float, 32);
39+
reg_ctor!(f64, Float, 64);
40+
}
41+
42+
impl Reg {
43+
pub fn align<C: HasDataLayout>(&self, cx: &C) -> Align {
44+
let dl = cx.data_layout();
45+
match self.kind {
46+
RegKind::Integer => match self.size.bits() {
47+
1 => dl.i1_align.abi,
48+
2..=8 => dl.i8_align.abi,
49+
9..=16 => dl.i16_align.abi,
50+
17..=32 => dl.i32_align.abi,
51+
33..=64 => dl.i64_align.abi,
52+
65..=128 => dl.i128_align.abi,
53+
_ => panic!("unsupported integer: {self:?}"),
54+
},
55+
RegKind::Float => match self.size.bits() {
56+
16 => dl.f16_align.abi,
57+
32 => dl.f32_align.abi,
58+
64 => dl.f64_align.abi,
59+
128 => dl.f128_align.abi,
60+
_ => panic!("unsupported float: {self:?}"),
61+
},
62+
RegKind::Vector => dl.vector_align(self.size).abi,
63+
}
64+
}
65+
}
66+
67+
/// Return value from the `homogeneous_aggregate` test function.
68+
#[derive(Copy, Clone, Debug)]
69+
pub enum HomogeneousAggregate {
70+
/// Yes, all the "leaf fields" of this struct are passed in the
71+
/// same way (specified in the `Reg` value).
72+
Homogeneous(Reg),
73+
74+
/// There are no leaf fields at all.
75+
NoData,
76+
}
77+
78+
/// Error from the `homogeneous_aggregate` test function, indicating
79+
/// there are distinct leaf fields passed in different ways,
80+
/// or this is uninhabited.
81+
#[derive(Copy, Clone, Debug)]
82+
pub struct Heterogeneous;
83+
84+
impl HomogeneousAggregate {
85+
/// If this is a homogeneous aggregate, returns the homogeneous
86+
/// unit, else `None`.
87+
pub fn unit(self) -> Option<Reg> {
88+
match self {
89+
HomogeneousAggregate::Homogeneous(reg) => Some(reg),
90+
HomogeneousAggregate::NoData => None,
91+
}
92+
}
93+
94+
/// Try to combine two `HomogeneousAggregate`s, e.g. from two fields in
95+
/// the same `struct`. Only succeeds if only one of them has any data,
96+
/// or both units are identical.
97+
fn merge(self, other: HomogeneousAggregate) -> Result<HomogeneousAggregate, Heterogeneous> {
98+
match (self, other) {
99+
(x, HomogeneousAggregate::NoData) | (HomogeneousAggregate::NoData, x) => Ok(x),
100+
101+
(HomogeneousAggregate::Homogeneous(a), HomogeneousAggregate::Homogeneous(b)) => {
102+
if a != b {
103+
return Err(Heterogeneous);
104+
}
105+
Ok(self)
106+
}
107+
}
108+
}
109+
}
110+
111+
impl<'a, Ty> TyAndLayout<'a, Ty> {
112+
/// Returns `true` if this is an aggregate type (including a ScalarPair!)
113+
pub fn is_aggregate(&self) -> bool {
114+
match self.abi {
115+
Abi::Uninhabited | Abi::Scalar(_) | Abi::Vector { .. } => false,
116+
Abi::ScalarPair(..) | Abi::Aggregate { .. } => true,
117+
}
118+
}
119+
120+
/// Returns `Homogeneous` if this layout is an aggregate containing fields of
121+
/// only a single type (e.g., `(u32, u32)`). Such aggregates are often
122+
/// special-cased in ABIs.
123+
///
124+
/// Note: We generally ignore 1-ZST fields when computing this value (see #56877).
125+
///
126+
/// This is public so that it can be used in unit tests, but
127+
/// should generally only be relevant to the ABI details of
128+
/// specific targets.
129+
pub fn homogeneous_aggregate<C>(&self, cx: &C) -> Result<HomogeneousAggregate, Heterogeneous>
130+
where
131+
Ty: TyAbiInterface<'a, C> + Copy,
132+
{
133+
match self.abi {
134+
Abi::Uninhabited => Err(Heterogeneous),
135+
136+
// The primitive for this algorithm.
137+
Abi::Scalar(scalar) => {
138+
let kind = match scalar.primitive() {
139+
abi::Int(..) | abi::Pointer(_) => RegKind::Integer,
140+
abi::Float(_) => RegKind::Float,
141+
};
142+
Ok(HomogeneousAggregate::Homogeneous(Reg { kind, size: self.size }))
143+
}
144+
145+
Abi::Vector { .. } => {
146+
assert!(!self.is_zst());
147+
Ok(HomogeneousAggregate::Homogeneous(Reg {
148+
kind: RegKind::Vector,
149+
size: self.size,
150+
}))
151+
}
152+
153+
Abi::ScalarPair(..) | Abi::Aggregate { sized: true } => {
154+
// Helper for computing `homogeneous_aggregate`, allowing a custom
155+
// starting offset (used below for handling variants).
156+
let from_fields_at =
157+
|layout: Self,
158+
start: Size|
159+
-> Result<(HomogeneousAggregate, Size), Heterogeneous> {
160+
let is_union = match layout.fields {
161+
FieldsShape::Primitive => {
162+
unreachable!("aggregates can't have `FieldsShape::Primitive`")
163+
}
164+
FieldsShape::Array { count, .. } => {
165+
assert_eq!(start, Size::ZERO);
166+
167+
let result = if count > 0 {
168+
layout.field(cx, 0).homogeneous_aggregate(cx)?
169+
} else {
170+
HomogeneousAggregate::NoData
171+
};
172+
return Ok((result, layout.size));
173+
}
174+
FieldsShape::Union(_) => true,
175+
FieldsShape::Arbitrary { .. } => false,
176+
};
177+
178+
let mut result = HomogeneousAggregate::NoData;
179+
let mut total = start;
180+
181+
for i in 0..layout.fields.count() {
182+
let field = layout.field(cx, i);
183+
if field.is_1zst() {
184+
// No data here and no impact on layout, can be ignored.
185+
// (We might be able to also ignore all aligned ZST but that's less clear.)
186+
continue;
187+
}
188+
189+
if !is_union && total != layout.fields.offset(i) {
190+
// This field isn't just after the previous one we considered, abort.
191+
return Err(Heterogeneous);
192+
}
193+
194+
result = result.merge(field.homogeneous_aggregate(cx)?)?;
195+
196+
// Keep track of the offset (without padding).
197+
let size = field.size;
198+
if is_union {
199+
total = total.max(size);
200+
} else {
201+
total += size;
202+
}
203+
}
204+
205+
Ok((result, total))
206+
};
207+
208+
let (mut result, mut total) = from_fields_at(*self, Size::ZERO)?;
209+
210+
match &self.variants {
211+
abi::Variants::Single { .. } => {}
212+
abi::Variants::Multiple { variants, .. } => {
213+
// Treat enum variants like union members.
214+
// HACK(eddyb) pretend the `enum` field (discriminant)
215+
// is at the start of every variant (otherwise the gap
216+
// at the start of all variants would disqualify them).
217+
//
218+
// NB: for all tagged `enum`s (which include all non-C-like
219+
// `enum`s with defined FFI representation), this will
220+
// match the homogeneous computation on the equivalent
221+
// `struct { tag; union { variant1; ... } }` and/or
222+
// `union { struct { tag; variant1; } ... }`
223+
// (the offsets of variant fields should be identical
224+
// between the two for either to be a homogeneous aggregate).
225+
let variant_start = total;
226+
for variant_idx in variants.indices() {
227+
let (variant_result, variant_total) =
228+
from_fields_at(self.for_variant(cx, variant_idx), variant_start)?;
229+
230+
result = result.merge(variant_result)?;
231+
total = total.max(variant_total);
232+
}
233+
}
234+
}
235+
236+
// There needs to be no padding.
237+
if total != self.size {
238+
Err(Heterogeneous)
239+
} else {
240+
match result {
241+
HomogeneousAggregate::Homogeneous(_) => {
242+
assert_ne!(total, Size::ZERO);
243+
}
244+
HomogeneousAggregate::NoData => {
245+
assert_eq!(total, Size::ZERO);
246+
}
247+
}
248+
Ok(result)
249+
}
250+
}
251+
Abi::Aggregate { sized: false } => Err(Heterogeneous),
252+
}
253+
}
254+
}

‎compiler/rustc_abi/src/layout.rs

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -11,6 +11,10 @@ use crate::{
1111
Variants, WrappingRange,
1212
};
1313

14+
mod ty;
15+
16+
pub use ty::{FIRST_VARIANT, FieldIdx, Layout, TyAbiInterface, TyAndLayout, VariantIdx};
17+
1418
// A variant is absent if it's uninhabited and only has ZST fields.
1519
// Present uninhabited variants only require space for their fields,
1620
// but *not* an encoding of the discriminant (e.g., a tag value).

‎compiler/rustc_target/src/abi/mod.rs renamed to ‎compiler/rustc_abi/src/layout/ty.rs

Lines changed: 1 addition & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -6,18 +6,8 @@ use Primitive::*;
66
use rustc_data_structures::intern::Interned;
77
use rustc_macros::HashStable_Generic;
88

9-
use crate::json::{Json, ToJson};
10-
11-
pub mod call;
12-
139
// Explicitly import `Float` to avoid ambiguity with `Primitive::Float`.
14-
pub use rustc_abi::{Float, *};
15-
16-
impl ToJson for Endian {
17-
fn to_json(&self) -> Json {
18-
self.as_str().to_json()
19-
}
20-
}
10+
use crate::{Float, *};
2111

2212
rustc_index::newtype_index! {
2313
/// The *source-order* index of a field in a variant.

‎compiler/rustc_abi/src/lib.rs

Lines changed: 7 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11
// tidy-alphabetical-start
22
#![cfg_attr(feature = "nightly", allow(internal_features))]
33
#![cfg_attr(feature = "nightly", doc(rust_logo))]
4+
#![cfg_attr(feature = "nightly", feature(rustc_attrs))]
45
#![cfg_attr(feature = "nightly", feature(rustdoc_internals))]
56
#![cfg_attr(feature = "nightly", feature(step_trait))]
67
#![warn(unreachable_pub)]
@@ -22,11 +23,16 @@ use rustc_macros::HashStable_Generic;
2223
#[cfg(feature = "nightly")]
2324
use rustc_macros::{Decodable_Generic, Encodable_Generic};
2425

26+
mod callconv;
2527
mod layout;
2628
#[cfg(test)]
2729
mod tests;
2830

29-
pub use layout::{LayoutCalculator, LayoutCalculatorError};
31+
pub use callconv::{Heterogeneous, HomogeneousAggregate, Reg, RegKind};
32+
pub use layout::{
33+
FIRST_VARIANT, FieldIdx, Layout, LayoutCalculator, LayoutCalculatorError, TyAbiInterface,
34+
TyAndLayout, VariantIdx,
35+
};
3036

3137
/// Requirements for a `StableHashingContext` to be used in this crate.
3238
/// This is a hack to allow using the `HashStable_Generic` derive macro

‎compiler/rustc_middle/src/ty/context.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,7 @@ use std::marker::PhantomData;
1212
use std::ops::{Bound, Deref};
1313
use std::{fmt, iter, mem};
1414

15+
use rustc_abi::{FieldIdx, Layout, LayoutS, TargetDataLayout, VariantIdx};
1516
use rustc_ast::{self as ast, attr};
1617
use rustc_data_structures::defer;
1718
use rustc_data_structures::fingerprint::Fingerprint;
@@ -48,7 +49,6 @@ use rustc_session::{Limit, MetadataKind, Session};
4849
use rustc_span::def_id::{CRATE_DEF_ID, DefPathHash, StableCrateId};
4950
use rustc_span::symbol::{Ident, Symbol, kw, sym};
5051
use rustc_span::{DUMMY_SP, Span};
51-
use rustc_target::abi::{FieldIdx, Layout, LayoutS, TargetDataLayout, VariantIdx};
5252
use rustc_target::spec::abi;
5353
use rustc_type_ir::TyKind::*;
5454
use rustc_type_ir::fold::TypeFoldable;

‎compiler/rustc_target/src/abi/call/mod.rs renamed to ‎compiler/rustc_target/src/callconv/mod.rs

Lines changed: 2 additions & 247 deletions
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,11 @@
11
use std::fmt;
22
use std::str::FromStr;
33

4+
pub use rustc_abi::{Reg, RegKind};
45
use rustc_macros::HashStable_Generic;
56
use rustc_span::Symbol;
67

7-
use crate::abi::{self, Abi, Align, FieldsShape, HasDataLayout, Size, TyAbiInterface, TyAndLayout};
8+
use crate::abi::{self, Abi, Align, HasDataLayout, Size, TyAbiInterface, TyAndLayout};
89
use crate::spec::{self, HasTargetSpec, HasWasmCAbiOpt, WasmCAbi};
910

1011
mod aarch64;
@@ -192,63 +193,6 @@ impl ArgAttributes {
192193
}
193194
}
194195

195-
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, HashStable_Generic)]
196-
pub enum RegKind {
197-
Integer,
198-
Float,
199-
Vector,
200-
}
201-
202-
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, HashStable_Generic)]
203-
pub struct Reg {
204-
pub kind: RegKind,
205-
pub size: Size,
206-
}
207-
208-
macro_rules! reg_ctor {
209-
($name:ident, $kind:ident, $bits:expr) => {
210-
pub fn $name() -> Reg {
211-
Reg { kind: RegKind::$kind, size: Size::from_bits($bits) }
212-
}
213-
};
214-
}
215-
216-
impl Reg {
217-
reg_ctor!(i8, Integer, 8);
218-
reg_ctor!(i16, Integer, 16);
219-
reg_ctor!(i32, Integer, 32);
220-
reg_ctor!(i64, Integer, 64);
221-
reg_ctor!(i128, Integer, 128);
222-
223-
reg_ctor!(f32, Float, 32);
224-
reg_ctor!(f64, Float, 64);
225-
}
226-
227-
impl Reg {
228-
pub fn align<C: HasDataLayout>(&self, cx: &C) -> Align {
229-
let dl = cx.data_layout();
230-
match self.kind {
231-
RegKind::Integer => match self.size.bits() {
232-
1 => dl.i1_align.abi,
233-
2..=8 => dl.i8_align.abi,
234-
9..=16 => dl.i16_align.abi,
235-
17..=32 => dl.i32_align.abi,
236-
33..=64 => dl.i64_align.abi,
237-
65..=128 => dl.i128_align.abi,
238-
_ => panic!("unsupported integer: {self:?}"),
239-
},
240-
RegKind::Float => match self.size.bits() {
241-
16 => dl.f16_align.abi,
242-
32 => dl.f32_align.abi,
243-
64 => dl.f64_align.abi,
244-
128 => dl.f128_align.abi,
245-
_ => panic!("unsupported float: {self:?}"),
246-
},
247-
RegKind::Vector => dl.vector_align(self.size).abi,
248-
}
249-
}
250-
}
251-
252196
/// An argument passed entirely registers with the
253197
/// same kind (e.g., HFA / HVA on PPC64 and AArch64).
254198
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, HashStable_Generic)]
@@ -380,195 +324,6 @@ impl CastTarget {
380324
}
381325
}
382326

383-
/// Return value from the `homogeneous_aggregate` test function.
384-
#[derive(Copy, Clone, Debug)]
385-
pub enum HomogeneousAggregate {
386-
/// Yes, all the "leaf fields" of this struct are passed in the
387-
/// same way (specified in the `Reg` value).
388-
Homogeneous(Reg),
389-
390-
/// There are no leaf fields at all.
391-
NoData,
392-
}
393-
394-
/// Error from the `homogeneous_aggregate` test function, indicating
395-
/// there are distinct leaf fields passed in different ways,
396-
/// or this is uninhabited.
397-
#[derive(Copy, Clone, Debug)]
398-
pub struct Heterogeneous;
399-
400-
impl HomogeneousAggregate {
401-
/// If this is a homogeneous aggregate, returns the homogeneous
402-
/// unit, else `None`.
403-
pub fn unit(self) -> Option<Reg> {
404-
match self {
405-
HomogeneousAggregate::Homogeneous(reg) => Some(reg),
406-
HomogeneousAggregate::NoData => None,
407-
}
408-
}
409-
410-
/// Try to combine two `HomogeneousAggregate`s, e.g. from two fields in
411-
/// the same `struct`. Only succeeds if only one of them has any data,
412-
/// or both units are identical.
413-
fn merge(self, other: HomogeneousAggregate) -> Result<HomogeneousAggregate, Heterogeneous> {
414-
match (self, other) {
415-
(x, HomogeneousAggregate::NoData) | (HomogeneousAggregate::NoData, x) => Ok(x),
416-
417-
(HomogeneousAggregate::Homogeneous(a), HomogeneousAggregate::Homogeneous(b)) => {
418-
if a != b {
419-
return Err(Heterogeneous);
420-
}
421-
Ok(self)
422-
}
423-
}
424-
}
425-
}
426-
427-
impl<'a, Ty> TyAndLayout<'a, Ty> {
428-
/// Returns `true` if this is an aggregate type (including a ScalarPair!)
429-
fn is_aggregate(&self) -> bool {
430-
match self.abi {
431-
Abi::Uninhabited | Abi::Scalar(_) | Abi::Vector { .. } => false,
432-
Abi::ScalarPair(..) | Abi::Aggregate { .. } => true,
433-
}
434-
}
435-
436-
/// Returns `Homogeneous` if this layout is an aggregate containing fields of
437-
/// only a single type (e.g., `(u32, u32)`). Such aggregates are often
438-
/// special-cased in ABIs.
439-
///
440-
/// Note: We generally ignore 1-ZST fields when computing this value (see #56877).
441-
///
442-
/// This is public so that it can be used in unit tests, but
443-
/// should generally only be relevant to the ABI details of
444-
/// specific targets.
445-
pub fn homogeneous_aggregate<C>(&self, cx: &C) -> Result<HomogeneousAggregate, Heterogeneous>
446-
where
447-
Ty: TyAbiInterface<'a, C> + Copy,
448-
{
449-
match self.abi {
450-
Abi::Uninhabited => Err(Heterogeneous),
451-
452-
// The primitive for this algorithm.
453-
Abi::Scalar(scalar) => {
454-
let kind = match scalar.primitive() {
455-
abi::Int(..) | abi::Pointer(_) => RegKind::Integer,
456-
abi::Float(_) => RegKind::Float,
457-
};
458-
Ok(HomogeneousAggregate::Homogeneous(Reg { kind, size: self.size }))
459-
}
460-
461-
Abi::Vector { .. } => {
462-
assert!(!self.is_zst());
463-
Ok(HomogeneousAggregate::Homogeneous(Reg {
464-
kind: RegKind::Vector,
465-
size: self.size,
466-
}))
467-
}
468-
469-
Abi::ScalarPair(..) | Abi::Aggregate { sized: true } => {
470-
// Helper for computing `homogeneous_aggregate`, allowing a custom
471-
// starting offset (used below for handling variants).
472-
let from_fields_at =
473-
|layout: Self,
474-
start: Size|
475-
-> Result<(HomogeneousAggregate, Size), Heterogeneous> {
476-
let is_union = match layout.fields {
477-
FieldsShape::Primitive => {
478-
unreachable!("aggregates can't have `FieldsShape::Primitive`")
479-
}
480-
FieldsShape::Array { count, .. } => {
481-
assert_eq!(start, Size::ZERO);
482-
483-
let result = if count > 0 {
484-
layout.field(cx, 0).homogeneous_aggregate(cx)?
485-
} else {
486-
HomogeneousAggregate::NoData
487-
};
488-
return Ok((result, layout.size));
489-
}
490-
FieldsShape::Union(_) => true,
491-
FieldsShape::Arbitrary { .. } => false,
492-
};
493-
494-
let mut result = HomogeneousAggregate::NoData;
495-
let mut total = start;
496-
497-
for i in 0..layout.fields.count() {
498-
let field = layout.field(cx, i);
499-
if field.is_1zst() {
500-
// No data here and no impact on layout, can be ignored.
501-
// (We might be able to also ignore all aligned ZST but that's less clear.)
502-
continue;
503-
}
504-
505-
if !is_union && total != layout.fields.offset(i) {
506-
// This field isn't just after the previous one we considered, abort.
507-
return Err(Heterogeneous);
508-
}
509-
510-
result = result.merge(field.homogeneous_aggregate(cx)?)?;
511-
512-
// Keep track of the offset (without padding).
513-
let size = field.size;
514-
if is_union {
515-
total = total.max(size);
516-
} else {
517-
total += size;
518-
}
519-
}
520-
521-
Ok((result, total))
522-
};
523-
524-
let (mut result, mut total) = from_fields_at(*self, Size::ZERO)?;
525-
526-
match &self.variants {
527-
abi::Variants::Single { .. } => {}
528-
abi::Variants::Multiple { variants, .. } => {
529-
// Treat enum variants like union members.
530-
// HACK(eddyb) pretend the `enum` field (discriminant)
531-
// is at the start of every variant (otherwise the gap
532-
// at the start of all variants would disqualify them).
533-
//
534-
// NB: for all tagged `enum`s (which include all non-C-like
535-
// `enum`s with defined FFI representation), this will
536-
// match the homogeneous computation on the equivalent
537-
// `struct { tag; union { variant1; ... } }` and/or
538-
// `union { struct { tag; variant1; } ... }`
539-
// (the offsets of variant fields should be identical
540-
// between the two for either to be a homogeneous aggregate).
541-
let variant_start = total;
542-
for variant_idx in variants.indices() {
543-
let (variant_result, variant_total) =
544-
from_fields_at(self.for_variant(cx, variant_idx), variant_start)?;
545-
546-
result = result.merge(variant_result)?;
547-
total = total.max(variant_total);
548-
}
549-
}
550-
}
551-
552-
// There needs to be no padding.
553-
if total != self.size {
554-
Err(Heterogeneous)
555-
} else {
556-
match result {
557-
HomogeneousAggregate::Homogeneous(_) => {
558-
assert_ne!(total, Size::ZERO);
559-
}
560-
HomogeneousAggregate::NoData => {
561-
assert_eq!(total, Size::ZERO);
562-
}
563-
}
564-
Ok(result)
565-
}
566-
}
567-
Abi::Aggregate { sized: false } => Err(Heterogeneous),
568-
}
569-
}
570-
}
571-
572327
/// Information about how to pass an argument to,
573328
/// or return a value from, a function, under some ABI.
574329
#[derive(Clone, PartialEq, Eq, Hash, HashStable_Generic)]

‎compiler/rustc_target/src/json.rs

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -134,3 +134,9 @@ impl ToJson for TargetMetadata {
134134
})
135135
}
136136
}
137+
138+
impl ToJson for rustc_abi::Endian {
139+
fn to_json(&self) -> Json {
140+
self.as_str().to_json()
141+
}
142+
}

‎compiler/rustc_target/src/lib.rs

Lines changed: 10 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -21,15 +21,24 @@
2121

2222
use std::path::{Path, PathBuf};
2323

24-
pub mod abi;
2524
pub mod asm;
25+
pub mod callconv;
2626
pub mod json;
2727
pub mod spec;
2828
pub mod target_features;
2929

3030
#[cfg(test)]
3131
mod tests;
3232

33+
pub mod abi {
34+
pub(crate) use Float::*;
35+
pub(crate) use Primitive::*;
36+
// Explicitly import `Float` to avoid ambiguity with `Primitive::Float`.
37+
pub use rustc_abi::{Float, *};
38+
39+
pub use crate::callconv as call;
40+
}
41+
3342
pub use rustc_abi::HashStableContext;
3443

3544
/// The name of rustc's own place to organize libraries.

0 commit comments

Comments
 (0)
Please sign in to comment.