[eddyb/rebase cleanup] s/&self./self.

eddyb · eddyb · commit 484e07c231e2 · 2018-11-16T14:15:13.000+02:00
diff --git a/src/librustc_codegen_llvm/builder.rs b/src/librustc_codegen_llvm/builder.rs
@@ -761,7 +761,7 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         }).collect::<Vec<_>>();
 
         debug!("Asm Output Type: {:?}", output);
-        let fty = &self.cx().type_func(&argtys[..], output);
+        let fty = self.cx().type_func(&argtys[..], output);
         unsafe {
             // Ask LLVM to verify that the constraints are well-formed.
             let constraints_ok = llvm::LLVMRustInlineAsmVerify(fty, cons);
@@ -896,9 +896,9 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
     fn vector_splat(&self, num_elts: usize, elt: &'ll Value) -> &'ll Value {
         unsafe {
             let elt_ty = self.cx.val_ty(elt);
-            let undef = llvm::LLVMGetUndef(&self.cx().type_vector(elt_ty, num_elts as u64));
+            let undef = llvm::LLVMGetUndef(self.cx().type_vector(elt_ty, num_elts as u64));
             let vec = self.insert_element(undef, elt, self.cx.const_i32(0));
-            let vec_i32_ty = &self.cx().type_vector(&self.cx().type_i32(), num_elts as u64);
+            let vec_i32_ty = self.cx().type_vector(self.cx().type_i32(), num_elts as u64);
             self.shuffle_vector(vec, undef, self.cx().const_null(vec_i32_ty))
         }
     }
@@ -1305,6 +1305,6 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
     }
 
     fn cx(&self) -> &'a CodegenCx<'ll, 'tcx> {
-        &self.cx
+        self.cx
     }
 }
diff --git a/src/librustc_codegen_llvm/common.rs b/src/librustc_codegen_llvm/common.rs
@@ -255,19 +255,19 @@ impl<'ll, 'tcx: 'll> ConstMethods for CodegenCx<'ll, 'tcx> {
     }
 
     fn const_bool(&self, val: bool) -> &'ll Value {
-        &self.const_uint(&self.type_i1(), val as u64)
+        self.const_uint(self.type_i1(), val as u64)
     }
 
     fn const_i32(&self, i: i32) -> &'ll Value {
-        &self.const_int(&self.type_i32(), i as i64)
+        self.const_int(self.type_i32(), i as i64)
     }
 
     fn const_u32(&self, i: u32) -> &'ll Value {
-        &self.const_uint(&self.type_i32(), i as u64)
+        self.const_uint(self.type_i32(), i as u64)
     }
 
     fn const_u64(&self, i: u64) -> &'ll Value {
-        &self.const_uint(&self.type_i64(), i)
+        self.const_uint(self.type_i64(), i)
     }
 
     fn const_usize(&self, i: u64) -> &'ll Value {
@@ -277,11 +277,11 @@ impl<'ll, 'tcx: 'll> ConstMethods for CodegenCx<'ll, 'tcx> {
             assert!(i < (1<<bit_size));
         }
 
-        &self.const_uint(&self.isize_ty, i)
+        self.const_uint(self.isize_ty, i)
     }
 
     fn const_u8(&self, i: u8) -> &'ll Value {
-        &self.const_uint(&self.type_i8(), i as u64)
+        self.const_uint(self.type_i8(), i as u64)
     }
 
 
@@ -293,23 +293,23 @@ impl<'ll, 'tcx: 'll> ConstMethods for CodegenCx<'ll, 'tcx> {
         null_terminated: bool,
     ) -> &'ll Value {
         unsafe {
-            if let Some(&llval) = &self.const_cstr_cache.borrow().get(&s) {
+            if let Some(&llval) = self.const_cstr_cache.borrow().get(&s) {
                 return llval;
             }
 
-            let sc = llvm::LLVMConstStringInContext(&self.llcx,
+            let sc = llvm::LLVMConstStringInContext(self.llcx,
                                                     s.as_ptr() as *const c_char,
                                                     s.len() as c_uint,
                                                     !null_terminated as Bool);
-            let sym = &self.generate_local_symbol_name("str");
-            let g = declare::define_global(&self, &sym[..], &self.val_ty(sc)).unwrap_or_else(||{
+            let sym = self.generate_local_symbol_name("str");
+            let g = declare::define_global(&self, &sym[..], self.val_ty(sc)).unwrap_or_else(||{
                 bug!("symbol `{}` is already defined", sym);
             });
             llvm::LLVMSetInitializer(g, sc);
             llvm::LLVMSetGlobalConstant(g, True);
             llvm::LLVMRustSetLinkage(g, llvm::Linkage::InternalLinkage);
 
-            &self.const_cstr_cache.borrow_mut().insert(s, g);
+            self.const_cstr_cache.borrow_mut().insert(s, g);
             g
         }
     }
@@ -318,9 +318,9 @@ impl<'ll, 'tcx: 'll> ConstMethods for CodegenCx<'ll, 'tcx> {
     // you will be kicked off fast isel. See issue #4352 for an example of this.
     fn const_str_slice(&self, s: LocalInternedString) -> &'ll Value {
         let len = s.len();
-        let cs = consts::ptrcast(&self.const_cstr(s, false),
-            &self.type_ptr_to(&self.layout_of(&self.tcx.mk_str()).llvm_type(&self)));
-        &self.const_fat_ptr(cs, &self.const_usize(len as u64))
+        let cs = consts::ptrcast(self.const_cstr(s, false),
+            self.type_ptr_to(self.layout_of(self.tcx.mk_str()).llvm_type(&self)));
+        self.const_fat_ptr(cs, self.const_usize(len as u64))
     }
 
     fn const_fat_ptr(
@@ -330,15 +330,15 @@ impl<'ll, 'tcx: 'll> ConstMethods for CodegenCx<'ll, 'tcx> {
     ) -> &'ll Value {
         assert_eq!(abi::FAT_PTR_ADDR, 0);
         assert_eq!(abi::FAT_PTR_EXTRA, 1);
-        &self.const_struct(&[ptr, meta], false)
+        self.const_struct(&[ptr, meta], false)
     }
 
     fn const_struct(
         &self,
         elts: &[&'ll Value],
         packed: bool
     ) -> &'ll Value {
-        struct_in_context(&self.llcx, elts, packed)
+        struct_in_context(self.llcx, elts, packed)
     }
 
     fn const_array(&self, ty: &'ll Type, elts: &[&'ll Value]) -> &'ll Value {
@@ -354,7 +354,7 @@ impl<'ll, 'tcx: 'll> ConstMethods for CodegenCx<'ll, 'tcx> {
     }
 
     fn const_bytes(&self, bytes: &[u8]) -> &'ll Value {
-        bytes_in_context(&self.llcx, bytes)
+        bytes_in_context(self.llcx, bytes)
     }
 
     fn const_get_elt(&self, v: &'ll Value, idx: u64) -> &'ll Value {
diff --git a/src/librustc_codegen_llvm/consts.rs b/src/librustc_codegen_llvm/consts.rs
@@ -137,16 +137,16 @@ impl StaticMethods<'tcx> for CodegenCx<'ll, 'tcx> {
     ) -> &'ll Value {
         unsafe {
             let gv = match kind {
-                Some(kind) if !&self.tcx.sess.fewer_names() => {
-                    let name = &self.generate_local_symbol_name(kind);
+                Some(kind) if !self.tcx.sess.fewer_names() => {
+                    let name = self.generate_local_symbol_name(kind);
                     let gv = declare::define_global(&self, &name[..],
-                        &self.val_ty(cv)).unwrap_or_else(||{
+                        self.val_ty(cv)).unwrap_or_else(||{
                             bug!("symbol `{}` is already defined", name);
                     });
                     llvm::LLVMRustSetLinkage(gv, llvm::Linkage::PrivateLinkage);
                     gv
                 },
-                _ => declare::define_private_global(&self, &self.val_ty(cv)),
+                _ => declare::define_private_global(&self, self.val_ty(cv)),
             };
             llvm::LLVMSetInitializer(gv, cv);
             set_global_alignment(&self, gv, align);
@@ -161,7 +161,7 @@ impl StaticMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         align: Align,
         kind: Option<&str>,
     ) -> &'ll Value {
-        if let Some(&gv) = &self.const_globals.borrow().get(&cv) {
+        if let Some(&gv) = self.const_globals.borrow().get(&cv) {
             unsafe {
                 // Upgrade the alignment in cases where the same constant is used with different
                 // alignment requirements
@@ -172,21 +172,21 @@ impl StaticMethods<'tcx> for CodegenCx<'ll, 'tcx> {
             }
             return gv;
         }
-        let gv = &self.static_addr_of_mut(cv, align, kind);
+        let gv = self.static_addr_of_mut(cv, align, kind);
         unsafe {
             llvm::LLVMSetGlobalConstant(gv, True);
         }
-        &self.const_globals.borrow_mut().insert(cv, gv);
+        self.const_globals.borrow_mut().insert(cv, gv);
         gv
     }
 
     fn get_static(&self, def_id: DefId) -> &'ll Value {
         let instance = Instance::mono(self.tcx, def_id);
-        if let Some(&g) = &self.instances.borrow().get(&instance) {
+        if let Some(&g) = self.instances.borrow().get(&instance) {
             return g;
         }
 
-        let defined_in_current_codegen_unit = &self.codegen_unit
+        let defined_in_current_codegen_unit = self.codegen_unit
                                                 .items()
                                                 .contains_key(&MonoItem::Static(def_id));
         assert!(!defined_in_current_codegen_unit,
@@ -201,8 +201,8 @@ impl StaticMethods<'tcx> for CodegenCx<'ll, 'tcx> {
 
         let g = if let Some(id) = self.tcx.hir.as_local_node_id(def_id) {
 
-            let llty = &self.layout_of(ty).llvm_type(&self);
-            let (g, attrs) = match &self.tcx.hir.get(id) {
+            let llty = self.layout_of(ty).llvm_type(&self);
+            let (g, attrs) = match self.tcx.hir.get(id) {
                 Node::Item(&hir::Item {
                     ref attrs, span, node: hir::ItemKind::Static(..), ..
                 }) => {
@@ -212,7 +212,7 @@ impl StaticMethods<'tcx> for CodegenCx<'ll, 'tcx> {
 
                     let g = declare::define_global(&self, &sym[..], llty).unwrap();
 
-                    if !&self.tcx.is_reachable_non_generic(def_id) {
+                    if !self.tcx.is_reachable_non_generic(def_id) {
                         unsafe {
                             llvm::LLVMRustSetVisibility(g, llvm::Visibility::Hidden);
                         }
@@ -224,7 +224,7 @@ impl StaticMethods<'tcx> for CodegenCx<'ll, 'tcx> {
                 Node::ForeignItem(&hir::ForeignItem {
                     ref attrs, span, node: hir::ForeignItemKind::Static(..), ..
                 }) => {
-                    let fn_attrs = &self.tcx.codegen_fn_attrs(def_id);
+                    let fn_attrs = self.tcx.codegen_fn_attrs(def_id);
                     (check_and_apply_linkage(&self, &fn_attrs, ty, sym, Some(span)), attrs)
                 }
 
@@ -242,9 +242,9 @@ impl StaticMethods<'tcx> for CodegenCx<'ll, 'tcx> {
             g
         } else {
             // FIXME(nagisa): perhaps the map of externs could be offloaded to llvm somehow?
-            debug!("get_static: sym={} item_attr={:?}", sym, &self.tcx.item_attrs(def_id));
+            debug!("get_static: sym={} item_attr={:?}", sym, self.tcx.item_attrs(def_id));
 
-            let attrs = &self.tcx.codegen_fn_attrs(def_id);
+            let attrs = self.tcx.codegen_fn_attrs(def_id);
             let g = check_and_apply_linkage(&self, &attrs, ty, sym, None);
 
             // Thread-local statics in some other crate need to *always* be linked
@@ -258,11 +258,11 @@ impl StaticMethods<'tcx> for CodegenCx<'ll, 'tcx> {
             }
 
             let needs_dll_storage_attr =
-                self.use_dll_storage_attrs && !&self.tcx.is_foreign_item(def_id) &&
+                self.use_dll_storage_attrs && !self.tcx.is_foreign_item(def_id) &&
                 // ThinLTO can't handle this workaround in all cases, so we don't
                 // emit the attrs. Instead we make them unnecessary by disallowing
                 // dynamic linking when cross-language LTO is enabled.
-                !&self.tcx.sess.opts.debugging_opts.cross_lang_lto.enabled();
+                !self.tcx.sess.opts.debugging_opts.cross_lang_lto.enabled();
 
             // If this assertion triggers, there's something wrong with commandline
             // argument validation.
@@ -281,7 +281,7 @@ impl StaticMethods<'tcx> for CodegenCx<'ll, 'tcx> {
                 // crates, so there are cases where a static with an upstream DefId
                 // is actually present in the current crate. We can find out via the
                 // is_codegened_item query.
-                if !&self.tcx.is_codegened_item(def_id) {
+                if !self.tcx.is_codegened_item(def_id) {
                     unsafe {
                         llvm::LLVMSetDLLStorageClass(g, llvm::DLLStorageClass::DllImport);
                     }
@@ -297,7 +297,7 @@ impl StaticMethods<'tcx> for CodegenCx<'ll, 'tcx> {
             }
         }
 
-        &self.instances.borrow_mut().insert(instance, g);
+        self.instances.borrow_mut().insert(instance, g);
         g
     }
 
@@ -307,15 +307,15 @@ impl StaticMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         is_mutable: bool,
     ) {
         unsafe {
-            let attrs = &self.tcx.codegen_fn_attrs(def_id);
+            let attrs = self.tcx.codegen_fn_attrs(def_id);
 
             let (v, alloc) = match ::mir::codegen_static_initializer(&self, def_id) {
                 Ok(v) => v,
                 // Error has already been reported
                 Err(_) => return,
             };
 
-            let g = &self.get_static(def_id);
+            let g = self.get_static(def_id);
 
             // boolean SSA values are i1, but they have to be stored in i8 slots,
             // otherwise some LLVM optimization passes don't work as expected
@@ -344,15 +344,15 @@ impl StaticMethods<'tcx> for CodegenCx<'ll, 'tcx> {
                 let visibility = llvm::LLVMRustGetVisibility(g);
 
                 let new_g = llvm::LLVMRustGetOrInsertGlobal(
-                    &self.llmod, name_string.as_ptr(), val_llty);
+                    self.llmod, name_string.as_ptr(), val_llty);
 
                 llvm::LLVMRustSetLinkage(new_g, linkage);
                 llvm::LLVMRustSetVisibility(new_g, visibility);
 
                 // To avoid breaking any invariants, we leave around the old
                 // global for the moment; we'll replace all references to it
                 // with the new global later. (See base::codegen_backend.)
-                &self.statics_to_rauw.borrow_mut().push((g, new_g));
+                self.statics_to_rauw.borrow_mut().push((g, new_g));
                 new_g
             };
             set_global_alignment(&self, g, self.align_of(ty));
@@ -416,19 +416,19 @@ impl StaticMethods<'tcx> for CodegenCx<'ll, 'tcx> {
             if self.tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
                 if let Some(section) = attrs.link_section {
                     let section = llvm::LLVMMDStringInContext(
-                        &self.llcx,
+                        self.llcx,
                         section.as_str().as_ptr() as *const _,
                         section.as_str().len() as c_uint,
                     );
                     let alloc = llvm::LLVMMDStringInContext(
-                        &self.llcx,
+                        self.llcx,
                         alloc.bytes.as_ptr() as *const _,
                         alloc.bytes.len() as c_uint,
                     );
                     let data = [section, alloc];
-                    let meta = llvm::LLVMMDNodeInContext(&self.llcx, data.as_ptr(), 2);
+                    let meta = llvm::LLVMMDNodeInContext(self.llcx, data.as_ptr(), 2);
                     llvm::LLVMAddNamedMetadataOperand(
-                        &self.llmod,
+                        self.llmod,
                         "wasm.custom_sections\0".as_ptr() as *const _,
                         meta,
                     );
@@ -439,8 +439,8 @@ impl StaticMethods<'tcx> for CodegenCx<'ll, 'tcx> {
 
             if attrs.flags.contains(CodegenFnAttrFlags::USED) {
                 // This static will be stored in the llvm.used variable which is an array of i8*
-                let cast = llvm::LLVMConstPointerCast(g, &self.type_i8p());
-                &self.used_statics.borrow_mut().push(cast);
+                let cast = llvm::LLVMConstPointerCast(g, self.type_i8p());
+                self.used_statics.borrow_mut().push(cast);
             }
         }
     }
diff --git a/src/librustc_codegen_llvm/context.rs b/src/librustc_codegen_llvm/context.rs

Original file line number	Diff line number	Diff line change
`@@ -761,7 +761,7 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {`
`761`	`761`	`}).collect::<Vec<_>>();`
`762`	`762`
`763`	`763`	`debug!("Asm Output Type: {:?}", output);`
`764`		`- let fty = &self.cx().type_func(&argtys[..], output);`
	`764`	`+ let fty = self.cx().type_func(&argtys[..], output);`
`765`	`765`	`unsafe {`
`766`	`766`	`// Ask LLVM to verify that the constraints are well-formed.`
`767`	`767`	`let constraints_ok = llvm::LLVMRustInlineAsmVerify(fty, cons);`
`@@ -896,9 +896,9 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {`
`896`	`896`	`fn vector_splat(&self, num_elts: usize, elt: &'ll Value) -> &'ll Value {`
`897`	`897`	`unsafe {`
`898`	`898`	`let elt_ty = self.cx.val_ty(elt);`
`899`		`- let undef = llvm::LLVMGetUndef(&self.cx().type_vector(elt_ty, num_elts as u64));`
	`899`	`+ let undef = llvm::LLVMGetUndef(self.cx().type_vector(elt_ty, num_elts as u64));`
`900`	`900`	`let vec = self.insert_element(undef, elt, self.cx.const_i32(0));`
`901`		`- let vec_i32_ty = &self.cx().type_vector(&self.cx().type_i32(), num_elts as u64);`
	`901`	`+ let vec_i32_ty = self.cx().type_vector(self.cx().type_i32(), num_elts as u64);`
`902`	`902`	`self.shuffle_vector(vec, undef, self.cx().const_null(vec_i32_ty))`
`903`	`903`	`}`
`904`	`904`	`}`
`@@ -1305,6 +1305,6 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {`
`1305`	`1305`	`}`
`1306`	`1306`
`1307`	`1307`	`fn cx(&self) -> &'a CodegenCx<'ll, 'tcx> {`
`1308`		`- &self.cx`
	`1308`	`+ self.cx`
`1309`	`1309`	`}`
`1310`	`1310`	`}`
Original file line number	Diff line number	Diff line change
`@@ -255,19 +255,19 @@ impl<'ll, 'tcx: 'll> ConstMethods for CodegenCx<'ll, 'tcx> {`
`255`	`255`	`}`
`256`	`256`
`257`	`257`	`fn const_bool(&self, val: bool) -> &'ll Value {`
`258`		`- &self.const_uint(&self.type_i1(), val as u64)`
	`258`	`+ self.const_uint(self.type_i1(), val as u64)`
`259`	`259`	`}`
`260`	`260`
`261`	`261`	`fn const_i32(&self, i: i32) -> &'ll Value {`
`262`		`- &self.const_int(&self.type_i32(), i as i64)`
	`262`	`+ self.const_int(self.type_i32(), i as i64)`
`263`	`263`	`}`
`264`	`264`
`265`	`265`	`fn const_u32(&self, i: u32) -> &'ll Value {`
`266`		`- &self.const_uint(&self.type_i32(), i as u64)`
	`266`	`+ self.const_uint(self.type_i32(), i as u64)`
`267`	`267`	`}`
`268`	`268`
`269`	`269`	`fn const_u64(&self, i: u64) -> &'ll Value {`
`270`		`- &self.const_uint(&self.type_i64(), i)`
	`270`	`+ self.const_uint(self.type_i64(), i)`
`271`	`271`	`}`
`272`	`272`
`273`	`273`	`fn const_usize(&self, i: u64) -> &'ll Value {`
`@@ -277,11 +277,11 @@ impl<'ll, 'tcx: 'll> ConstMethods for CodegenCx<'ll, 'tcx> {`
`277`	`277`	`assert!(i < (1<<bit_size));`
`278`	`278`	`}`
`279`	`279`
`280`		`- &self.const_uint(&self.isize_ty, i)`
	`280`	`+ self.const_uint(self.isize_ty, i)`
`281`	`281`	`}`
`282`	`282`
`283`	`283`	`fn const_u8(&self, i: u8) -> &'ll Value {`
`284`		`- &self.const_uint(&self.type_i8(), i as u64)`
	`284`	`+ self.const_uint(self.type_i8(), i as u64)`
`285`	`285`	`}`
`286`	`286`
`287`	`287`
`@@ -293,23 +293,23 @@ impl<'ll, 'tcx: 'll> ConstMethods for CodegenCx<'ll, 'tcx> {`
`293`	`293`	`null_terminated: bool,`
`294`	`294`	`) -> &'ll Value {`
`295`	`295`	`unsafe {`
`296`		`- if let Some(&llval) = &self.const_cstr_cache.borrow().get(&s) {`
	`296`	`+ if let Some(&llval) = self.const_cstr_cache.borrow().get(&s) {`
`297`	`297`	`return llval;`
`298`	`298`	`}`
`299`	`299`
`300`		`- let sc = llvm::LLVMConstStringInContext(&self.llcx,`
	`300`	`+ let sc = llvm::LLVMConstStringInContext(self.llcx,`
`301`	`301`	`s.as_ptr() as *const c_char,`
`302`	`302`	`s.len() as c_uint,`
`303`	`303`	`!null_terminated as Bool);`
`304`		`- let sym = &self.generate_local_symbol_name("str");`
`305`		`- let g = declare::define_global(&self, &sym[..], &self.val_ty(sc)).unwrap_or_else(\|\|{`
	`304`	`+ let sym = self.generate_local_symbol_name("str");`
	`305`	`+ let g = declare::define_global(&self, &sym[..], self.val_ty(sc)).unwrap_or_else(\|\|{`
`306`	`306`	bug!("symbol `{}` is already defined", sym);
`307`	`307`	`});`
`308`	`308`	`llvm::LLVMSetInitializer(g, sc);`
`309`	`309`	`llvm::LLVMSetGlobalConstant(g, True);`
`310`	`310`	`llvm::LLVMRustSetLinkage(g, llvm::Linkage::InternalLinkage);`
`311`	`311`
`312`		`- &self.const_cstr_cache.borrow_mut().insert(s, g);`
	`312`	`+ self.const_cstr_cache.borrow_mut().insert(s, g);`
`313`	`313`	`g`
`314`	`314`	`}`
`315`	`315`	`}`
`@@ -318,9 +318,9 @@ impl<'ll, 'tcx: 'll> ConstMethods for CodegenCx<'ll, 'tcx> {`
`318`	`318`	`// you will be kicked off fast isel. See issue #4352 for an example of this.`
`319`	`319`	`fn const_str_slice(&self, s: LocalInternedString) -> &'ll Value {`
`320`	`320`	`let len = s.len();`
`321`		`- let cs = consts::ptrcast(&self.const_cstr(s, false),`
`322`		`- &self.type_ptr_to(&self.layout_of(&self.tcx.mk_str()).llvm_type(&self)));`
`323`		`- &self.const_fat_ptr(cs, &self.const_usize(len as u64))`
	`321`	`+ let cs = consts::ptrcast(self.const_cstr(s, false),`
	`322`	`+ self.type_ptr_to(self.layout_of(self.tcx.mk_str()).llvm_type(&self)));`
	`323`	`+ self.const_fat_ptr(cs, self.const_usize(len as u64))`
`324`	`324`	`}`
`325`	`325`
`326`	`326`	`fn const_fat_ptr(`
`@@ -330,15 +330,15 @@ impl<'ll, 'tcx: 'll> ConstMethods for CodegenCx<'ll, 'tcx> {`
`330`	`330`	`) -> &'ll Value {`
`331`	`331`	`assert_eq!(abi::FAT_PTR_ADDR, 0);`
`332`	`332`	`assert_eq!(abi::FAT_PTR_EXTRA, 1);`
`333`		`- &self.const_struct(&[ptr, meta], false)`
	`333`	`+ self.const_struct(&[ptr, meta], false)`
`334`	`334`	`}`
`335`	`335`
`336`	`336`	`fn const_struct(`
`337`	`337`	`&self,`
`338`	`338`	`elts: &[&'ll Value],`
`339`	`339`	`packed: bool`
`340`	`340`	`) -> &'ll Value {`
`341`		`- struct_in_context(&self.llcx, elts, packed)`
	`341`	`+ struct_in_context(self.llcx, elts, packed)`
`342`	`342`	`}`
`343`	`343`
`344`	`344`	`fn const_array(&self, ty: &'ll Type, elts: &[&'ll Value]) -> &'ll Value {`
`@@ -354,7 +354,7 @@ impl<'ll, 'tcx: 'll> ConstMethods for CodegenCx<'ll, 'tcx> {`
`354`	`354`	`}`
`355`	`355`
`356`	`356`	`fn const_bytes(&self, bytes: &[u8]) -> &'ll Value {`
`357`		`- bytes_in_context(&self.llcx, bytes)`
	`357`	`+ bytes_in_context(self.llcx, bytes)`
`358`	`358`	`}`
`359`	`359`
`360`	`360`	`fn const_get_elt(&self, v: &'ll Value, idx: u64) -> &'ll Value {`