---

yaml
---
r: 6492
b: refs/heads/master
c: 152bb31
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 8371beb5905158377689b9efb5cdb4a07ae17ada
+refs/heads/master: 152bb314f5665b66d1eb91b7ce90f14c01c1197d

trunk/src/comp/middle/shape.rs

@@ -6,7 +6,7 @@ import lib::llvm::llvm::{ModuleRef, TypeRef, ValueRef};
 import driver::session;
 import middle::{trans, trans_common};
 import middle::trans_common::{crate_ctxt, val_ty, C_bytes,
-                              C_named_struct, C_struct};
+                              C_named_struct, C_struct, T_tag_variant};
 import middle::ty;
 import middle::ty::field;
 import syntax::ast;
@@ -213,7 +213,12 @@ fn compute_static_tag_size(ccx: @crate_ctxt, largest_variants: [uint],
     // Add space for the tag if applicable.
     // FIXME (issue #792): This is wrong. If the tag starts with an 8 byte
     // aligned quantity, we don't align it.
-    if vec::len(variants) > 1u { max_size += 4u16; max_align = 4u8; }
+    if vec::len(variants) > 1u {
+        let variant_t = T_tag_variant(ccx);
+        max_size += trans::llsize_of_real(ccx, variant_t) as u16;
+        let align = trans::llalign_of_real(ccx, variant_t) as u8;
+        if max_align < align { max_align = align; }
+    }
 
     ret {size: max_size, align: max_align};
 }

trunk/src/comp/middle/trans.rs

@@ -220,11 +220,11 @@ fn type_of_tag(cx: @crate_ctxt, sp: span, did: ast::def_id, t: ty::t)
     if check type_has_static_size(cx, t) {
         let size = static_size_of_tag(cx, sp, t);
         if !degen { T_tag(cx, size) }
-        else if size == 0u { T_struct([cx.int_type]) }
+        else if size == 0u { T_struct([T_tag_variant(cx)]) }
         else { T_array(T_i8(), size) }
     }
     else {
-        if degen { T_struct([cx.int_type]) }
+        if degen { T_struct([T_tag_variant(cx)]) }
         else { T_opaque_tag(cx) }
     }
 }

trunk/src/comp/middle/trans_common.rs

@@ -676,21 +676,25 @@ fn T_opaque_closure_ptr(cx: @crate_ctxt) -> TypeRef {
     ret t;
 }
 
+fn T_tag_variant(cx: @crate_ctxt) -> TypeRef {
+    ret cx.int_type;
+}
+
 fn T_tag(cx: @crate_ctxt, size: uint) -> TypeRef {
     let s = "tag_" + uint::to_str(size, 10u);
     if cx.tn.name_has_type(s) { ret cx.tn.get_type(s); }
     let t =
         if size == 0u {
-            T_struct([cx.int_type])
-        } else { T_struct([cx.int_type, T_array(T_i8(), size)]) };
+            T_struct([T_tag_variant(cx)])
+        } else { T_struct([T_tag_variant(cx), T_array(T_i8(), size)]) };
     cx.tn.associate(s, t);
     ret t;
 }
 
 fn T_opaque_tag(cx: @crate_ctxt) -> TypeRef {
     let s = "opaque_tag";
     if cx.tn.name_has_type(s) { ret cx.tn.get_type(s); }
-    let t = T_struct([cx.int_type, T_i8()]);
+    let t = T_struct([T_tag_variant(cx), T_i8()]);
     cx.tn.associate(s, t);
     ret t;
 }

trunk/src/test/run-pass/shape_intrinsic_tag_then_rec.rs

@@ -0,0 +1,31 @@
+// Exercises a bug in the shape code that was exposed
+// on x86_64: when there is a tag embedded in an 
+// interior record which is then itself interior to
+// something else, shape calculations were off.
+use std;
+import std::list;
+import std::list::list;
+import std::option;
+
+tag opt_span {
+
+    //hack (as opposed to option::t), to make `span` compile
+    os_none;
+    os_some(@span);
+}
+type span = {lo: uint, hi: uint, expanded_from: opt_span};
+type spanned<T> = { data: T, span: span };
+type ty_ = uint;
+type path_ = { global: bool, idents: [str], types: [@ty] };
+type path = spanned<path_>;
+type ty = spanned<ty_>;
+
+fn main() {
+    let sp: span = {lo: 57451u, hi: 57542u, expanded_from: os_none};
+    let t: @ty = @{ data: 3u, span: sp };
+    let p_: path_ = { global: true, idents: ["hi"], types: [t] };
+    let p: path = { data: p_, span: sp };
+    let x = { sp: sp, path: p };
+    log_err x.path;
+    log_err x;
+}