Merge pull request rust-lang#108 from oli-obk/packd

implement packed struct field access

Author: solson

Cargo.lock

@@ -443,6 +443,10 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                 match *dest_layout {
                     Univariant { ref variant, .. } => {
                         let offsets = variant.offsets.iter().map(|s| s.bytes());
+                        if variant.packed {
+                            let ptr = self.force_allocation(dest)?.to_ptr_and_extra().0;
+                            self.memory.mark_packed(ptr, variant.stride().bytes());
+                        }
                         self.assign_fields(dest, offsets, operands)?;
                     }
 
@@ -460,6 +464,10 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                         if let mir::AggregateKind::Adt(adt_def, variant, _, _) = *kind {
                             let discr_val = adt_def.variants[variant].disr_val.to_u128_unchecked();
                             let discr_size = discr.size().bytes();
+                            if variants[variant].packed {
+                                let ptr = self.force_allocation(dest)?.to_ptr_and_extra().0;
+                                self.memory.mark_packed(ptr, variants[variant].stride().bytes());
+                            }
 
                             self.assign_discr_and_fields(
                                 dest,
@@ -496,6 +504,10 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
 
                     StructWrappedNullablePointer { nndiscr, ref nonnull, ref discrfield, .. } => {
                         if let mir::AggregateKind::Adt(_, variant, _, _) = *kind {
+                            if nonnull.packed {
+                                let ptr = self.force_allocation(dest)?.to_ptr_and_extra().0;
+                                self.memory.mark_packed(ptr, nonnull.stride().bytes());
+                            }
                             if nndiscr == variant as u64 {
                                 let offsets = nonnull.offsets.iter().map(|s| s.bytes());
                                 self.assign_fields(dest, offsets, operands)?;

src/eval_context.rs

@@ -173,13 +173,15 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                 let field = field.index();
 
                 use rustc::ty::layout::Layout::*;
-                let offset = match *base_layout {
-                    Univariant { ref variant, .. } => variant.offsets[field],
+                let (offset, packed) = match *base_layout {
+                    Univariant { ref variant, .. } => {
+                        (variant.offsets[field], variant.packed)
+                    },
 
                     General { ref variants, .. } => {
                         if let LvalueExtra::DowncastVariant(variant_idx) = base_extra {
                             // +1 for the discriminant, which is field 0
-                            variants[variant_idx].offsets[field + 1]
+                            (variants[variant_idx].offsets[field + 1], variants[variant_idx].packed)
                         } else {
                             bug!("field access on enum had no variant index");
                         }
@@ -191,7 +193,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                     }
 
                     StructWrappedNullablePointer { ref nonnull, .. } => {
-                        nonnull.offsets[field]
+                        (nonnull.offsets[field], nonnull.packed)
                     }
 
                     UntaggedUnion { .. } => return Ok(base),
@@ -200,13 +202,19 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                         let field = field as u64;
                         assert!(field < count);
                         let elem_size = element.size(&self.tcx.data_layout).bytes();
-                        Size::from_bytes(field * elem_size)
+                        (Size::from_bytes(field * elem_size), false)
                     }
 
                     _ => bug!("field access on non-product type: {:?}", base_layout),
                 };
 
                 let ptr = base_ptr.offset(offset.bytes());
+
+                if packed {
+                    let size = self.type_size(field_ty)?.expect("packed struct must be sized");
+                    self.memory.mark_packed(ptr, size);
+                }
+
                 let extra = if self.type_is_sized(field_ty) {
                     LvalueExtra::None
                 } else {