rustc_codegen_llvm: replace fn noname() with const UNNAMED.

eddyb · eddyb · commit 25d68344932f · 2019-06-01T21:13:08.000+03:00
diff --git a/src/librustc_codegen_llvm/builder.rs b/src/librustc_codegen_llvm/builder.rs
@@ -20,6 +20,7 @@ use rustc_codegen_ssa::mir::operand::{OperandValue, OperandRef};
 use rustc_codegen_ssa::mir::place::PlaceRef;
 use rustc_target::spec::{HasTargetSpec, Target};
 use std::borrow::Cow;
+use std::ffi::CStr;
 use std::ops::{Deref, Range};
 use std::ptr;
 use std::iter::TrustedLen;
@@ -39,12 +40,15 @@ impl Drop for Builder<'a, 'll, 'tcx> {
     }
 }
 
-// This is a really awful way to get a zero-length c-string, but better (and a
-// lot more efficient) than doing str::as_c_str("", ...) every time.
-fn noname() -> *const c_char {
-    static CNULL: c_char = 0;
-    &CNULL
-}
+// FIXME(eddyb) use a checked constructor when they become `const fn`.
+const EMPTY_C_STR: &CStr = unsafe {
+    CStr::from_bytes_with_nul_unchecked(b"\0")
+};
+
+/// Empty string, to be used where LLVM expects an instruction name, indicating
+/// that the instruction is to be left unnamed (i.e. numbered, in textual IR).
+// FIXME(eddyb) pass `&CStr` directly to FFI once it's a thin pointer.
+const UNNAMED: *const c_char = EMPTY_C_STR.as_ptr();
 
 impl BackendTypes for Builder<'_, 'll, 'tcx> {
     type Value = <CodegenCx<'ll, 'tcx> as BackendTypes>::Value;
@@ -104,7 +108,7 @@ macro_rules! builder_methods_for_value_instructions {
     ($($name:ident($($arg:ident),*) => $llvm_capi:ident),+ $(,)?) => {
         $(fn $name(&mut self, $($arg: &'ll Value),*) -> &'ll Value {
             unsafe {
-                llvm::$llvm_capi(self.llbuilder, $($arg,)* noname())
+                llvm::$llvm_capi(self.llbuilder, $($arg,)* UNNAMED)
             }
         })*
     }
@@ -227,7 +231,7 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
                                       then,
                                       catch,
                                       bundle,
-                                      noname())
+                                      UNNAMED)
         }
     }
 
@@ -265,39 +269,39 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
 
     fn fadd_fast(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
         unsafe {
-            let instr = llvm::LLVMBuildFAdd(self.llbuilder, lhs, rhs, noname());
+            let instr = llvm::LLVMBuildFAdd(self.llbuilder, lhs, rhs, UNNAMED);
             llvm::LLVMRustSetHasUnsafeAlgebra(instr);
             instr
         }
     }
 
     fn fsub_fast(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
         unsafe {
-            let instr = llvm::LLVMBuildFSub(self.llbuilder, lhs, rhs, noname());
+            let instr = llvm::LLVMBuildFSub(self.llbuilder, lhs, rhs, UNNAMED);
             llvm::LLVMRustSetHasUnsafeAlgebra(instr);
             instr
         }
     }
 
     fn fmul_fast(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
         unsafe {
-            let instr = llvm::LLVMBuildFMul(self.llbuilder, lhs, rhs, noname());
+            let instr = llvm::LLVMBuildFMul(self.llbuilder, lhs, rhs, UNNAMED);
             llvm::LLVMRustSetHasUnsafeAlgebra(instr);
             instr
         }
     }
 
     fn fdiv_fast(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
         unsafe {
-            let instr = llvm::LLVMBuildFDiv(self.llbuilder, lhs, rhs, noname());
+            let instr = llvm::LLVMBuildFDiv(self.llbuilder, lhs, rhs, UNNAMED);
             llvm::LLVMRustSetHasUnsafeAlgebra(instr);
             instr
         }
     }
 
     fn frem_fast(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
         unsafe {
-            let instr = llvm::LLVMBuildFRem(self.llbuilder, lhs, rhs, noname());
+            let instr = llvm::LLVMBuildFRem(self.llbuilder, lhs, rhs, UNNAMED);
             llvm::LLVMRustSetHasUnsafeAlgebra(instr);
             instr
         }
@@ -388,7 +392,7 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
     fn dynamic_alloca(&mut self, ty: &'ll Type, name: &str, align: Align) -> &'ll Value {
         unsafe {
             let alloca = if name.is_empty() {
-                llvm::LLVMBuildAlloca(self.llbuilder, ty, noname())
+                llvm::LLVMBuildAlloca(self.llbuilder, ty, UNNAMED)
             } else {
                 let name = SmallCStr::new(name);
                 llvm::LLVMBuildAlloca(self.llbuilder, ty,
@@ -406,7 +410,7 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
                         align: Align) -> &'ll Value {
         unsafe {
             let alloca = if name.is_empty() {
-                llvm::LLVMBuildArrayAlloca(self.llbuilder, ty, len, noname())
+                llvm::LLVMBuildArrayAlloca(self.llbuilder, ty, len, UNNAMED)
             } else {
                 let name = SmallCStr::new(name);
                 llvm::LLVMBuildArrayAlloca(self.llbuilder, ty, len,
@@ -419,15 +423,15 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
 
     fn load(&mut self, ptr: &'ll Value, align: Align) -> &'ll Value {
         unsafe {
-            let load = llvm::LLVMBuildLoad(self.llbuilder, ptr, noname());
+            let load = llvm::LLVMBuildLoad(self.llbuilder, ptr, UNNAMED);
             llvm::LLVMSetAlignment(load, align.bytes() as c_uint);
             load
         }
     }
 
     fn volatile_load(&mut self, ptr: &'ll Value) -> &'ll Value {
         unsafe {
-            let load = llvm::LLVMBuildLoad(self.llbuilder, ptr, noname());
+            let load = llvm::LLVMBuildLoad(self.llbuilder, ptr, UNNAMED);
             llvm::LLVMSetVolatile(load, llvm::True);
             load
         }
@@ -443,7 +447,7 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
             let load = llvm::LLVMRustBuildAtomicLoad(
                 self.llbuilder,
                 ptr,
-                noname(),
+                UNNAMED,
                 AtomicOrdering::from_generic(order),
             );
             // LLVM requires the alignment of atomic loads to be at least the size of the type.
@@ -646,88 +650,88 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
     fn gep(&mut self, ptr: &'ll Value, indices: &[&'ll Value]) -> &'ll Value {
         unsafe {
             llvm::LLVMBuildGEP(self.llbuilder, ptr, indices.as_ptr(),
-                               indices.len() as c_uint, noname())
+                               indices.len() as c_uint, UNNAMED)
         }
     }
 
     fn inbounds_gep(&mut self, ptr: &'ll Value, indices: &[&'ll Value]) -> &'ll Value {
         unsafe {
             llvm::LLVMBuildInBoundsGEP(
-                self.llbuilder, ptr, indices.as_ptr(), indices.len() as c_uint, noname())
+                self.llbuilder, ptr, indices.as_ptr(), indices.len() as c_uint, UNNAMED)
         }
     }
 
     fn struct_gep(&mut self, ptr: &'ll Value, idx: u64) -> &'ll Value {
         assert_eq!(idx as c_uint as u64, idx);
         unsafe {
-            llvm::LLVMBuildStructGEP(self.llbuilder, ptr, idx as c_uint, noname())
+            llvm::LLVMBuildStructGEP(self.llbuilder, ptr, idx as c_uint, UNNAMED)
         }
     }
 
     /* Casts */
     fn trunc(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {
         unsafe {
-            llvm::LLVMBuildTrunc(self.llbuilder, val, dest_ty, noname())
+            llvm::LLVMBuildTrunc(self.llbuilder, val, dest_ty, UNNAMED)
         }
     }
 
     fn sext(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {
         unsafe {
-            llvm::LLVMBuildSExt(self.llbuilder, val, dest_ty, noname())
+            llvm::LLVMBuildSExt(self.llbuilder, val, dest_ty, UNNAMED)
         }
     }
 
     fn fptoui(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {
         unsafe {
-            llvm::LLVMBuildFPToUI(self.llbuilder, val, dest_ty, noname())
+            llvm::LLVMBuildFPToUI(self.llbuilder, val, dest_ty, UNNAMED)
         }
     }
 
     fn fptosi(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {
         unsafe {
-            llvm::LLVMBuildFPToSI(self.llbuilder, val, dest_ty,noname())
+            llvm::LLVMBuildFPToSI(self.llbuilder, val, dest_ty,UNNAMED)
         }
     }
 
     fn uitofp(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {
         unsafe {
-            llvm::LLVMBuildUIToFP(self.llbuilder, val, dest_ty, noname())
+            llvm::LLVMBuildUIToFP(self.llbuilder, val, dest_ty, UNNAMED)
         }
     }
 
     fn sitofp(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {
         unsafe {
-            llvm::LLVMBuildSIToFP(self.llbuilder, val, dest_ty, noname())
+            llvm::LLVMBuildSIToFP(self.llbuilder, val, dest_ty, UNNAMED)
         }
     }
 
     fn fptrunc(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {
         unsafe {
-            llvm::LLVMBuildFPTrunc(self.llbuilder, val, dest_ty, noname())
+            llvm::LLVMBuildFPTrunc(self.llbuilder, val, dest_ty, UNNAMED)
         }
     }
 
     fn fpext(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {
         unsafe {
-            llvm::LLVMBuildFPExt(self.llbuilder, val, dest_ty, noname())
+            llvm::LLVMBuildFPExt(self.llbuilder, val, dest_ty, UNNAMED)
         }
     }
 
     fn ptrtoint(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {
         unsafe {
-            llvm::LLVMBuildPtrToInt(self.llbuilder, val, dest_ty, noname())
+            llvm::LLVMBuildPtrToInt(self.llbuilder, val, dest_ty, UNNAMED)
         }
     }
 
     fn inttoptr(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {
         unsafe {
-            llvm::LLVMBuildIntToPtr(self.llbuilder, val, dest_ty, noname())
+            llvm::LLVMBuildIntToPtr(self.llbuilder, val, dest_ty, UNNAMED)
         }
     }
 
     fn bitcast(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {
         unsafe {
-            llvm::LLVMBuildBitCast(self.llbuilder, val, dest_ty, noname())
+            llvm::LLVMBuildBitCast(self.llbuilder, val, dest_ty, UNNAMED)
         }
     }
 
@@ -740,21 +744,21 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
 
     fn pointercast(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {
         unsafe {
-            llvm::LLVMBuildPointerCast(self.llbuilder, val, dest_ty, noname())
+            llvm::LLVMBuildPointerCast(self.llbuilder, val, dest_ty, UNNAMED)
         }
     }
 
     /* Comparisons */
     fn icmp(&mut self, op: IntPredicate, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
         let op = llvm::IntPredicate::from_generic(op);
         unsafe {
-            llvm::LLVMBuildICmp(self.llbuilder, op as c_uint, lhs, rhs, noname())
+            llvm::LLVMBuildICmp(self.llbuilder, op as c_uint, lhs, rhs, UNNAMED)
         }
     }
 
     fn fcmp(&mut self, op: RealPredicate, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
         unsafe {
-            llvm::LLVMBuildFCmp(self.llbuilder, op as c_uint, lhs, rhs, noname())
+            llvm::LLVMBuildFCmp(self.llbuilder, op as c_uint, lhs, rhs, UNNAMED)
         }
     }
 
@@ -822,20 +826,20 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         else_val: &'ll Value,
     ) -> &'ll Value {
         unsafe {
-            llvm::LLVMBuildSelect(self.llbuilder, cond, then_val, else_val, noname())
+            llvm::LLVMBuildSelect(self.llbuilder, cond, then_val, else_val, UNNAMED)
         }
     }
 
     #[allow(dead_code)]
     fn va_arg(&mut self, list: &'ll Value, ty: &'ll Type) -> &'ll Value {
         unsafe {
-            llvm::LLVMBuildVAArg(self.llbuilder, list, ty, noname())
+            llvm::LLVMBuildVAArg(self.llbuilder, list, ty, UNNAMED)
         }
     }
 
     fn extract_element(&mut self, vec: &'ll Value, idx: &'ll Value) -> &'ll Value {
         unsafe {
-            llvm::LLVMBuildExtractElement(self.llbuilder, vec, idx, noname())
+            llvm::LLVMBuildExtractElement(self.llbuilder, vec, idx, UNNAMED)
         }
     }
 
@@ -852,7 +856,7 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
     fn extract_value(&mut self, agg_val: &'ll Value, idx: u64) -> &'ll Value {
         assert_eq!(idx as c_uint as u64, idx);
         unsafe {
-            llvm::LLVMBuildExtractValue(self.llbuilder, agg_val, idx as c_uint, noname())
+            llvm::LLVMBuildExtractValue(self.llbuilder, agg_val, idx as c_uint, UNNAMED)
         }
     }
 
@@ -861,15 +865,15 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         assert_eq!(idx as c_uint as u64, idx);
         unsafe {
             llvm::LLVMBuildInsertValue(self.llbuilder, agg_val, elt, idx as c_uint,
-                                       noname())
+                                       UNNAMED)
         }
     }
 
     fn landing_pad(&mut self, ty: &'ll Type, pers_fn: &'ll Value,
                        num_clauses: usize) -> &'ll Value {
         unsafe {
             llvm::LLVMBuildLandingPad(self.llbuilder, ty, pers_fn,
-                                      num_clauses as c_uint, noname())
+                                      num_clauses as c_uint, UNNAMED)
         }
     }
 
@@ -1039,14 +1043,14 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
                 llfn,
                 args.as_ptr() as *const &llvm::Value,
                 args.len() as c_uint,
-                bundle, noname()
+                bundle, UNNAMED
             )
         }
     }
 
     fn zext(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {
         unsafe {
-            llvm::LLVMBuildZExt(self.llbuilder, val, dest_ty, noname())
+            llvm::LLVMBuildZExt(self.llbuilder, val, dest_ty, UNNAMED)
         }
     }
 
@@ -1128,7 +1132,7 @@ impl Builder<'a, 'll, 'tcx> {
         idx: &'ll Value,
     ) -> &'ll Value {
         unsafe {
-            llvm::LLVMBuildInsertElement(self.llbuilder, vec, elt, idx, noname())
+            llvm::LLVMBuildInsertElement(self.llbuilder, vec, elt, idx, UNNAMED)
         }
     }
 
@@ -1139,7 +1143,7 @@ impl Builder<'a, 'll, 'tcx> {
         mask: &'ll Value,
     ) -> &'ll Value {
         unsafe {
-            llvm::LLVMBuildShuffleVector(self.llbuilder, v1, v2, mask, noname())
+            llvm::LLVMBuildShuffleVector(self.llbuilder, v1, v2, mask, UNNAMED)
         }
     }
 
@@ -1281,7 +1285,7 @@ impl Builder<'a, 'll, 'tcx> {
 
     pub fn va_arg(&mut self, list: &'ll Value, ty: &'ll Type) -> &'ll Value {
         unsafe {
-            llvm::LLVMBuildVAArg(self.llbuilder, list, ty, noname())
+            llvm::LLVMBuildVAArg(self.llbuilder, list, ty, UNNAMED)
         }
     }
 
@@ -1304,7 +1308,7 @@ impl Builder<'a, 'll, 'tcx> {
     fn phi(&mut self, ty: &'ll Type, vals: &[&'ll Value], bbs: &[&'ll BasicBlock]) -> &'ll Value {
         assert_eq!(vals.len(), bbs.len());
         let phi = unsafe {
-            llvm::LLVMBuildPhi(self.llbuilder, ty, noname())
+            llvm::LLVMBuildPhi(self.llbuilder, ty, UNNAMED)
         };
         unsafe {
             llvm::LLVMAddIncoming(phi, vals.as_ptr(),
diff --git a/src/librustc_codegen_llvm/lib.rs b/src/librustc_codegen_llvm/lib.rs
@@ -8,6 +8,7 @@
 
 #![feature(box_patterns)]
 #![feature(box_syntax)]
+#![feature(const_cstr_unchecked)]
 #![feature(crate_visibility_modifier)]
 #![feature(custom_attribute)]
 #![feature(extern_types)]

Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,7 @@ use rustc_codegen_ssa::mir::operand::{OperandValue, OperandRef};`
`20`	`20`	`use rustc_codegen_ssa::mir::place::PlaceRef;`
`21`	`21`	`use rustc_target::spec::{HasTargetSpec, Target};`
`22`	`22`	`use std::borrow::Cow;`
	`23`	`+use std::ffi::CStr;`
`23`	`24`	`use std::ops::{Deref, Range};`
`24`	`25`	`use std::ptr;`
`25`	`26`	`use std::iter::TrustedLen;`
`@@ -39,12 +40,15 @@ impl Drop for Builder<'a, 'll, 'tcx> {`
`39`	`40`	`}`
`40`	`41`	`}`
`41`	`42`
`42`		`-// This is a really awful way to get a zero-length c-string, but better (and a`
`43`		`-// lot more efficient) than doing str::as_c_str("", ...) every time.`
`44`		`-fn noname() -> *const c_char {`
`45`		`- static CNULL: c_char = 0;`
`46`		`- &CNULL`
`47`		`-}`
	`43`	+// FIXME(eddyb) use a checked constructor when they become `const fn`.
	`44`	`+const EMPTY_C_STR: &CStr = unsafe {`
	`45`	`+ CStr::from_bytes_with_nul_unchecked(b"\0")`
	`46`	`+};`
	`47`	`+`
	`48`	`+/// Empty string, to be used where LLVM expects an instruction name, indicating`
	`49`	`+/// that the instruction is to be left unnamed (i.e. numbered, in textual IR).`
	`50`	+// FIXME(eddyb) pass `&CStr` directly to FFI once it's a thin pointer.
	`51`	`+const UNNAMED: *const c_char = EMPTY_C_STR.as_ptr();`
`48`	`52`
`49`	`53`	`impl BackendTypes for Builder<'_, 'll, 'tcx> {`
`50`	`54`	`type Value = <CodegenCx<'ll, 'tcx> as BackendTypes>::Value;`
`@@ -104,7 +108,7 @@ macro_rules! builder_methods_for_value_instructions {`
`104`	`108`	`($($name:ident($($arg:ident),*) => $llvm_capi:ident),+ $(,)?) => {`
`105`	`109`	`$(fn $name(&mut self, $($arg: &'ll Value),*) -> &'ll Value {`
`106`	`110`	`unsafe {`
`107`		`- llvm::$llvm_capi(self.llbuilder, $($arg,)* noname())`
	`111`	`+ llvm::$llvm_capi(self.llbuilder, $($arg,)* UNNAMED)`
`108`	`112`	`}`
`109`	`113`	`})*`
`110`	`114`	`}`
`@@ -227,7 +231,7 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {`
`227`	`231`	`then,`
`228`	`232`	`catch,`
`229`	`233`	`bundle,`
`230`		`- noname())`
	`234`	`+ UNNAMED)`
`231`	`235`	`}`
`232`	`236`	`}`
`233`	`237`
`@@ -265,39 +269,39 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {`
`265`	`269`
`266`	`270`	`fn fadd_fast(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {`
`267`	`271`	`unsafe {`
`268`		`- let instr = llvm::LLVMBuildFAdd(self.llbuilder, lhs, rhs, noname());`
	`272`	`+ let instr = llvm::LLVMBuildFAdd(self.llbuilder, lhs, rhs, UNNAMED);`
`269`	`273`	`llvm::LLVMRustSetHasUnsafeAlgebra(instr);`
`270`	`274`	`instr`
`271`	`275`	`}`
`272`	`276`	`}`
`273`	`277`
`274`	`278`	`fn fsub_fast(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {`
`275`	`279`	`unsafe {`
`276`		`- let instr = llvm::LLVMBuildFSub(self.llbuilder, lhs, rhs, noname());`
	`280`	`+ let instr = llvm::LLVMBuildFSub(self.llbuilder, lhs, rhs, UNNAMED);`
`277`	`281`	`llvm::LLVMRustSetHasUnsafeAlgebra(instr);`
`278`	`282`	`instr`
`279`	`283`	`}`
`280`	`284`	`}`
`281`	`285`
`282`	`286`	`fn fmul_fast(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {`
`283`	`287`	`unsafe {`
`284`		`- let instr = llvm::LLVMBuildFMul(self.llbuilder, lhs, rhs, noname());`
	`288`	`+ let instr = llvm::LLVMBuildFMul(self.llbuilder, lhs, rhs, UNNAMED);`
`285`	`289`	`llvm::LLVMRustSetHasUnsafeAlgebra(instr);`
`286`	`290`	`instr`
`287`	`291`	`}`
`288`	`292`	`}`
`289`	`293`
`290`	`294`	`fn fdiv_fast(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {`
`291`	`295`	`unsafe {`
`292`		`- let instr = llvm::LLVMBuildFDiv(self.llbuilder, lhs, rhs, noname());`
	`296`	`+ let instr = llvm::LLVMBuildFDiv(self.llbuilder, lhs, rhs, UNNAMED);`
`293`	`297`	`llvm::LLVMRustSetHasUnsafeAlgebra(instr);`
`294`	`298`	`instr`
`295`	`299`	`}`
`296`	`300`	`}`
`297`	`301`
`298`	`302`	`fn frem_fast(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {`
`299`	`303`	`unsafe {`
`300`		`- let instr = llvm::LLVMBuildFRem(self.llbuilder, lhs, rhs, noname());`
	`304`	`+ let instr = llvm::LLVMBuildFRem(self.llbuilder, lhs, rhs, UNNAMED);`
`301`	`305`	`llvm::LLVMRustSetHasUnsafeAlgebra(instr);`
`302`	`306`	`instr`
`303`	`307`	`}`
`@@ -388,7 +392,7 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {`
`388`	`392`	`fn dynamic_alloca(&mut self, ty: &'ll Type, name: &str, align: Align) -> &'ll Value {`
`389`	`393`	`unsafe {`
`390`	`394`	`let alloca = if name.is_empty() {`
`391`		`- llvm::LLVMBuildAlloca(self.llbuilder, ty, noname())`
	`395`	`+ llvm::LLVMBuildAlloca(self.llbuilder, ty, UNNAMED)`
`392`	`396`	`} else {`
`393`	`397`	`let name = SmallCStr::new(name);`
`394`	`398`	`llvm::LLVMBuildAlloca(self.llbuilder, ty,`
`@@ -406,7 +410,7 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {`
`406`	`410`	`align: Align) -> &'ll Value {`
`407`	`411`	`unsafe {`
`408`	`412`	`let alloca = if name.is_empty() {`
`409`		`- llvm::LLVMBuildArrayAlloca(self.llbuilder, ty, len, noname())`
	`413`	`+ llvm::LLVMBuildArrayAlloca(self.llbuilder, ty, len, UNNAMED)`
`410`	`414`	`} else {`
`411`	`415`	`let name = SmallCStr::new(name);`
`412`	`416`	`llvm::LLVMBuildArrayAlloca(self.llbuilder, ty, len,`
`@@ -419,15 +423,15 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {`
`419`	`423`
`420`	`424`	`fn load(&mut self, ptr: &'ll Value, align: Align) -> &'ll Value {`
`421`	`425`	`unsafe {`
`422`		`- let load = llvm::LLVMBuildLoad(self.llbuilder, ptr, noname());`
	`426`	`+ let load = llvm::LLVMBuildLoad(self.llbuilder, ptr, UNNAMED);`
`423`	`427`	`llvm::LLVMSetAlignment(load, align.bytes() as c_uint);`
`424`	`428`	`load`
`425`	`429`	`}`
`426`	`430`	`}`
`427`	`431`
`428`	`432`	`fn volatile_load(&mut self, ptr: &'ll Value) -> &'ll Value {`
`429`	`433`	`unsafe {`
`430`		`- let load = llvm::LLVMBuildLoad(self.llbuilder, ptr, noname());`
	`434`	`+ let load = llvm::LLVMBuildLoad(self.llbuilder, ptr, UNNAMED);`
`431`	`435`	`llvm::LLVMSetVolatile(load, llvm::True);`
`432`	`436`	`load`
`433`	`437`	`}`
`@@ -443,7 +447,7 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {`
`443`	`447`	`let load = llvm::LLVMRustBuildAtomicLoad(`
`444`	`448`	`self.llbuilder,`
`445`	`449`	`ptr,`
`446`		`- noname(),`
	`450`	`+ UNNAMED,`
`447`	`451`	`AtomicOrdering::from_generic(order),`
`448`	`452`	`);`
`449`	`453`	`// LLVM requires the alignment of atomic loads to be at least the size of the type.`
`@@ -646,88 +650,88 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {`
`646`	`650`	`fn gep(&mut self, ptr: &'ll Value, indices: &[&'ll Value]) -> &'ll Value {`
`647`	`651`	`unsafe {`
`648`	`652`	`llvm::LLVMBuildGEP(self.llbuilder, ptr, indices.as_ptr(),`
`649`		`- indices.len() as c_uint, noname())`
	`653`	`+ indices.len() as c_uint, UNNAMED)`
`650`	`654`	`}`
`651`	`655`	`}`
`652`	`656`
`653`	`657`	`fn inbounds_gep(&mut self, ptr: &'ll Value, indices: &[&'ll Value]) -> &'ll Value {`
`654`	`658`	`unsafe {`
`655`	`659`	`llvm::LLVMBuildInBoundsGEP(`
`656`		`- self.llbuilder, ptr, indices.as_ptr(), indices.len() as c_uint, noname())`
	`660`	`+ self.llbuilder, ptr, indices.as_ptr(), indices.len() as c_uint, UNNAMED)`
`657`	`661`	`}`
`658`	`662`	`}`
`659`	`663`
`660`	`664`	`fn struct_gep(&mut self, ptr: &'ll Value, idx: u64) -> &'ll Value {`
`661`	`665`	`assert_eq!(idx as c_uint as u64, idx);`
`662`	`666`	`unsafe {`
`663`		`- llvm::LLVMBuildStructGEP(self.llbuilder, ptr, idx as c_uint, noname())`
	`667`	`+ llvm::LLVMBuildStructGEP(self.llbuilder, ptr, idx as c_uint, UNNAMED)`
`664`	`668`	`}`
`665`	`669`	`}`
`666`	`670`
`667`	`671`	`/* Casts */`
`668`	`672`	`fn trunc(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {`
`669`	`673`	`unsafe {`
`670`		`- llvm::LLVMBuildTrunc(self.llbuilder, val, dest_ty, noname())`
	`674`	`+ llvm::LLVMBuildTrunc(self.llbuilder, val, dest_ty, UNNAMED)`
`671`	`675`	`}`
`672`	`676`	`}`
`673`	`677`
`674`	`678`	`fn sext(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {`
`675`	`679`	`unsafe {`
`676`		`- llvm::LLVMBuildSExt(self.llbuilder, val, dest_ty, noname())`
	`680`	`+ llvm::LLVMBuildSExt(self.llbuilder, val, dest_ty, UNNAMED)`
`677`	`681`	`}`
`678`	`682`	`}`
`679`	`683`
`680`	`684`	`fn fptoui(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {`
`681`	`685`	`unsafe {`
`682`		`- llvm::LLVMBuildFPToUI(self.llbuilder, val, dest_ty, noname())`
	`686`	`+ llvm::LLVMBuildFPToUI(self.llbuilder, val, dest_ty, UNNAMED)`
`683`	`687`	`}`
`684`	`688`	`}`
`685`	`689`
`686`	`690`	`fn fptosi(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {`
`687`	`691`	`unsafe {`
`688`		`- llvm::LLVMBuildFPToSI(self.llbuilder, val, dest_ty,noname())`
	`692`	`+ llvm::LLVMBuildFPToSI(self.llbuilder, val, dest_ty,UNNAMED)`
`689`	`693`	`}`
`690`	`694`	`}`
`691`	`695`
`692`	`696`	`fn uitofp(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {`
`693`	`697`	`unsafe {`
`694`		`- llvm::LLVMBuildUIToFP(self.llbuilder, val, dest_ty, noname())`
	`698`	`+ llvm::LLVMBuildUIToFP(self.llbuilder, val, dest_ty, UNNAMED)`
`695`	`699`	`}`
`696`	`700`	`}`
`697`	`701`
`698`	`702`	`fn sitofp(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {`
`699`	`703`	`unsafe {`
`700`		`- llvm::LLVMBuildSIToFP(self.llbuilder, val, dest_ty, noname())`
	`704`	`+ llvm::LLVMBuildSIToFP(self.llbuilder, val, dest_ty, UNNAMED)`
`701`	`705`	`}`
`702`	`706`	`}`
`703`	`707`
`704`	`708`	`fn fptrunc(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {`
`705`	`709`	`unsafe {`
`706`		`- llvm::LLVMBuildFPTrunc(self.llbuilder, val, dest_ty, noname())`
	`710`	`+ llvm::LLVMBuildFPTrunc(self.llbuilder, val, dest_ty, UNNAMED)`
`707`	`711`	`}`
`708`	`712`	`}`
`709`	`713`
`710`	`714`	`fn fpext(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {`
`711`	`715`	`unsafe {`
`712`		`- llvm::LLVMBuildFPExt(self.llbuilder, val, dest_ty, noname())`
	`716`	`+ llvm::LLVMBuildFPExt(self.llbuilder, val, dest_ty, UNNAMED)`
`713`	`717`	`}`
`714`	`718`	`}`
`715`	`719`
`716`	`720`	`fn ptrtoint(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {`
`717`	`721`	`unsafe {`
`718`		`- llvm::LLVMBuildPtrToInt(self.llbuilder, val, dest_ty, noname())`
	`722`	`+ llvm::LLVMBuildPtrToInt(self.llbuilder, val, dest_ty, UNNAMED)`
`719`	`723`	`}`
`720`	`724`	`}`
`721`	`725`
`722`	`726`	`fn inttoptr(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {`
`723`	`727`	`unsafe {`
`724`		`- llvm::LLVMBuildIntToPtr(self.llbuilder, val, dest_ty, noname())`
	`728`	`+ llvm::LLVMBuildIntToPtr(self.llbuilder, val, dest_ty, UNNAMED)`
`725`	`729`	`}`
`726`	`730`	`}`
`727`	`731`
`728`	`732`	`fn bitcast(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {`
`729`	`733`	`unsafe {`
`730`		`- llvm::LLVMBuildBitCast(self.llbuilder, val, dest_ty, noname())`
	`734`	`+ llvm::LLVMBuildBitCast(self.llbuilder, val, dest_ty, UNNAMED)`
`731`	`735`	`}`
`732`	`736`	`}`
`733`	`737`
`@@ -740,21 +744,21 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {`
`740`	`744`
`741`	`745`	`fn pointercast(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {`
`742`	`746`	`unsafe {`
`743`		`- llvm::LLVMBuildPointerCast(self.llbuilder, val, dest_ty, noname())`
	`747`	`+ llvm::LLVMBuildPointerCast(self.llbuilder, val, dest_ty, UNNAMED)`
`744`	`748`	`}`
`745`	`749`	`}`
`746`	`750`
`747`	`751`	`/* Comparisons */`
`748`	`752`	`fn icmp(&mut self, op: IntPredicate, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {`
`749`	`753`	`let op = llvm::IntPredicate::from_generic(op);`
`750`	`754`	`unsafe {`
`751`		`- llvm::LLVMBuildICmp(self.llbuilder, op as c_uint, lhs, rhs, noname())`
	`755`	`+ llvm::LLVMBuildICmp(self.llbuilder, op as c_uint, lhs, rhs, UNNAMED)`
`752`	`756`	`}`
`753`	`757`	`}`
`754`	`758`
`755`	`759`	`fn fcmp(&mut self, op: RealPredicate, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {`
`756`	`760`	`unsafe {`
`757`		`- llvm::LLVMBuildFCmp(self.llbuilder, op as c_uint, lhs, rhs, noname())`
	`761`	`+ llvm::LLVMBuildFCmp(self.llbuilder, op as c_uint, lhs, rhs, UNNAMED)`
`758`	`762`	`}`
`759`	`763`	`}`
`760`	`764`
`@@ -822,20 +826,20 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {`
`822`	`826`	`else_val: &'ll Value,`
`823`	`827`	`) -> &'ll Value {`
`824`	`828`	`unsafe {`
`825`		`- llvm::LLVMBuildSelect(self.llbuilder, cond, then_val, else_val, noname())`
	`829`	`+ llvm::LLVMBuildSelect(self.llbuilder, cond, then_val, else_val, UNNAMED)`
`826`	`830`	`}`
`827`	`831`	`}`
`828`	`832`
`829`	`833`	`#[allow(dead_code)]`
`830`	`834`	`fn va_arg(&mut self, list: &'ll Value, ty: &'ll Type) -> &'ll Value {`
`831`	`835`	`unsafe {`
`832`		`- llvm::LLVMBuildVAArg(self.llbuilder, list, ty, noname())`
	`836`	`+ llvm::LLVMBuildVAArg(self.llbuilder, list, ty, UNNAMED)`
`833`	`837`	`}`
`834`	`838`	`}`
`835`	`839`
`836`	`840`	`fn extract_element(&mut self, vec: &'ll Value, idx: &'ll Value) -> &'ll Value {`
`837`	`841`	`unsafe {`
`838`		`- llvm::LLVMBuildExtractElement(self.llbuilder, vec, idx, noname())`
	`842`	`+ llvm::LLVMBuildExtractElement(self.llbuilder, vec, idx, UNNAMED)`
`839`	`843`	`}`
`840`	`844`	`}`
`841`	`845`
`@@ -852,7 +856,7 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {`
`852`	`856`	`fn extract_value(&mut self, agg_val: &'ll Value, idx: u64) -> &'ll Value {`
`853`	`857`	`assert_eq!(idx as c_uint as u64, idx);`
`854`	`858`	`unsafe {`
`855`		`- llvm::LLVMBuildExtractValue(self.llbuilder, agg_val, idx as c_uint, noname())`
	`859`	`+ llvm::LLVMBuildExtractValue(self.llbuilder, agg_val, idx as c_uint, UNNAMED)`
`856`	`860`	`}`
`857`	`861`	`}`
`858`	`862`
`@@ -861,15 +865,15 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {`
`861`	`865`	`assert_eq!(idx as c_uint as u64, idx);`
`862`	`866`	`unsafe {`
`863`	`867`	`llvm::LLVMBuildInsertValue(self.llbuilder, agg_val, elt, idx as c_uint,`
`864`		`- noname())`
	`868`	`+ UNNAMED)`
`865`	`869`	`}`
`866`	`870`	`}`
`867`	`871`
`868`	`872`	`fn landing_pad(&mut self, ty: &'ll Type, pers_fn: &'ll Value,`
`869`	`873`	`num_clauses: usize) -> &'ll Value {`
`870`	`874`	`unsafe {`
`871`	`875`	`llvm::LLVMBuildLandingPad(self.llbuilder, ty, pers_fn,`
`872`		`- num_clauses as c_uint, noname())`
	`876`	`+ num_clauses as c_uint, UNNAMED)`
`873`	`877`	`}`
`874`	`878`	`}`
`875`	`879`
`@@ -1039,14 +1043,14 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {`
`1039`	`1043`	`llfn,`
`1040`	`1044`	`args.as_ptr() as *const &llvm::Value,`
`1041`	`1045`	`args.len() as c_uint,`
`1042`		`- bundle, noname()`
	`1046`	`+ bundle, UNNAMED`
`1043`	`1047`	`)`
`1044`	`1048`	`}`
`1045`	`1049`	`}`
`1046`	`1050`
`1047`	`1051`	`fn zext(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {`
`1048`	`1052`	`unsafe {`
`1049`		`- llvm::LLVMBuildZExt(self.llbuilder, val, dest_ty, noname())`
	`1053`	`+ llvm::LLVMBuildZExt(self.llbuilder, val, dest_ty, UNNAMED)`
`1050`	`1054`	`}`
`1051`	`1055`	`}`
`1052`	`1056`
`@@ -1128,7 +1132,7 @@ impl Builder<'a, 'll, 'tcx> {`
`1128`	`1132`	`idx: &'ll Value,`
`1129`	`1133`	`) -> &'ll Value {`
`1130`	`1134`	`unsafe {`
`1131`		`- llvm::LLVMBuildInsertElement(self.llbuilder, vec, elt, idx, noname())`
	`1135`	`+ llvm::LLVMBuildInsertElement(self.llbuilder, vec, elt, idx, UNNAMED)`
`1132`	`1136`	`}`
`1133`	`1137`	`}`
`1134`	`1138`
`@@ -1139,7 +1143,7 @@ impl Builder<'a, 'll, 'tcx> {`
`1139`	`1143`	`mask: &'ll Value,`
`1140`	`1144`	`) -> &'ll Value {`
`1141`	`1145`	`unsafe {`
`1142`		`- llvm::LLVMBuildShuffleVector(self.llbuilder, v1, v2, mask, noname())`
	`1146`	`+ llvm::LLVMBuildShuffleVector(self.llbuilder, v1, v2, mask, UNNAMED)`
`1143`	`1147`	`}`
`1144`	`1148`	`}`
`1145`	`1149`
`@@ -1281,7 +1285,7 @@ impl Builder<'a, 'll, 'tcx> {`
`1281`	`1285`
`1282`	`1286`	`pub fn va_arg(&mut self, list: &'ll Value, ty: &'ll Type) -> &'ll Value {`
`1283`	`1287`	`unsafe {`
`1284`		`- llvm::LLVMBuildVAArg(self.llbuilder, list, ty, noname())`
	`1288`	`+ llvm::LLVMBuildVAArg(self.llbuilder, list, ty, UNNAMED)`
`1285`	`1289`	`}`
`1286`	`1290`	`}`
`1287`	`1291`
`@@ -1304,7 +1308,7 @@ impl Builder<'a, 'll, 'tcx> {`
`1304`	`1308`	`fn phi(&mut self, ty: &'ll Type, vals: &[&'ll Value], bbs: &[&'ll BasicBlock]) -> &'ll Value {`
`1305`	`1309`	`assert_eq!(vals.len(), bbs.len());`
`1306`	`1310`	`let phi = unsafe {`
`1307`		`- llvm::LLVMBuildPhi(self.llbuilder, ty, noname())`
	`1311`	`+ llvm::LLVMBuildPhi(self.llbuilder, ty, UNNAMED)`
`1308`	`1312`	`};`
`1309`	`1313`	`unsafe {`
`1310`	`1314`	`llvm::LLVMAddIncoming(phi, vals.as_ptr(),`