diff --git a/src/test/codegen/adjustments.rs b/src/test/codegen/adjustments.rs
index 20d0493943452..75da9ce2dacf0 100644
--- a/src/test/codegen/adjustments.rs
+++ b/src/test/codegen/adjustments.rs
@@ -16,8 +16,7 @@
 // Hack to get the correct size for the length part in slices
 // CHECK: @helper([[USIZE:i[0-9]+]])
 #[no_mangle]
-fn helper(_: usize) {
-}
+fn helper(_: usize) {}
 
 // CHECK-LABEL: @no_op_slice_adjustment
 #[no_mangle]
@@ -25,10 +24,12 @@ fn helper(_: usize) {
 pub fn no_op_slice_adjustment(x: &[u8]) -> &[u8] {
     // We used to generate an extra alloca and memcpy for the block's trailing expression value, so
     // check that we copy directly to the return value slot
-// CHECK: [[SRC:%[0-9]+]] = bitcast { i8*, [[USIZE]] }* %x to
-// CHECK: [[DST:%[0-9]+]] = bitcast { i8*, [[USIZE]] }* %sret_slot to i8*
-// CHECK: call void @llvm.memcpy.{{.*}}(i8* [[DST]], i8* [[SRC]],
-    { x }
+    // CHECK: [[SRC:%[0-9]+]] = bitcast { i8*, [[USIZE]] }* %x to
+    // CHECK: [[DST:%[0-9]+]] = bitcast { i8*, [[USIZE]] }* %sret_slot to i8*
+    // CHECK: call void @llvm.memcpy.{{.*}}(i8* [[DST]], i8* [[SRC]],
+    {
+        x
+    }
 }
 
 // CHECK-LABEL: @no_op_slice_adjustment2
@@ -36,6 +37,6 @@ pub fn no_op_slice_adjustment(x: &[u8]) -> &[u8] {
 pub fn no_op_slice_adjustment2(x: &[u8]) -> &[u8] {
     // We used to generate an extra alloca and memcpy for the function's return value, so check
     // that there's no memcpy (the slice is written to sret_slot element-wise)
-// CHECK-NOT: call void @llvm.memcpy.
+    // CHECK-NOT: call void @llvm.memcpy.
     no_op_slice_adjustment(x)
 }
diff --git a/src/test/codegen/coercions.rs b/src/test/codegen/coercions.rs
index 74c7192259ac4..29951e0e56a1a 100644
--- a/src/test/codegen/coercions.rs
+++ b/src/test/codegen/coercions.rs
@@ -19,7 +19,7 @@ static X: i32 = 5;
 // CHECK-NOT: alloca
 #[no_mangle]
 #[rustc_no_mir] // FIXME #27840 MIR has different codegen.
-pub fn raw_ptr_to_raw_ptr_noop() -> *const i32{
+pub fn raw_ptr_to_raw_ptr_noop() -> *const i32 {
     &X as *const i32
 }
 
diff --git a/src/test/codegen/consts.rs b/src/test/codegen/consts.rs
index ea4c932d43549..f837276cdaa1b 100644
--- a/src/test/codegen/consts.rs
+++ b/src/test/codegen/consts.rs
@@ -27,7 +27,6 @@
 // CHECK: @const{{[0-9]+}} = {{.*}}, align 4
 
 #[derive(Copy, Clone)]
-
 // repr(i16) is required for the {low,high}_align_const test
 #[repr(i16)]
 pub enum E<A, B> {
@@ -42,7 +41,7 @@ pub static STATIC: E<i16, i32> = E::A(0);
 #[no_mangle]
 #[rustc_no_mir] // FIXME #27840 MIR has different codegen.
 pub fn static_enum_const() -> E<i16, i32> {
-   STATIC
+    STATIC
 }
 
 // CHECK-LABEL: @inline_enum_const
@@ -56,8 +55,8 @@ pub fn inline_enum_const() -> E<i8, i16> {
 #[no_mangle]
 #[rustc_no_mir] // FIXME #27840 MIR has different codegen.
 pub fn low_align_const() -> E<i16, [i16; 3]> {
-// Check that low_align_const and high_align_const use the same constant
-// CHECK: call void @llvm.memcpy.{{.*}}(i8* %{{[0-9]+}}, i8* {{.*}} [[LOW_HIGH:@const[0-9]+]]
+    // Check that low_align_const and high_align_const use the same constant
+    // CHECK: call void @llvm.memcpy.{{.*}}(i8* %{{[0-9]+}}, i8* {{.*}} [[LOW_HIGH:@const[0-9]+]]
     E::A(0)
 }
 
@@ -65,7 +64,7 @@ pub fn low_align_const() -> E<i16, [i16; 3]> {
 #[no_mangle]
 #[rustc_no_mir] // FIXME #27840 MIR has different codegen.
 pub fn high_align_const() -> E<i16, i32> {
-// Check that low_align_const and high_align_const use the same constant
-// CHECK: call void @llvm.memcpy.{{.*}}(i8* %{{[0-9]}}, i8* {{.*}} [[LOW_HIGH]]
+    // Check that low_align_const and high_align_const use the same constant
+    // CHECK: call void @llvm.memcpy.{{.*}}(i8* %{{[0-9]}}, i8* {{.*}} [[LOW_HIGH]]
     E::A(0)
 }
diff --git a/src/test/codegen/drop.rs b/src/test/codegen/drop.rs
index 83dd6a3b00258..5b5f661890ca7 100644
--- a/src/test/codegen/drop.rs
+++ b/src/test/codegen/drop.rs
@@ -16,30 +16,28 @@
 struct SomeUniqueName;
 
 impl Drop for SomeUniqueName {
-    fn drop(&mut self) {
-    }
+    fn drop(&mut self) {}
 }
 
-pub fn possibly_unwinding() {
-}
+pub fn possibly_unwinding() {}
 
 // CHECK-LABEL: @droppy
 #[no_mangle]
 #[rustc_no_mir] // FIXME #27840 MIR has different codegen.
 pub fn droppy() {
-// Check that there are exactly 6 drop calls. The cleanups for the unwinding should be reused, so
-// that's one new drop call per call to possibly_unwinding(), and finally 3 drop calls for the
-// regular function exit. We used to have problems with quadratic growths of drop calls in such
-// functions.
-// CHECK: call{{.*}}SomeUniqueName{{.*}}drop
-// CHECK: call{{.*}}SomeUniqueName{{.*}}drop
-// CHECK: call{{.*}}SomeUniqueName{{.*}}drop
-// CHECK: call{{.*}}SomeUniqueName{{.*}}drop
-// CHECK: call{{.*}}SomeUniqueName{{.*}}drop
-// CHECK: call{{.*}}SomeUniqueName{{.*}}drop
-// CHECK-NOT: call{{.*}}SomeUniqueName{{.*}}drop
-// The next line checks for the } that ends the function definition
-// CHECK-LABEL: {{^[}]}}
+    // Check that there are exactly 6 drop calls. The cleanups for the unwinding should be reused, so
+    // that's one new drop call per call to possibly_unwinding(), and finally 3 drop calls for the
+    // regular function exit. We used to have problems with quadratic growths of drop calls in such
+    // functions.
+    // CHECK: call{{.*}}SomeUniqueName{{.*}}drop
+    // CHECK: call{{.*}}SomeUniqueName{{.*}}drop
+    // CHECK: call{{.*}}SomeUniqueName{{.*}}drop
+    // CHECK: call{{.*}}SomeUniqueName{{.*}}drop
+    // CHECK: call{{.*}}SomeUniqueName{{.*}}drop
+    // CHECK: call{{.*}}SomeUniqueName{{.*}}drop
+    // CHECK-NOT: call{{.*}}SomeUniqueName{{.*}}drop
+    // The next line checks for the } that ends the function definition
+    // CHECK-LABEL: {{^[}]}}
     let _s = SomeUniqueName;
     possibly_unwinding();
     let _s = SomeUniqueName;
diff --git a/src/test/codegen/extern-functions.rs b/src/test/codegen/extern-functions.rs
index 7ee31070b2635..6bd43cc995aff 100644
--- a/src/test/codegen/extern-functions.rs
+++ b/src/test/codegen/extern-functions.rs
@@ -13,12 +13,12 @@
 #![crate_type = "lib"]
 #![feature(unwind_attributes)]
 
-extern {
-// CHECK: Function Attrs: nounwind
-// CHECK-NEXT: declare void @extern_fn
+extern "C" {
+    // CHECK: Function Attrs: nounwind
+    // CHECK-NEXT: declare void @extern_fn
     fn extern_fn();
-// CHECK-NOT: Function Attrs: nounwind
-// CHECK: declare void @unwinding_extern_fn
+    // CHECK-NOT: Function Attrs: nounwind
+    // CHECK: declare void @unwinding_extern_fn
     #[unwind]
     fn unwinding_extern_fn();
 }
diff --git a/src/test/codegen/fatptr.rs b/src/test/codegen/fatptr.rs
index b9e6508dfff1d..aa9e2f78ca5bd 100644
--- a/src/test/codegen/fatptr.rs
+++ b/src/test/codegen/fatptr.rs
@@ -17,6 +17,6 @@ pub trait T {}
 // CHECK-LABEL: @copy_fat_ptr
 #[no_mangle]
 pub fn copy_fat_ptr(x: &T) {
-// CHECK-NOT: extractvalue
+    // CHECK-NOT: extractvalue
     let x2 = x;
 }
diff --git a/src/test/codegen/float_math.rs b/src/test/codegen/float_math.rs
index bc458d45446fe..8fd4132ca8b25 100644
--- a/src/test/codegen/float_math.rs
+++ b/src/test/codegen/float_math.rs
@@ -13,48 +13,40 @@
 #![crate_type = "lib"]
 #![feature(core_intrinsics)]
 
-use std::intrinsics::{fadd_fast, fsub_fast, fmul_fast, fdiv_fast, frem_fast};
+use std::intrinsics::{fadd_fast, fdiv_fast, fmul_fast, frem_fast, fsub_fast};
 
 // CHECK-LABEL: @add
 #[no_mangle]
 pub fn add(x: f32, y: f32) -> f32 {
-// CHECK: fadd float
-// CHECK-NOT fast
+    // CHECK: fadd float
+    // CHECK-NOT fast
     x + y
 }
 
 // CHECK-LABEL: @addition
 #[no_mangle]
 pub fn addition(x: f32, y: f32) -> f32 {
-// CHECK: fadd fast float
-    unsafe {
-        fadd_fast(x, y)
-    }
+    // CHECK: fadd fast float
+    unsafe { fadd_fast(x, y) }
 }
 
 // CHECK-LABEL: @subtraction
 #[no_mangle]
 pub fn subtraction(x: f32, y: f32) -> f32 {
-// CHECK: fsub fast float
-    unsafe {
-        fsub_fast(x, y)
-    }
+    // CHECK: fsub fast float
+    unsafe { fsub_fast(x, y) }
 }
 
 // CHECK-LABEL: @multiplication
 #[no_mangle]
 pub fn multiplication(x: f32, y: f32) -> f32 {
-// CHECK: fmul fast float
-    unsafe {
-        fmul_fast(x, y)
-    }
+    // CHECK: fmul fast float
+    unsafe { fmul_fast(x, y) }
 }
 
 // CHECK-LABEL: @division
 #[no_mangle]
 pub fn division(x: f32, y: f32) -> f32 {
-// CHECK: fdiv fast float
-    unsafe {
-        fdiv_fast(x, y)
-    }
+    // CHECK: fdiv fast float
+    unsafe { fdiv_fast(x, y) }
 }
diff --git a/src/test/codegen/function-arguments.rs b/src/test/codegen/function-arguments.rs
index c373cdb76c5c7..b090ec6ec6924 100644
--- a/src/test/codegen/function-arguments.rs
+++ b/src/test/codegen/function-arguments.rs
@@ -14,133 +14,116 @@
 #![feature(allocator)]
 
 pub struct S {
-  _field: [i64; 4],
+    _field: [i64; 4],
 }
 
 pub struct UnsafeInner {
-  _field: std::cell::UnsafeCell<i16>,
+    _field: std::cell::UnsafeCell<i16>,
 }
 
 // CHECK: zeroext i1 @boolean(i1 zeroext)
 #[no_mangle]
 pub fn boolean(x: bool) -> bool {
-  x
+    x
 }
 
 // CHECK: @readonly_borrow(i32* noalias readonly dereferenceable(4))
 // FIXME #25759 This should also have `nocapture`
 #[no_mangle]
-pub fn readonly_borrow(_: &i32) {
-}
+pub fn readonly_borrow(_: &i32) {}
 
 // CHECK: @static_borrow(i32* noalias readonly dereferenceable(4))
 // static borrow may be captured
 #[no_mangle]
-pub fn static_borrow(_: &'static i32) {
-}
+pub fn static_borrow(_: &'static i32) {}
 
 // CHECK: @named_borrow(i32* noalias readonly dereferenceable(4))
 // borrow with named lifetime may be captured
 #[no_mangle]
-pub fn named_borrow<'r>(_: &'r i32) {
-}
+pub fn named_borrow<'r>(_: &'r i32) {}
 
 // CHECK: @unsafe_borrow(%UnsafeInner* dereferenceable(2))
 // unsafe interior means this isn't actually readonly and there may be aliases ...
 #[no_mangle]
-pub fn unsafe_borrow(_: &UnsafeInner) {
-}
+pub fn unsafe_borrow(_: &UnsafeInner) {}
 
 // CHECK: @mutable_unsafe_borrow(%UnsafeInner* dereferenceable(2))
 // ... unless this is a mutable borrow, those never alias
 // ... except that there's this LLVM bug that forces us to not use noalias, see #29485
 #[no_mangle]
-pub fn mutable_unsafe_borrow(_: &mut UnsafeInner) {
-}
+pub fn mutable_unsafe_borrow(_: &mut UnsafeInner) {}
 
 // CHECK: @mutable_borrow(i32* dereferenceable(4))
 // FIXME #25759 This should also have `nocapture`
 // ... there's this LLVM bug that forces us to not use noalias, see #29485
 #[no_mangle]
-pub fn mutable_borrow(_: &mut i32) {
-}
+pub fn mutable_borrow(_: &mut i32) {}
 
 // CHECK: @indirect_struct(%S* noalias nocapture dereferenceable(32))
 #[no_mangle]
-pub fn indirect_struct(_: S) {
-}
+pub fn indirect_struct(_: S) {}
 
 // CHECK: @borrowed_struct(%S* noalias readonly dereferenceable(32))
 // FIXME #25759 This should also have `nocapture`
 #[no_mangle]
-pub fn borrowed_struct(_: &S) {
-}
+pub fn borrowed_struct(_: &S) {}
 
 // CHECK: noalias dereferenceable(4) i32* @_box(i32* noalias dereferenceable(4))
 #[no_mangle]
 pub fn _box(x: Box<i32>) -> Box<i32> {
-  x
+    x
 }
 
 // CHECK: @struct_return(%S* noalias nocapture sret dereferenceable(32))
 #[no_mangle]
 pub fn struct_return() -> S {
-  S {
-    _field: [0, 0, 0, 0]
-  }
+    S { _field: [0, 0, 0, 0] }
 }
 
 // Hack to get the correct size for the length part in slices
 // CHECK: @helper([[USIZE:i[0-9]+]])
 #[no_mangle]
-fn helper(_: usize) {
-}
+fn helper(_: usize) {}
 
 // CHECK: @slice(i8* noalias nonnull readonly, [[USIZE]])
 // FIXME #25759 This should also have `nocapture`
 #[no_mangle]
-fn slice(_: &[u8]) {
-}
+fn slice(_: &[u8]) {}
 
 // CHECK: @mutable_slice(i8* nonnull, [[USIZE]])
 // FIXME #25759 This should also have `nocapture`
 // ... there's this LLVM bug that forces us to not use noalias, see #29485
 #[no_mangle]
-fn mutable_slice(_: &mut [u8]) {
-}
+fn mutable_slice(_: &mut [u8]) {}
 
 // CHECK: @unsafe_slice(%UnsafeInner* nonnull, [[USIZE]])
 // unsafe interior means this isn't actually readonly and there may be aliases ...
 #[no_mangle]
-pub fn unsafe_slice(_: &[UnsafeInner]) {
-}
+pub fn unsafe_slice(_: &[UnsafeInner]) {}
 
 // CHECK: @str(i8* noalias nonnull readonly, [[USIZE]])
 // FIXME #25759 This should also have `nocapture`
 #[no_mangle]
-fn str(_: &[u8]) {
-}
+fn str(_: &[u8]) {}
 
 // CHECK: @trait_borrow(i8* nonnull, void (i8*)** nonnull)
 // FIXME #25759 This should also have `nocapture`
 #[no_mangle]
-fn trait_borrow(_: &Drop) {
-}
+fn trait_borrow(_: &Drop) {}
 
 // CHECK: @trait_box(i8* noalias nonnull, void (i8*)** nonnull)
 #[no_mangle]
-fn trait_box(_: Box<Drop>) {
-}
+fn trait_box(_: Box<Drop>) {}
 
 // CHECK: { i16*, [[USIZE]] } @return_slice(i16* noalias nonnull readonly, [[USIZE]])
 #[no_mangle]
 fn return_slice(x: &[u16]) -> &[u16] {
-  x
+    x
 }
 
 // CHECK: noalias i8* @allocator()
 #[no_mangle]
 #[allocator]
 pub fn allocator() -> *const i8 {
-  std::ptr::null()
+    std::ptr::null()
 }
diff --git a/src/test/codegen/intrinsic-no-unnamed-attr.rs b/src/test/codegen/intrinsic-no-unnamed-attr.rs
index 0f239c8426575..3595bf1a526bd 100644
--- a/src/test/codegen/intrinsic-no-unnamed-attr.rs
+++ b/src/test/codegen/intrinsic-no-unnamed-attr.rs
@@ -18,5 +18,7 @@ extern "rust-intrinsic" {
 // CHECK: @llvm.sqrt.f32(float) #{{[0-9]*}}
 
 fn main() {
-    unsafe { sqrtf32(0.0f32); }
+    unsafe {
+        sqrtf32(0.0f32);
+    }
 }
diff --git a/src/test/codegen/link_section.rs b/src/test/codegen/link_section.rs
index 5ad3854c05ccc..0ac4ee950e266 100644
--- a/src/test/codegen/link_section.rs
+++ b/src/test/codegen/link_section.rs
@@ -19,7 +19,7 @@ pub static VAR1: u32 = 1;
 
 pub enum E {
     A(u32),
-    B(f32)
+    B(f32),
 }
 
 // CHECK: @VAR2 = constant {{.*}} { i32 0, i32 666, {{.*}} }, section ".test_two"
diff --git a/src/test/codegen/loads.rs b/src/test/codegen/loads.rs
index 21f23b6ea1861..1748d265fd008 100644
--- a/src/test/codegen/loads.rs
+++ b/src/test/codegen/loads.rs
@@ -13,23 +13,23 @@
 #![crate_type = "lib"]
 
 pub struct Bytes {
-  a: u8,
-  b: u8,
-  c: u8,
-  d: u8,
+    a: u8,
+    b: u8,
+    c: u8,
+    d: u8,
 }
 
 // CHECK-LABEL: @borrow
 #[no_mangle]
 pub fn borrow(x: &i32) -> &i32 {
-// CHECK: load {{(i32\*, )?}}i32** %x{{.*}}, !nonnull
+    // CHECK: load {{(i32\*, )?}}i32** %x{{.*}}, !nonnull
     x
 }
 
 // CHECK-LABEL: @_box
 #[no_mangle]
 pub fn _box(x: Box<i32>) -> i32 {
-// CHECK: load {{(i32\*, )?}}i32** %x{{.*}}, !nonnull
+    // CHECK: load {{(i32\*, )?}}i32** %x{{.*}}, !nonnull
     *x
 }
 
@@ -38,8 +38,8 @@ pub fn _box(x: Box<i32>) -> i32 {
 // dependent alignment
 #[no_mangle]
 pub fn small_array_alignment(x: [i8; 4]) -> [i8; 4] {
-// CHECK: [[VAR:%[0-9]+]] = load {{(i32, )?}}i32* %{{.*}}, align 1
-// CHECK: ret i32 [[VAR]]
+    // CHECK: [[VAR:%[0-9]+]] = load {{(i32, )?}}i32* %{{.*}}, align 1
+    // CHECK: ret i32 [[VAR]]
     x
 }
 
@@ -48,7 +48,7 @@ pub fn small_array_alignment(x: [i8; 4]) -> [i8; 4] {
 // dependent alignment
 #[no_mangle]
 pub fn small_struct_alignment(x: Bytes) -> Bytes {
-// CHECK: [[VAR:%[0-9]+]] = load {{(i32, )?}}i32* %{{.*}}, align 1
-// CHECK: ret i32 [[VAR]]
+    // CHECK: [[VAR:%[0-9]+]] = load {{(i32, )?}}i32* %{{.*}}, align 1
+    // CHECK: ret i32 [[VAR]]
     x
 }
diff --git a/src/test/codegen/lto-removes-invokes.rs b/src/test/codegen/lto-removes-invokes.rs
index b2f43489523d1..18e3c7c0a7c4a 100644
--- a/src/test/codegen/lto-removes-invokes.rs
+++ b/src/test/codegen/lto-removes-invokes.rs
@@ -20,8 +20,8 @@ fn main() {
 fn foo() {
     let _a = Box::new(3);
     bar();
-// CHECK-LABEL: foo
-// CHECK: call {{.*}} void @bar
+    // CHECK-LABEL: foo
+    // CHECK: call {{.*}} void @bar
 }
 
 #[inline(never)]
diff --git a/src/test/codegen/match.rs b/src/test/codegen/match.rs
index ac47f6082e3e3..2ec9185b9dbc6 100644
--- a/src/test/codegen/match.rs
+++ b/src/test/codegen/match.rs
@@ -20,9 +20,9 @@ pub enum E {
 // CHECK-LABEL: @exhaustive_match
 #[no_mangle]
 pub fn exhaustive_match(e: E) {
-// CHECK: switch{{.*}}, label %[[DEFAULT:[a-zA-Z0-9_]+]]
-// CHECK: [[DEFAULT]]:
-// CHECK-NEXT: unreachable
+    // CHECK: switch{{.*}}, label %[[DEFAULT:[a-zA-Z0-9_]+]]
+    // CHECK: [[DEFAULT]]:
+    // CHECK-NEXT: unreachable
     match e {
         E::A => (),
         E::B => (),
diff --git a/src/test/codegen/mir_zst_stores.rs b/src/test/codegen/mir_zst_stores.rs
index c1acdaf703191..7273eb654b9d0 100644
--- a/src/test/codegen/mir_zst_stores.rs
+++ b/src/test/codegen/mir_zst_stores.rs
@@ -15,12 +15,14 @@
 use std::marker::PhantomData;
 
 
-struct Zst { phantom: PhantomData<Zst> }
+struct Zst {
+    phantom: PhantomData<Zst>,
+}
 
 // CHECK-LABEL: @mir
 #[no_mangle]
 #[rustc_mir]
-fn mir(){
+fn mir() {
     // CHECK-NOT: getelementptr
     // CHECK-NOT: store{{.*}}undef
     let x = Zst { phantom: PhantomData };
diff --git a/src/test/codegen/naked-functions.rs b/src/test/codegen/naked-functions.rs
index 0a600f4acad1f..a5040968029a0 100644
--- a/src/test/codegen/naked-functions.rs
+++ b/src/test/codegen/naked-functions.rs
@@ -59,11 +59,7 @@ fn naked_recursive() {
     // CHECK: call void @naked_empty()
     naked_empty();
     // CHECK: %{{[0-9]+}} = call i{{[0-9]+}} @naked_with_return()
-    naked_with_args(
-        // CHECK: %{{[0-9]+}} = call i{{[0-9]+}} @naked_with_args_and_return(i{{[0-9]+}} %{{[0-9]+}})
-        naked_with_args_and_return(
-            // CHECK: call void @naked_with_args(i{{[0-9]+}} %{{[0-9]+}})
-            naked_with_return()
-        )
-    );
+    naked_with_args(// CHECK: %{{[0-9]+}} = call i{{[0-9]+}} @naked_with_args_and_return(i{{[0-9]+}} %{{[0-9]+}})
+                    naked_with_args_and_return(// CHECK: call void @naked_with_args(i{{[0-9]+}} %{{[0-9]+}})
+                                               naked_with_return()));
 }
diff --git a/src/test/codegen/refs.rs b/src/test/codegen/refs.rs
index 36c83412e4f0f..094efd59daa68 100644
--- a/src/test/codegen/refs.rs
+++ b/src/test/codegen/refs.rs
@@ -16,8 +16,7 @@
 // Hack to get the correct size for the length part in slices
 // CHECK: @helper([[USIZE:i[0-9]+]])
 #[no_mangle]
-fn helper(_: usize) {
-}
+fn helper(_: usize) {}
 
 // CHECK-LABEL: @ref_dst
 #[no_mangle]
@@ -25,8 +24,8 @@ fn helper(_: usize) {
 pub fn ref_dst(s: &[u8]) {
     // We used to generate an extra alloca and memcpy to ref the dst, so check that we copy
     // directly to the alloca for "x"
-// CHECK: [[SRC:%[0-9]+]] = bitcast { i8*, [[USIZE]] }* %s to i8*
-// CHECK: [[DST:%[0-9]+]] = bitcast { i8*, [[USIZE]] }* %x to i8*
-// CHECK: call void @llvm.memcpy.{{.*}}(i8* [[DST]], i8* [[SRC]],
+    // CHECK: [[SRC:%[0-9]+]] = bitcast { i8*, [[USIZE]] }* %s to i8*
+    // CHECK: [[DST:%[0-9]+]] = bitcast { i8*, [[USIZE]] }* %x to i8*
+    // CHECK: call void @llvm.memcpy.{{.*}}(i8* [[DST]], i8* [[SRC]],
     let x = &*s;
 }
diff --git a/src/test/codegen/stores.rs b/src/test/codegen/stores.rs
index 8c425507975ca..7eb2b2ba8df60 100644
--- a/src/test/codegen/stores.rs
+++ b/src/test/codegen/stores.rs
@@ -14,10 +14,10 @@
 #![feature(rustc_attrs)]
 
 pub struct Bytes {
-  a: u8,
-  b: u8,
-  c: u8,
-  d: u8,
+    a: u8,
+    b: u8,
+    c: u8,
+    d: u8,
 }
 
 // CHECK-LABEL: small_array_alignment
@@ -26,8 +26,8 @@ pub struct Bytes {
 #[no_mangle]
 #[rustc_no_mir] // FIXME #27840 MIR has different codegen.
 pub fn small_array_alignment(x: &mut [i8; 4], y: [i8; 4]) {
-// CHECK: store i32 %{{.*}}, i32* %{{.*}}, align 1
-// CHECK: [[VAR:%[0-9]+]] = bitcast i32* %{{.*}} to [4 x i8]*
+    // CHECK: store i32 %{{.*}}, i32* %{{.*}}, align 1
+    // CHECK: [[VAR:%[0-9]+]] = bitcast i32* %{{.*}} to [4 x i8]*
     *x = y;
 }
 
@@ -37,7 +37,7 @@ pub fn small_array_alignment(x: &mut [i8; 4], y: [i8; 4]) {
 #[no_mangle]
 #[rustc_no_mir] // FIXME #27840 MIR has different codegen.
 pub fn small_struct_alignment(x: &mut Bytes, y: Bytes) {
-// CHECK: store i32 %{{.*}}, i32* %{{.*}}, align 1
-// CHECK: [[VAR:%[0-9]+]] = bitcast i32* %{{.*}} to %Bytes*
+    // CHECK: store i32 %{{.*}}, i32* %{{.*}}, align 1
+    // CHECK: [[VAR:%[0-9]+]] = bitcast i32* %{{.*}} to %Bytes*
     *x = y;
 }