1 files changed, 13 insertions, 16 deletions
diff --git a/src/librustc_trans/mir/operand.rs b/src/librustc_trans/mir/operand.rs
index f6966178291..3e4a73c2e90 100644
--- a/src/librustc_trans/mir/operand.rs
+++ b/src/librustc_trans/mir/operand.rs
@@ -18,7 +18,7 @@ use rustc_data_structures::indexed_vec::Idx;
 
 use base;
 use common::{self, CodegenCx, C_null, C_undef, C_usize};
-use builder::Builder;
+use builder::{Builder, MemFlags};
 use value::Value;
 use type_of::LayoutLlvmExt;
 use type_::Type;
@@ -275,14 +275,18 @@ impl<'a, 'tcx> OperandRef<'tcx> {
 
 impl<'a, 'tcx> OperandValue {
     pub fn store(self, bx: &Builder<'a, 'tcx>, dest: PlaceRef<'tcx>) {
-        self.store_maybe_volatile(bx, dest, false);
+        self.store_with_flags(bx, dest, MemFlags::empty());
     }
 
     pub fn volatile_store(self, bx: &Builder<'a, 'tcx>, dest: PlaceRef<'tcx>) {
-        self.store_maybe_volatile(bx, dest, true);
+        self.store_with_flags(bx, dest, MemFlags::VOLATILE);
     }
 
-    fn store_maybe_volatile(self, bx: &Builder<'a, 'tcx>, dest: PlaceRef<'tcx>, volatile: bool) {
+    pub fn nontemporal_store(self, bx: &Builder<'a, 'tcx>, dest: PlaceRef<'tcx>) {
+        self.store_with_flags(bx, dest, MemFlags::NONTEMPORAL);
+    }
+
+    fn store_with_flags(self, bx: &Builder<'a, 'tcx>, dest: PlaceRef<'tcx>, flags: MemFlags) {
         debug!("OperandRef::store: operand={:?}, dest={:?}", self, dest);
         // Avoid generating stores of zero-sized values, because the only way to have a zero-sized
         // value is through `undef`, and store itself is useless.
@@ -290,16 +294,13 @@ impl<'a, 'tcx> OperandValue {
             return;
         }
         match self {
-            OperandValue::Ref(r, source_align) =>
+            OperandValue::Ref(r, source_align) => {
                 base::memcpy_ty(bx, dest.llval, r, dest.layout,
-                                source_align.min(dest.align), volatile),
+                                source_align.min(dest.align), flags)
+            }
             OperandValue::Immediate(s) => {
                 let val = base::from_immediate(bx, s);
-                if !volatile {
-                    bx.store(val, dest.llval, dest.align);
-                } else {
-                    bx.volatile_store(val, dest.llval, dest.align);
-                }
+                bx.store_with_flags(val, dest.llval, dest.align, flags);
             }
             OperandValue::Pair(a, b) => {
                 for (i, &x) in [a, b].iter().enumerate() {
@@ -309,11 +310,7 @@ impl<'a, 'tcx> OperandValue {
                         llptr = bx.pointercast(llptr, Type::i8p(bx.cx));
                     }
                     let val = base::from_immediate(bx, x);
-                    if !volatile {
-                        bx.store(val, llptr, dest.align);
-                    } else {
-                        bx.volatile_store(val, llptr, dest.align);
-                    }
+                    bx.store_with_flags(val, llptr, dest.align, flags);
                 }
             }
         }