Use ABI alignment, not "preferred" alignment, to unify monomorphizations

src/librustc/middle/trans/monomorphize.rs

@@ -30,7 +30,7 @@ use middle::trans::type_use;
 use middle::ty;
 use middle::ty::{FnSig};
 use middle::typeck;
-use util::ppaux::Repr;
+use util::ppaux::{Repr,ty_to_str};
 
 use core::vec;
 use syntax::ast;
@@ -379,10 +379,14 @@ pub fn make_mono_id(ccx: @CrateContext,
                         {
                             let llty = type_of::type_of(ccx, subst);
                             let size = machine::llbitsize_of_real(ccx, llty);
-                            let align = machine::llalign_of_pref(ccx, llty);
+                            let align = machine::llalign_of_min(ccx, llty);
                             let mode = datum::appropriate_mode(subst);
                             let data_class = mono_data_classify(subst);
 
+                            debug!("make_mono_id: type %s -> size %u align %u mode %? class %?",
+                                  ty_to_str(ccx.tcx, subst),
+                                  size, align, mode, data_class);
+
                             // Special value for nil to prevent problems
                             // with undef return pointers.
                             if size <= 8u && ty::type_is_nil(subst) {

src/test/run-pass/monomorphize-abi-alignment.rs

@@ -0,0 +1,31 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+/*!
+ * On x86_64-linux-gnu and possibly other platforms, structs get 8-byte "preferred" alignment,
+ * but their "ABI" alignment (i.e., what actually matters for data layout) is the largest alignment
+ * of any field.  (Also, u64 has 8-byte ABI alignment; this is not always true).
+ *
+ * On such platforms, if monomorphize uses the "preferred" alignment, then it will unify
+ * `A` and `B`, even though `S<A>` and `S<B>` have the field `t` at different offsets,
+ * and apply the wrong instance of the method `unwrap`.
+ */
+
+struct S<T> { i:u8, t:T }
+impl<T> S<T> { fn unwrap(self) -> T { self.t } }
+struct A((u32, u32));
+struct B(u64);
+
+pub fn main() {
+	static Ca: S<A> = S { i: 0, t: A((13, 104)) };
+	static Cb: S<B> = S { i: 0, t: B(31337) };
+	assert_eq!(*(Ca.unwrap()), (13, 104));
+	assert_eq!(*(Cb.unwrap()), 31337);
+}