rustc_target: treat enum variants like union members, in call ABIs.

Author: eddyb

src/librustc_target/abi/call/mod.rs

@@ -308,7 +308,7 @@ impl<'a, Ty> TyLayout<'a, Ty> {
 
             Abi::ScalarPair(..) | Abi::Aggregate { .. } => {
                 // Helper for computing `homogenous_aggregate`, allowing a custom
-                // starting offset (TODO(eddyb): use this to handle variants).
+                // starting offset (used below for handling variants).
                 let from_fields_at =
                     |layout: Self,
                      start: Size|
@@ -354,6 +354,24 @@ impl<'a, Ty> TyLayout<'a, Ty> {
 
                 let (mut result, mut total) = from_fields_at(*self, Size::ZERO)?;
 
+                match &self.variants {
+                    abi::Variants::Single { .. } => {}
+                    abi::Variants::Multiple { variants, .. } => {
+                        // Treat enum variants like union members.
+                        // HACK(eddyb) pretend the `enum` field (discriminant)
+                        // is at the start of every variant (otherwise the gap
+                        // at the start of all variants would disqualify them).
+                        let variant_start = total;
+                        for variant_idx in variants.indices() {
+                            let (variant_result, variant_total) =
+                                from_fields_at(self.for_variant(cx, variant_idx), variant_start)?;
+
+                            result = result.merge(variant_result)?;
+                            total = total.max(variant_total);
+                        }
+                    }
+                }
+
                 // There needs to be no padding.
                 if total != self.size {
                     Err(Heterogeneous)

src/librustc_target/abi/call/x86_64.rs

@@ -56,16 +56,24 @@ where
 
             Abi::Vector { .. } => Class::Sse,
 
-            Abi::ScalarPair(..) | Abi::Aggregate { .. } => match layout.variants {
-                abi::Variants::Single { .. } => {
-                    for i in 0..layout.fields.count() {
-                        let field_off = off + layout.fields.offset(i);
-                        classify(cx, layout.field(cx, i), cls, field_off)?;
+            Abi::ScalarPair(..) | Abi::Aggregate { .. } => {
+                for i in 0..layout.fields.count() {
+                    let field_off = off + layout.fields.offset(i);
+                    classify(cx, layout.field(cx, i), cls, field_off)?;
+                }
+
+                match &layout.variants {
+                    abi::Variants::Single { .. } => {}
+                    abi::Variants::Multiple { variants, .. } => {
+                        // Treat enum variants like union members.
+                        for variant_idx in variants.indices() {
+                            classify(cx, layout.for_variant(cx, variant_idx), cls, off)?;
+                        }
                     }
-                    return Ok(());
                 }
-                abi::Variants::Multiple { .. } => return Err(Memory),
-            },
+
+                return Ok(());
+            }
         };
 
         // Fill in `cls` for scalars (Int/Sse) and vectors (Sse).

src/test/run-make-fulldeps/pass-non-c-like-enum-to-c/nonclike.rs

@@ -14,11 +14,11 @@ pub enum T {
 }
 
 extern "C" {
-    pub fn t_add(a: T) -> u64;
+    pub fn t_add(a: T, b: T) -> u64;
     pub fn tt_add(a: TT, b: TT) -> u64;
 }
 
 fn main() {
     assert_eq!(33, unsafe { tt_add(TT::AA(1,2), TT::AA(10,20)) });
-    assert_eq!(11, unsafe { t_add(T::A(1)) });
+    assert_eq!(11, unsafe { t_add(T::A(1), T::A(10)) });
 }