Auto merge of #37347 - srinivasreddy:llvm, r=eddyb

run rustfmt on librustc_llvm folder

4 files changed, 314 insertions, 508 deletions

diff --git a/src/librustc_llvm/build.rs b/src/librustc_llvm/build.rs
index 5257575a94e..35140d5ab4a 100644
--- a/src/librustc_llvm/build.rs
+++ b/src/librustc_llvm/build.rs
@@ -22,22 +22,21 @@ fn main() {
 
     let target = env::var("TARGET").expect("TARGET was not set");
     let llvm_config = env::var_os("LLVM_CONFIG")
-                          .map(PathBuf::from)
-                          .unwrap_or_else(|| {
-                              if let Some(dir) = env::var_os("CARGO_TARGET_DIR")
-                                      .map(PathBuf::from) {
-                                  let to_test = dir.parent()
-                                                   .unwrap()
-                                                   .parent()
-                                                   .unwrap()
-                                                   .join(&target)
-                                                   .join("llvm/bin/llvm-config");
-                                  if Command::new(&to_test).output().is_ok() {
-                                      return to_test;
-                                  }
-                              }
-                              PathBuf::from("llvm-config")
-                          });
+        .map(PathBuf::from)
+        .unwrap_or_else(|| {
+            if let Some(dir) = env::var_os("CARGO_TARGET_DIR").map(PathBuf::from) {
+                let to_test = dir.parent()
+                    .unwrap()
+                    .parent()
+                    .unwrap()
+                    .join(&target)
+                    .join("llvm/bin/llvm-config");
+                if Command::new(&to_test).output().is_ok() {
+                    return to_test;
+                }
+            }
+            PathBuf::from("llvm-config")
+        });
 
     println!("cargo:rerun-if-changed={}", llvm_config.display());
 
@@ -66,8 +65,8 @@ fn main() {
     let host = env::var("HOST").expect("HOST was not set");
     let is_crossed = target != host;
 
-    let optional_components = ["x86", "arm", "aarch64", "mips", "powerpc", "pnacl", "systemz",
-                               "jsbackend"];
+    let optional_components =
+        ["x86", "arm", "aarch64", "mips", "powerpc", "pnacl", "systemz", "jsbackend"];
 
     // FIXME: surely we don't need all these components, right? Stuff like mcjit
     //        or interpreter the compiler itself never uses.
@@ -149,7 +148,7 @@ fn main() {
             // that off
             lib.trim_right_matches(".lib")
         } else {
-            continue
+            continue;
         };
 
         // Don't need or want this library, but LLVM's CMake build system
@@ -158,7 +157,7 @@ fn main() {
         // library and it otherwise may just pull in extra dependencies on
         // libedit which we don't want
         if name == "LLVMLineEditor" {
-            continue
+            continue;
         }
 
         let kind = if name.starts_with("LLVM") {
@@ -179,7 +178,7 @@ fn main() {
     cmd.arg("--ldflags");
     for lib in output(&mut cmd).split_whitespace() {
         if lib.starts_with("-LIBPATH:") {
-                println!("cargo:rustc-link-search=native={}", &lib[9..]);
+            println!("cargo:rustc-link-search=native={}", &lib[9..]);
         } else if is_crossed {
             if lib.starts_with("-L") {
                 println!("cargo:rustc-link-search=native={}",
diff --git a/src/librustc_llvm/diagnostic.rs b/src/librustc_llvm/diagnostic.rs
index 8520ae1df60..8767f03b3e7 100644
--- a/src/librustc_llvm/diagnostic.rs
+++ b/src/librustc_llvm/diagnostic.rs
@@ -33,8 +33,7 @@ pub enum OptimizationDiagnosticKind {
 impl OptimizationDiagnosticKind {
     pub fn describe(self) -> &'static str {
         match self {
-            OptimizationRemark |
-            OptimizationRemarkOther => "remark",
+            OptimizationRemark | OptimizationRemarkOther => "remark",
             OptimizationMissed => "missed",
             OptimizationAnalysis => "analysis",
             OptimizationAnalysisFPCommute => "floating-point",
@@ -130,18 +129,14 @@ impl Diagnostic {
                 Optimization(OptimizationDiagnostic::unpack(OptimizationAnalysis, di))
             }
 
-
             Dk::OptimizationRemarkAnalysisFPCommute => {
-                Optimization(OptimizationDiagnostic::unpack(
-                    OptimizationAnalysisFPCommute, di))
+                Optimization(OptimizationDiagnostic::unpack(OptimizationAnalysisFPCommute, di))
             }
 
             Dk::OptimizationRemarkAnalysisAliasing => {
-                Optimization(OptimizationDiagnostic::unpack(
-                    OptimizationAnalysisAliasing, di))
+                Optimization(OptimizationDiagnostic::unpack(OptimizationAnalysisAliasing, di))
             }
 
-
             Dk::OptimizationFailure => {
                 Optimization(OptimizationDiagnostic::unpack(OptimizationFailure, di))
             }
diff --git a/src/librustc_llvm/ffi.rs b/src/librustc_llvm/ffi.rs
index 302c0ce6c54..78a9d67ed77 100644
--- a/src/librustc_llvm/ffi.rs
+++ b/src/librustc_llvm/ffi.rs
@@ -8,11 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use debuginfo::{DIBuilderRef, DIDescriptor,
-                DIFile, DILexicalBlock, DISubprogram, DIType,
-                DIBasicType, DIDerivedType, DICompositeType, DIScope,
-                DIVariable, DIGlobalVariable, DIArray, DISubrange,
-                DITemplateTypeParameter, DIEnumerator, DINameSpace};
+use debuginfo::{DIBuilderRef, DIDescriptor, DIFile, DILexicalBlock, DISubprogram, DIType,
+                DIBasicType, DIDerivedType, DICompositeType, DIScope, DIVariable,
+                DIGlobalVariable, DIArray, DISubrange, DITemplateTypeParameter, DIEnumerator,
+                DINameSpace};
 
 use libc::{c_uint, c_int, size_t, c_char};
 use libc::{c_longlong, c_ulonglong, c_void};
@@ -44,7 +43,7 @@ pub enum CallConv {
     X86FastcallCallConv = 65,
     X86_64_SysV = 78,
     X86_64_Win64 = 79,
-    X86_VectorCall = 80
+    X86_VectorCall = 80,
 }
 
 /// LLVMRustLinkage
@@ -78,9 +77,9 @@ pub enum DiagnosticSeverity {
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub enum DLLStorageClass {
-  Default   = 0,
-  DllImport = 1, /* Function to be imported from DLL. */
-  DllExport = 2, /* Function to be accessible from DLL. */
+    Default = 0,
+    DllImport = 1, // Function to be imported from DLL.
+    DllExport = 2, // Function to be accessible from DLL.
 }
 
 bitflags! {
@@ -180,23 +179,23 @@ pub enum RealPredicate {
 #[derive(Copy, Clone, PartialEq, Debug)]
 #[repr(C)]
 pub enum TypeKind {
-    Void      = 0,
-    Half      = 1,
-    Float     = 2,
-    Double    = 3,
-    X86_FP80  = 4,
-    FP128     = 5,
+    Void = 0,
+    Half = 1,
+    Float = 2,
+    Double = 3,
+    X86_FP80 = 4,
+    FP128 = 5,
     PPC_FP128 = 6,
-    Label     = 7,
-    Integer   = 8,
-    Function  = 9,
-    Struct    = 10,
-    Array     = 11,
-    Pointer   = 12,
-    Vector    = 13,
-    Metadata  = 14,
-    X86_MMX   = 15,
-    Token     = 16,
+    Label = 7,
+    Integer = 8,
+    Function = 9,
+    Struct = 10,
+    Array = 11,
+    Pointer = 12,
+    Vector = 13,
+    Metadata = 14,
+    X86_MMX = 15,
+    Token = 16,
 }
 
 /// LLVMAtomicRmwBinOp
@@ -204,14 +203,14 @@ pub enum TypeKind {
 #[repr(C)]
 pub enum AtomicRmwBinOp {
     AtomicXchg = 0,
-    AtomicAdd  = 1,
-    AtomicSub  = 2,
-    AtomicAnd  = 3,
+    AtomicAdd = 1,
+    AtomicSub = 2,
+    AtomicAnd = 3,
     AtomicNand = 4,
-    AtomicOr   = 5,
-    AtomicXor  = 6,
-    AtomicMax  = 7,
-    AtomicMin  = 8,
+    AtomicOr = 5,
+    AtomicXor = 6,
+    AtomicMax = 7,
+    AtomicMin = 8,
     AtomicUMax = 9,
     AtomicUMin = 10,
 }
@@ -227,7 +226,7 @@ pub enum AtomicOrdering {
     Acquire = 4,
     Release = 5,
     AcquireRelease = 6,
-    SequentiallyConsistent = 7
+    SequentiallyConsistent = 7,
 }
 
 /// LLVMRustSynchronizationScope
@@ -429,7 +428,7 @@ pub type InlineAsmDiagHandler = unsafe extern "C" fn(SMDiagnosticRef, *const c_v
 
 pub mod debuginfo {
     pub use self::DIDescriptorFlags::*;
-    use super::{MetadataRef};
+    use super::MetadataRef;
 
     #[allow(missing_copy_implementations)]
     pub enum DIBuilder_opaque {}
@@ -455,22 +454,22 @@ pub mod debuginfo {
 
     #[derive(Copy, Clone)]
     pub enum DIDescriptorFlags {
-      FlagPrivate            = 1 << 0,
-      FlagProtected          = 1 << 1,
-      FlagFwdDecl            = 1 << 2,
-      FlagAppleBlock         = 1 << 3,
-      FlagBlockByrefStruct   = 1 << 4,
-      FlagVirtual            = 1 << 5,
-      FlagArtificial         = 1 << 6,
-      FlagExplicit           = 1 << 7,
-      FlagPrototyped         = 1 << 8,
-      FlagObjcClassComplete  = 1 << 9,
-      FlagObjectPointer      = 1 << 10,
-      FlagVector             = 1 << 11,
-      FlagStaticMember       = 1 << 12,
-      FlagIndirectVariable   = 1 << 13,
-      FlagLValueReference    = 1 << 14,
-      FlagRValueReference    = 1 << 15
+        FlagPrivate = 1 << 0,
+        FlagProtected = 1 << 1,
+        FlagFwdDecl = 1 << 2,
+        FlagAppleBlock = 1 << 3,
+        FlagBlockByrefStruct = 1 << 4,
+        FlagVirtual = 1 << 5,
+        FlagArtificial = 1 << 6,
+        FlagExplicit = 1 << 7,
+        FlagPrototyped = 1 << 8,
+        FlagObjcClassComplete = 1 << 9,
+        FlagObjectPointer = 1 << 10,
+        FlagVector = 1 << 11,
+        FlagStaticMember = 1 << 12,
+        FlagIndirectVariable = 1 << 13,
+        FlagLValueReference = 1 << 14,
+        FlagRValueReference = 1 << 15,
     }
 }
 
@@ -487,22 +486,17 @@ pub mod debuginfo {
 // set of the libraries we need to link to LLVM for.
 #[link(name = "rustllvm", kind = "static")]
 #[cfg(not(cargobuild))]
-extern {}
+extern "C" {}
 
 #[linked_from = "rustllvm"] // not quite true but good enough
-extern {
-    /* Create and destroy contexts. */
+extern "C" {
+    // Create and destroy contexts.
     pub fn LLVMContextCreate() -> ContextRef;
     pub fn LLVMContextDispose(C: ContextRef);
-    pub fn LLVMGetMDKindIDInContext(C: ContextRef,
-                                    Name: *const c_char,
-                                    SLen: c_uint)
-                                    -> c_uint;
+    pub fn LLVMGetMDKindIDInContext(C: ContextRef, Name: *const c_char, SLen: c_uint) -> c_uint;
 
-    /* Create and destroy modules. */
-    pub fn LLVMModuleCreateWithNameInContext(ModuleID: *const c_char,
-                                             C: ContextRef)
-                                             -> ModuleRef;
+    // Create and destroy modules.
+    pub fn LLVMModuleCreateWithNameInContext(ModuleID: *const c_char, C: ContextRef) -> ModuleRef;
     pub fn LLVMGetModuleContext(M: ModuleRef) -> ContextRef;
     pub fn LLVMCloneModule(M: ModuleRef) -> ModuleRef;
     pub fn LLVMDisposeModule(M: ModuleRef);
@@ -527,25 +521,24 @@ extern {
     /// See llvm::LLVMType::getContext.
     pub fn LLVMGetTypeContext(Ty: TypeRef) -> ContextRef;
 
-    /* Operations on integer types */
+    // Operations on integer types
     pub fn LLVMInt1TypeInContext(C: ContextRef) -> TypeRef;
     pub fn LLVMInt8TypeInContext(C: ContextRef) -> TypeRef;
     pub fn LLVMInt16TypeInContext(C: ContextRef) -> TypeRef;
     pub fn LLVMInt32TypeInContext(C: ContextRef) -> TypeRef;
     pub fn LLVMInt64TypeInContext(C: ContextRef) -> TypeRef;
-    pub fn LLVMIntTypeInContext(C: ContextRef, NumBits: c_uint)
-                                -> TypeRef;
+    pub fn LLVMIntTypeInContext(C: ContextRef, NumBits: c_uint) -> TypeRef;
 
     pub fn LLVMGetIntTypeWidth(IntegerTy: TypeRef) -> c_uint;
 
-    /* Operations on real types */
+    // Operations on real types
     pub fn LLVMFloatTypeInContext(C: ContextRef) -> TypeRef;
     pub fn LLVMDoubleTypeInContext(C: ContextRef) -> TypeRef;
     pub fn LLVMX86FP80TypeInContext(C: ContextRef) -> TypeRef;
     pub fn LLVMFP128TypeInContext(C: ContextRef) -> TypeRef;
     pub fn LLVMPPCFP128TypeInContext(C: ContextRef) -> TypeRef;
 
-    /* Operations on function types */
+    // Operations on function types
     pub fn LLVMFunctionType(ReturnType: TypeRef,
                             ParamTypes: *const TypeRef,
                             ParamCount: c_uint,
@@ -556,37 +549,33 @@ extern {
     pub fn LLVMCountParamTypes(FunctionTy: TypeRef) -> c_uint;
     pub fn LLVMGetParamTypes(FunctionTy: TypeRef, Dest: *mut TypeRef);
 
-    /* Operations on struct types */
+    // Operations on struct types
     pub fn LLVMStructTypeInContext(C: ContextRef,
                                    ElementTypes: *const TypeRef,
                                    ElementCount: c_uint,
                                    Packed: Bool)
                                    -> TypeRef;
     pub fn LLVMCountStructElementTypes(StructTy: TypeRef) -> c_uint;
-    pub fn LLVMGetStructElementTypes(StructTy: TypeRef,
-                                     Dest: *mut TypeRef);
+    pub fn LLVMGetStructElementTypes(StructTy: TypeRef, Dest: *mut TypeRef);
     pub fn LLVMIsPackedStruct(StructTy: TypeRef) -> Bool;
 
-    /* Operations on array, pointer, and vector types (sequence types) */
+    // Operations on array, pointer, and vector types (sequence types)
     pub fn LLVMRustArrayType(ElementType: TypeRef, ElementCount: u64) -> TypeRef;
-    pub fn LLVMPointerType(ElementType: TypeRef, AddressSpace: c_uint)
-                           -> TypeRef;
-    pub fn LLVMVectorType(ElementType: TypeRef, ElementCount: c_uint)
-                          -> TypeRef;
+    pub fn LLVMPointerType(ElementType: TypeRef, AddressSpace: c_uint) -> TypeRef;
+    pub fn LLVMVectorType(ElementType: TypeRef, ElementCount: c_uint) -> TypeRef;
 
     pub fn LLVMGetElementType(Ty: TypeRef) -> TypeRef;
     pub fn LLVMGetArrayLength(ArrayTy: TypeRef) -> c_uint;
     pub fn LLVMGetPointerAddressSpace(PointerTy: TypeRef) -> c_uint;
-    pub fn LLVMGetPointerToGlobal(EE: ExecutionEngineRef, V: ValueRef)
-                                  -> *const c_void;
+    pub fn LLVMGetPointerToGlobal(EE: ExecutionEngineRef, V: ValueRef) -> *const c_void;
     pub fn LLVMGetVectorSize(VectorTy: TypeRef) -> c_uint;
 
-    /* Operations on other types */
+    // Operations on other types
     pub fn LLVMVoidTypeInContext(C: ContextRef) -> TypeRef;
     pub fn LLVMLabelTypeInContext(C: ContextRef) -> TypeRef;
     pub fn LLVMRustMetadataTypeInContext(C: ContextRef) -> TypeRef;
 
-    /* Operations on all values */
+    // Operations on all values
     pub fn LLVMTypeOf(Val: ValueRef) -> TypeRef;
     pub fn LLVMGetValueName(Val: ValueRef) -> *const c_char;
     pub fn LLVMSetValueName(Val: ValueRef, Name: *const c_char);
@@ -594,58 +583,45 @@ extern {
     pub fn LLVMReplaceAllUsesWith(OldVal: ValueRef, NewVal: ValueRef);
     pub fn LLVMSetMetadata(Val: ValueRef, KindID: c_uint, Node: ValueRef);
 
-    /* Operations on Uses */
+    // Operations on Uses
     pub fn LLVMGetFirstUse(Val: ValueRef) -> UseRef;
     pub fn LLVMGetNextUse(U: UseRef) -> UseRef;
     pub fn LLVMGetUser(U: UseRef) -> ValueRef;
     pub fn LLVMGetUsedValue(U: UseRef) -> ValueRef;
 
-    /* Operations on Users */
+    // Operations on Users
     pub fn LLVMGetNumOperands(Val: ValueRef) -> c_int;
     pub fn LLVMGetOperand(Val: ValueRef, Index: c_uint) -> ValueRef;
     pub fn LLVMSetOperand(Val: ValueRef, Index: c_uint, Op: ValueRef);
 
-    /* Operations on constants of any type */
+    // Operations on constants of any type
     pub fn LLVMConstNull(Ty: TypeRef) -> ValueRef;
-    /* all zeroes */
+    // all zeroes
     pub fn LLVMConstAllOnes(Ty: TypeRef) -> ValueRef;
-    pub fn LLVMConstICmp(Pred: IntPredicate, V1: ValueRef, V2: ValueRef)
-                         -> ValueRef;
-    pub fn LLVMConstFCmp(Pred: RealPredicate, V1: ValueRef, V2: ValueRef)
-                         -> ValueRef;
-    /* only for isize/vector */
+    pub fn LLVMConstICmp(Pred: IntPredicate, V1: ValueRef, V2: ValueRef) -> ValueRef;
+    pub fn LLVMConstFCmp(Pred: RealPredicate, V1: ValueRef, V2: ValueRef) -> ValueRef;
+    // only for isize/vector
     pub fn LLVMGetUndef(Ty: TypeRef) -> ValueRef;
     pub fn LLVMIsConstant(Val: ValueRef) -> Bool;
     pub fn LLVMIsNull(Val: ValueRef) -> Bool;
     pub fn LLVMIsUndef(Val: ValueRef) -> Bool;
     pub fn LLVMConstPointerNull(Ty: TypeRef) -> ValueRef;
 
-    /* Operations on metadata */
-    pub fn LLVMMDStringInContext(C: ContextRef,
-                                 Str: *const c_char,
-                                 SLen: c_uint)
-                                 -> ValueRef;
-    pub fn LLVMMDNodeInContext(C: ContextRef,
-                               Vals: *const ValueRef,
-                               Count: c_uint)
-                               -> ValueRef;
-    pub fn LLVMAddNamedMetadataOperand(M: ModuleRef,
-                                       Str: *const c_char,
-                                       Val: ValueRef);
+    // Operations on metadata
+    pub fn LLVMMDStringInContext(C: ContextRef, Str: *const c_char, SLen: c_uint) -> ValueRef;
+    pub fn LLVMMDNodeInContext(C: ContextRef, Vals: *const ValueRef, Count: c_uint) -> ValueRef;
+    pub fn LLVMAddNamedMetadataOperand(M: ModuleRef, Str: *const c_char, Val: ValueRef);
 
-    /* Operations on scalar constants */
-    pub fn LLVMConstInt(IntTy: TypeRef, N: c_ulonglong, SignExtend: Bool)
-                        -> ValueRef;
-    pub fn LLVMConstIntOfString(IntTy: TypeRef, Text: *const c_char, Radix: u8)
-                                -> ValueRef;
+    // Operations on scalar constants
+    pub fn LLVMConstInt(IntTy: TypeRef, N: c_ulonglong, SignExtend: Bool) -> ValueRef;
+    pub fn LLVMConstIntOfString(IntTy: TypeRef, Text: *const c_char, Radix: u8) -> ValueRef;
     pub fn LLVMConstIntOfStringAndSize(IntTy: TypeRef,
                                        Text: *const c_char,
                                        SLen: c_uint,
                                        Radix: u8)
                                        -> ValueRef;
     pub fn LLVMConstReal(RealTy: TypeRef, N: f64) -> ValueRef;
-    pub fn LLVMConstRealOfString(RealTy: TypeRef, Text: *const c_char)
-                                 -> ValueRef;
+    pub fn LLVMConstRealOfString(RealTy: TypeRef, Text: *const c_char) -> ValueRef;
     pub fn LLVMConstRealOfStringAndSize(RealTy: TypeRef,
                                         Text: *const c_char,
                                         SLen: c_uint)
@@ -654,7 +630,7 @@ extern {
     pub fn LLVMConstIntGetSExtValue(ConstantVal: ValueRef) -> c_longlong;
 
 
-    /* Operations on composite constants */
+    // Operations on composite constants
     pub fn LLVMConstStringInContext(C: ContextRef,
                                     Str: *const c_char,
                                     Length: c_uint,
@@ -670,10 +646,9 @@ extern {
                           ConstantVals: *const ValueRef,
                           Length: c_uint)
                           -> ValueRef;
-    pub fn LLVMConstVector(ScalarConstantVals: *const ValueRef, Size: c_uint)
-                           -> ValueRef;
+    pub fn LLVMConstVector(ScalarConstantVals: *const ValueRef, Size: c_uint) -> ValueRef;
 
-    /* Constant expressions */
+    // Constant expressions
     pub fn LLVMAlignOf(Ty: TypeRef) -> ValueRef;
     pub fn LLVMSizeOf(Ty: TypeRef) -> ValueRef;
     pub fn LLVMConstNeg(ConstantVal: ValueRef) -> ValueRef;
@@ -681,57 +656,31 @@ extern {
     pub fn LLVMConstNUWNeg(ConstantVal: ValueRef) -> ValueRef;
     pub fn LLVMConstFNeg(ConstantVal: ValueRef) -> ValueRef;
     pub fn LLVMConstNot(ConstantVal: ValueRef) -> ValueRef;
-    pub fn LLVMConstAdd(LHSConstant: ValueRef, RHSConstant: ValueRef)
-                        -> ValueRef;
-    pub fn LLVMConstNSWAdd(LHSConstant: ValueRef, RHSConstant: ValueRef)
-                           -> ValueRef;
-    pub fn LLVMConstNUWAdd(LHSConstant: ValueRef, RHSConstant: ValueRef)
-                           -> ValueRef;
-    pub fn LLVMConstFAdd(LHSConstant: ValueRef, RHSConstant: ValueRef)
-                         -> ValueRef;
-    pub fn LLVMConstSub(LHSConstant: ValueRef, RHSConstant: ValueRef)
-                        -> ValueRef;
-    pub fn LLVMConstNSWSub(LHSConstant: ValueRef, RHSConstant: ValueRef)
-                           -> ValueRef;
-    pub fn LLVMConstNUWSub(LHSConstant: ValueRef, RHSConstant: ValueRef)
-                           -> ValueRef;
-    pub fn LLVMConstFSub(LHSConstant: ValueRef, RHSConstant: ValueRef)
-                         -> ValueRef;
-    pub fn LLVMConstMul(LHSConstant: ValueRef, RHSConstant: ValueRef)
-                        -> ValueRef;
-    pub fn LLVMConstNSWMul(LHSConstant: ValueRef, RHSConstant: ValueRef)
-                           -> ValueRef;
-    pub fn LLVMConstNUWMul(LHSConstant: ValueRef, RHSConstant: ValueRef)
-                           -> ValueRef;
-    pub fn LLVMConstFMul(LHSConstant: ValueRef, RHSConstant: ValueRef)
-                         -> ValueRef;
-    pub fn LLVMConstUDiv(LHSConstant: ValueRef, RHSConstant: ValueRef)
-                         -> ValueRef;
-    pub fn LLVMConstSDiv(LHSConstant: ValueRef, RHSConstant: ValueRef)
-                         -> ValueRef;
-    pub fn LLVMConstExactSDiv(LHSConstant: ValueRef,
-                              RHSConstant: ValueRef)
-                              -> ValueRef;
-    pub fn LLVMConstFDiv(LHSConstant: ValueRef, RHSConstant: ValueRef)
-                         -> ValueRef;
-    pub fn LLVMConstURem(LHSConstant: ValueRef, RHSConstant: ValueRef)
-                         -> ValueRef;
-    pub fn LLVMConstSRem(LHSConstant: ValueRef, RHSConstant: ValueRef)
-                         -> ValueRef;
-    pub fn LLVMConstFRem(LHSConstant: ValueRef, RHSConstant: ValueRef)
-                         -> ValueRef;
-    pub fn LLVMConstAnd(LHSConstant: ValueRef, RHSConstant: ValueRef)
-                        -> ValueRef;
-    pub fn LLVMConstOr(LHSConstant: ValueRef, RHSConstant: ValueRef)
-                       -> ValueRef;
-    pub fn LLVMConstXor(LHSConstant: ValueRef, RHSConstant: ValueRef)
-                        -> ValueRef;
-    pub fn LLVMConstShl(LHSConstant: ValueRef, RHSConstant: ValueRef)
-                        -> ValueRef;
-    pub fn LLVMConstLShr(LHSConstant: ValueRef, RHSConstant: ValueRef)
-                         -> ValueRef;
-    pub fn LLVMConstAShr(LHSConstant: ValueRef, RHSConstant: ValueRef)
-                         -> ValueRef;
+    pub fn LLVMConstAdd(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef;
+    pub fn LLVMConstNSWAdd(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef;
+    pub fn LLVMConstNUWAdd(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef;
+    pub fn LLVMConstFAdd(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef;
+    pub fn LLVMConstSub(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef;
+    pub fn LLVMConstNSWSub(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef;
+    pub fn LLVMConstNUWSub(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef;
+    pub fn LLVMConstFSub(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef;
+    pub fn LLVMConstMul(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef;
+    pub fn LLVMConstNSWMul(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef;
+    pub fn LLVMConstNUWMul(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef;
+    pub fn LLVMConstFMul(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef;
+    pub fn LLVMConstUDiv(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef;
+    pub fn LLVMConstSDiv(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef;
+    pub fn LLVMConstExactSDiv(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef;
+    pub fn LLVMConstFDiv(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef;
+    pub fn LLVMConstURem(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef;
+    pub fn LLVMConstSRem(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef;
+    pub fn LLVMConstFRem(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef;
+    pub fn LLVMConstAnd(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef;
+    pub fn LLVMConstOr(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef;
+    pub fn LLVMConstXor(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef;
+    pub fn LLVMConstShl(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef;
+    pub fn LLVMConstLShr(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef;
+    pub fn LLVMConstAShr(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef;
     pub fn LLVMConstGEP(ConstantVal: ValueRef,
                         ConstantIndices: *const ValueRef,
                         NumIndices: c_uint)
@@ -740,51 +689,29 @@ extern {
                                 ConstantIndices: *const ValueRef,
                                 NumIndices: c_uint)
                                 -> ValueRef;
-    pub fn LLVMConstTrunc(ConstantVal: ValueRef, ToType: TypeRef)
-                          -> ValueRef;
-    pub fn LLVMConstSExt(ConstantVal: ValueRef, ToType: TypeRef)
-                         -> ValueRef;
-    pub fn LLVMConstZExt(ConstantVal: ValueRef, ToType: TypeRef)
-                         -> ValueRef;
-    pub fn LLVMConstFPTrunc(ConstantVal: ValueRef, ToType: TypeRef)
-                            -> ValueRef;
-    pub fn LLVMConstFPExt(ConstantVal: ValueRef, ToType: TypeRef)
-                          -> ValueRef;
-    pub fn LLVMConstUIToFP(ConstantVal: ValueRef, ToType: TypeRef)
-                           -> ValueRef;
-    pub fn LLVMConstSIToFP(ConstantVal: ValueRef, ToType: TypeRef)
-                           -> ValueRef;
-    pub fn LLVMConstFPToUI(ConstantVal: ValueRef, ToType: TypeRef)
-                           -> ValueRef;
-    pub fn LLVMConstFPToSI(ConstantVal: ValueRef, ToType: TypeRef)
-                           -> ValueRef;
-    pub fn LLVMConstPtrToInt(ConstantVal: ValueRef, ToType: TypeRef)
-                             -> ValueRef;
-    pub fn LLVMConstIntToPtr(ConstantVal: ValueRef, ToType: TypeRef)
-                             -> ValueRef;
-    pub fn LLVMConstBitCast(ConstantVal: ValueRef, ToType: TypeRef)
-                            -> ValueRef;
-    pub fn LLVMConstZExtOrBitCast(ConstantVal: ValueRef, ToType: TypeRef)
-                                  -> ValueRef;
-    pub fn LLVMConstSExtOrBitCast(ConstantVal: ValueRef, ToType: TypeRef)
-                                  -> ValueRef;
-    pub fn LLVMConstTruncOrBitCast(ConstantVal: ValueRef, ToType: TypeRef)
-                                   -> ValueRef;
-    pub fn LLVMConstPointerCast(ConstantVal: ValueRef, ToType: TypeRef)
-                                -> ValueRef;
-    pub fn LLVMConstIntCast(ConstantVal: ValueRef,
-                            ToType: TypeRef,
-                            isSigned: Bool)
-                            -> ValueRef;
-    pub fn LLVMConstFPCast(ConstantVal: ValueRef, ToType: TypeRef)
-                           -> ValueRef;
+    pub fn LLVMConstTrunc(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef;
+    pub fn LLVMConstSExt(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef;
+    pub fn LLVMConstZExt(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef;
+    pub fn LLVMConstFPTrunc(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef;
+    pub fn LLVMConstFPExt(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef;
+    pub fn LLVMConstUIToFP(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef;
+    pub fn LLVMConstSIToFP(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef;
+    pub fn LLVMConstFPToUI(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef;
+    pub fn LLVMConstFPToSI(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef;
+    pub fn LLVMConstPtrToInt(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef;
+    pub fn LLVMConstIntToPtr(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef;
+    pub fn LLVMConstBitCast(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef;
+    pub fn LLVMConstZExtOrBitCast(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef;
+    pub fn LLVMConstSExtOrBitCast(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef;
+    pub fn LLVMConstTruncOrBitCast(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef;
+    pub fn LLVMConstPointerCast(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef;
+    pub fn LLVMConstIntCast(ConstantVal: ValueRef, ToType: TypeRef, isSigned: Bool) -> ValueRef;
+    pub fn LLVMConstFPCast(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef;
     pub fn LLVMConstSelect(ConstantCondition: ValueRef,
                            ConstantIfTrue: ValueRef,
                            ConstantIfFalse: ValueRef)
                            -> ValueRef;
-    pub fn LLVMConstExtractElement(VectorConstant: ValueRef,
-                                   IndexConstant: ValueRef)
-                                   -> ValueRef;
+    pub fn LLVMConstExtractElement(VectorConstant: ValueRef, IndexConstant: ValueRef) -> ValueRef;
     pub fn LLVMConstInsertElement(VectorConstant: ValueRef,
                                   ElementValueConstant: ValueRef,
                                   IndexConstant: ValueRef)
@@ -812,7 +739,7 @@ extern {
 
 
 
-    /* Operations on global variables, functions, and aliases (globals) */
+    // Operations on global variables, functions, and aliases (globals)
     pub fn LLVMGetGlobalParent(Global: ValueRef) -> ModuleRef;
     pub fn LLVMIsDeclaration(Global: ValueRef) -> Bool;
     pub fn LLVMRustGetLinkage(Global: ValueRef) -> Linkage;
@@ -823,52 +750,41 @@ extern {
     pub fn LLVMSetVisibility(Global: ValueRef, Viz: c_uint);
     pub fn LLVMGetAlignment(Global: ValueRef) -> c_uint;
     pub fn LLVMSetAlignment(Global: ValueRef, Bytes: c_uint);
-    pub fn LLVMSetDLLStorageClass(V: ValueRef,
-                                  C: DLLStorageClass);
+    pub fn LLVMSetDLLStorageClass(V: ValueRef, C: DLLStorageClass);
 
 
-    /* Operations on global variables */
+    // Operations on global variables
     pub fn LLVMIsAGlobalVariable(GlobalVar: ValueRef) -> ValueRef;
-    pub fn LLVMAddGlobal(M: ModuleRef, Ty: TypeRef, Name: *const c_char)
-                         -> ValueRef;
+    pub fn LLVMAddGlobal(M: ModuleRef, Ty: TypeRef, Name: *const c_char) -> ValueRef;
     pub fn LLVMAddGlobalInAddressSpace(M: ModuleRef,
                                        Ty: TypeRef,
                                        Name: *const c_char,
                                        AddressSpace: c_uint)
                                        -> ValueRef;
-    pub fn LLVMGetNamedGlobal(M: ModuleRef,
-                              Name: *const c_char)
-                              -> ValueRef;
-    pub fn LLVMRustGetOrInsertGlobal(M: ModuleRef,
-                                     Name: *const c_char,
-                                     T: TypeRef)
-                                     -> ValueRef;
+    pub fn LLVMGetNamedGlobal(M: ModuleRef, Name: *const c_char) -> ValueRef;
+    pub fn LLVMRustGetOrInsertGlobal(M: ModuleRef, Name: *const c_char, T: TypeRef) -> ValueRef;
     pub fn LLVMGetFirstGlobal(M: ModuleRef) -> ValueRef;
     pub fn LLVMGetLastGlobal(M: ModuleRef) -> ValueRef;
     pub fn LLVMGetNextGlobal(GlobalVar: ValueRef) -> ValueRef;
     pub fn LLVMGetPreviousGlobal(GlobalVar: ValueRef) -> ValueRef;
     pub fn LLVMDeleteGlobal(GlobalVar: ValueRef);
     pub fn LLVMGetInitializer(GlobalVar: ValueRef) -> ValueRef;
-    pub fn LLVMSetInitializer(GlobalVar: ValueRef,
-                              ConstantVal: ValueRef);
+    pub fn LLVMSetInitializer(GlobalVar: ValueRef, ConstantVal: ValueRef);
     pub fn LLVMIsThreadLocal(GlobalVar: ValueRef) -> Bool;
     pub fn LLVMSetThreadLocal(GlobalVar: ValueRef, IsThreadLocal: Bool);
     pub fn LLVMIsGlobalConstant(GlobalVar: ValueRef) -> Bool;
     pub fn LLVMSetGlobalConstant(GlobalVar: ValueRef, IsConstant: Bool);
     pub fn LLVMRustGetNamedValue(M: ModuleRef, Name: *const c_char) -> ValueRef;
 
-    /* Operations on aliases */
+    // Operations on aliases
     pub fn LLVMAddAlias(M: ModuleRef,
                         Ty: TypeRef,
                         Aliasee: ValueRef,
                         Name: *const c_char)
                         -> ValueRef;
 
-    /* Operations on functions */
-    pub fn LLVMAddFunction(M: ModuleRef,
-                           Name: *const c_char,
-                           FunctionTy: TypeRef)
-                           -> ValueRef;
+    // Operations on functions
+    pub fn LLVMAddFunction(M: ModuleRef, Name: *const c_char, FunctionTy: TypeRef) -> ValueRef;
     pub fn LLVMGetNamedFunction(M: ModuleRef, Name: *const c_char) -> ValueRef;
     pub fn LLVMGetFirstFunction(M: ModuleRef) -> ValueRef;
     pub fn LLVMGetLastFunction(M: ModuleRef) -> ValueRef;
@@ -887,19 +803,16 @@ extern {
     pub fn LLVMRustAddDereferenceableAttr(Fn: ValueRef, index: c_uint, bytes: u64);
     pub fn LLVMRustAddFunctionAttribute(Fn: ValueRef, index: c_uint, PA: u64);
     pub fn LLVMRustAddFunctionAttrString(Fn: ValueRef, index: c_uint, Name: *const c_char);
-    pub fn LLVMRustAddFunctionAttrStringValue(Fn: ValueRef, index: c_uint,
+    pub fn LLVMRustAddFunctionAttrStringValue(Fn: ValueRef,
+                                              index: c_uint,
                                               Name: *const c_char,
                                               Value: *const c_char);
-    pub fn LLVMRustRemoveFunctionAttributes(Fn: ValueRef,
-                                            index: c_uint,
-                                            attr: u64);
-    pub fn LLVMRustRemoveFunctionAttrString(Fn: ValueRef,
-                                            index: c_uint,
-                                            Name: *const c_char);
+    pub fn LLVMRustRemoveFunctionAttributes(Fn: ValueRef, index: c_uint, attr: u64);
+    pub fn LLVMRustRemoveFunctionAttrString(Fn: ValueRef, index: c_uint, Name: *const c_char);
     pub fn LLVMGetFunctionAttr(Fn: ValueRef) -> c_uint;
     pub fn LLVMRemoveFunctionAttr(Fn: ValueRef, val: c_uint);
 
-    /* Operations on parameters */
+    // Operations on parameters
     pub fn LLVMCountParams(Fn: ValueRef) -> c_uint;
     pub fn LLVMGetParams(Fn: ValueRef, Params: *const ValueRef);
     pub fn LLVMGetParam(Fn: ValueRef, Index: c_uint) -> ValueRef;
@@ -913,7 +826,7 @@ extern {
     pub fn LLVMGetAttribute(Arg: ValueRef) -> c_uint;
     pub fn LLVMSetParamAlignment(Arg: ValueRef, align: c_uint);
 
-    /* Operations on basic blocks */
+    // Operations on basic blocks
     pub fn LLVMBasicBlockAsValue(BB: BasicBlockRef) -> ValueRef;
     pub fn LLVMValueIsBasicBlock(Val: ValueRef) -> Bool;
     pub fn LLVMValueAsBasicBlock(Val: ValueRef) -> BasicBlockRef;
@@ -936,13 +849,11 @@ extern {
                                          -> BasicBlockRef;
     pub fn LLVMDeleteBasicBlock(BB: BasicBlockRef);
 
-    pub fn LLVMMoveBasicBlockAfter(BB: BasicBlockRef,
-                                   MoveAfter: BasicBlockRef);
+    pub fn LLVMMoveBasicBlockAfter(BB: BasicBlockRef, MoveAfter: BasicBlockRef);
 
-    pub fn LLVMMoveBasicBlockBefore(BB: BasicBlockRef,
-                                    MoveBefore: BasicBlockRef);
+    pub fn LLVMMoveBasicBlockBefore(BB: BasicBlockRef, MoveBefore: BasicBlockRef);
 
-    /* Operations on instructions */
+    // Operations on instructions
     pub fn LLVMGetInstructionParent(Inst: ValueRef) -> BasicBlockRef;
     pub fn LLVMGetFirstInstruction(BB: BasicBlockRef) -> ValueRef;
     pub fn LLVMGetLastInstruction(BB: BasicBlockRef) -> ValueRef;
@@ -950,53 +861,37 @@ extern {
     pub fn LLVMGetPreviousInstruction(Inst: ValueRef) -> ValueRef;
     pub fn LLVMInstructionEraseFromParent(Inst: ValueRef);
 
-    /* Operations on call sites */
+    // Operations on call sites
     pub fn LLVMSetInstructionCallConv(Instr: ValueRef, CC: c_uint);
     pub fn LLVMGetInstructionCallConv(Instr: ValueRef) -> c_uint;
-    pub fn LLVMAddInstrAttribute(Instr: ValueRef,
-                                 index: c_uint,
-                                 IA: c_uint);
-    pub fn LLVMRemoveInstrAttribute(Instr: ValueRef,
-                                    index: c_uint,
-                                    IA: c_uint);
-    pub fn LLVMSetInstrParamAlignment(Instr: ValueRef,
-                                      index: c_uint,
-                                      align: c_uint);
-    pub fn LLVMRustAddCallSiteAttribute(Instr: ValueRef,
-                                    index: c_uint,
-                                    Val: u64);
-    pub fn LLVMRustAddDereferenceableCallSiteAttr(Instr: ValueRef,
-                                                  index: c_uint,
-                                                  bytes: u64);
-
-    /* Operations on call instructions (only) */
+    pub fn LLVMAddInstrAttribute(Instr: ValueRef, index: c_uint, IA: c_uint);
+    pub fn LLVMRemoveInstrAttribute(Instr: ValueRef, index: c_uint, IA: c_uint);
+    pub fn LLVMSetInstrParamAlignment(Instr: ValueRef, index: c_uint, align: c_uint);
+    pub fn LLVMRustAddCallSiteAttribute(Instr: ValueRef, index: c_uint, Val: u64);
+    pub fn LLVMRustAddDereferenceableCallSiteAttr(Instr: ValueRef, index: c_uint, bytes: u64);
+
+    // Operations on call instructions (only)
     pub fn LLVMIsTailCall(CallInst: ValueRef) -> Bool;
     pub fn LLVMSetTailCall(CallInst: ValueRef, IsTailCall: Bool);
 
-    /* Operations on load/store instructions (only) */
+    // Operations on load/store instructions (only)
     pub fn LLVMGetVolatile(MemoryAccessInst: ValueRef) -> Bool;
     pub fn LLVMSetVolatile(MemoryAccessInst: ValueRef, volatile: Bool);
 
-    /* Operations on phi nodes */
+    // Operations on phi nodes
     pub fn LLVMAddIncoming(PhiNode: ValueRef,
                            IncomingValues: *const ValueRef,
                            IncomingBlocks: *const BasicBlockRef,
                            Count: c_uint);
     pub fn LLVMCountIncoming(PhiNode: ValueRef) -> c_uint;
-    pub fn LLVMGetIncomingValue(PhiNode: ValueRef, Index: c_uint)
-                                -> ValueRef;
-    pub fn LLVMGetIncomingBlock(PhiNode: ValueRef, Index: c_uint)
-                                -> BasicBlockRef;
+    pub fn LLVMGetIncomingValue(PhiNode: ValueRef, Index: c_uint) -> ValueRef;
+    pub fn LLVMGetIncomingBlock(PhiNode: ValueRef, Index: c_uint) -> BasicBlockRef;
 
-    /* Instruction builders */
+    // Instruction builders
     pub fn LLVMCreateBuilderInContext(C: ContextRef) -> BuilderRef;
-    pub fn LLVMPositionBuilder(Builder: BuilderRef,
-                               Block: BasicBlockRef,
-                               Instr: ValueRef);
-    pub fn LLVMPositionBuilderBefore(Builder: BuilderRef,
-                                     Instr: ValueRef);
-    pub fn LLVMPositionBuilderAtEnd(Builder: BuilderRef,
-                                    Block: BasicBlockRef);
+    pub fn LLVMPositionBuilder(Builder: BuilderRef, Block: BasicBlockRef, Instr: ValueRef);
+    pub fn LLVMPositionBuilderBefore(Builder: BuilderRef, Instr: ValueRef);
+    pub fn LLVMPositionBuilderAtEnd(Builder: BuilderRef, Block: BasicBlockRef);
     pub fn LLVMGetInsertBlock(Builder: BuilderRef) -> BasicBlockRef;
     pub fn LLVMClearInsertionPosition(Builder: BuilderRef);
     pub fn LLVMInsertIntoBuilder(Builder: BuilderRef, Instr: ValueRef);
@@ -1005,18 +900,15 @@ extern {
                                          Name: *const c_char);
     pub fn LLVMDisposeBuilder(Builder: BuilderRef);
 
-    /* Metadata */
+    // Metadata
     pub fn LLVMSetCurrentDebugLocation(Builder: BuilderRef, L: ValueRef);
     pub fn LLVMGetCurrentDebugLocation(Builder: BuilderRef) -> ValueRef;
     pub fn LLVMSetInstDebugLocation(Builder: BuilderRef, Inst: ValueRef);
 
-    /* Terminators */
+    // Terminators
     pub fn LLVMBuildRetVoid(B: BuilderRef) -> ValueRef;
     pub fn LLVMBuildRet(B: BuilderRef, V: ValueRef) -> ValueRef;
-    pub fn LLVMBuildAggregateRet(B: BuilderRef,
-                                 RetVals: *const ValueRef,
-                                 N: c_uint)
-                                 -> ValueRef;
+    pub fn LLVMBuildAggregateRet(B: BuilderRef, RetVals: *const ValueRef, N: c_uint) -> ValueRef;
     pub fn LLVMBuildBr(B: BuilderRef, Dest: BasicBlockRef) -> ValueRef;
     pub fn LLVMBuildCondBr(B: BuilderRef,
                            If: ValueRef,
@@ -1028,10 +920,7 @@ extern {
                            Else: BasicBlockRef,
                            NumCases: c_uint)
                            -> ValueRef;
-    pub fn LLVMBuildIndirectBr(B: BuilderRef,
-                               Addr: ValueRef,
-                               NumDests: c_uint)
-                               -> ValueRef;
+    pub fn LLVMBuildIndirectBr(B: BuilderRef, Addr: ValueRef, NumDests: c_uint) -> ValueRef;
     pub fn LLVMRustBuildInvoke(B: BuilderRef,
                                Fn: ValueRef,
                                Args: *const ValueRef,
@@ -1055,42 +944,41 @@ extern {
                                    ParentPad: ValueRef,
                                    ArgCnt: c_uint,
                                    Args: *const ValueRef,
-                                   Name: *const c_char) -> ValueRef;
+                                   Name: *const c_char)
+                                   -> ValueRef;
     pub fn LLVMRustBuildCleanupRet(B: BuilderRef,
                                    CleanupPad: ValueRef,
-                                   UnwindBB: BasicBlockRef) -> ValueRef;
+                                   UnwindBB: BasicBlockRef)
+                                   -> ValueRef;
     pub fn LLVMRustBuildCatchPad(B: BuilderRef,
                                  ParentPad: ValueRef,
                                  ArgCnt: c_uint,
                                  Args: *const ValueRef,
-                                 Name: *const c_char) -> ValueRef;
-    pub fn LLVMRustBuildCatchRet(B: BuilderRef,
-                                 Pad: ValueRef,
-                                 BB: BasicBlockRef) -> ValueRef;
+                                 Name: *const c_char)
+                                 -> ValueRef;
+    pub fn LLVMRustBuildCatchRet(B: BuilderRef, Pad: ValueRef, BB: BasicBlockRef) -> ValueRef;
     pub fn LLVMRustBuildCatchSwitch(Builder: BuilderRef,
                                     ParentPad: ValueRef,
                                     BB: BasicBlockRef,
                                     NumHandlers: c_uint,
-                                    Name: *const c_char) -> ValueRef;
-    pub fn LLVMRustAddHandler(CatchSwitch: ValueRef,
-                              Handler: BasicBlockRef);
+                                    Name: *const c_char)
+                                    -> ValueRef;
+    pub fn LLVMRustAddHandler(CatchSwitch: ValueRef, Handler: BasicBlockRef);
     pub fn LLVMRustSetPersonalityFn(B: BuilderRef, Pers: ValueRef);
 
-    /* Add a case to the switch instruction */
-    pub fn LLVMAddCase(Switch: ValueRef,
-                       OnVal: ValueRef,
-                       Dest: BasicBlockRef);
+    // Add a case to the switch instruction
+    pub fn LLVMAddCase(Switch: ValueRef, OnVal: ValueRef, Dest: BasicBlockRef);
 
-    /* Add a destination to the indirectbr instruction */
+    // Add a destination to the indirectbr instruction
     pub fn LLVMAddDestination(IndirectBr: ValueRef, Dest: BasicBlockRef);
 
-    /* Add a clause to the landing pad instruction */
+    // Add a clause to the landing pad instruction
     pub fn LLVMAddClause(LandingPad: ValueRef, ClauseVal: ValueRef);
 
-    /* Set the cleanup on a landing pad instruction */
+    // Set the cleanup on a landing pad instruction
     pub fn LLVMSetCleanup(LandingPad: ValueRef, Val: Bool);
 
-    /* Arithmetic */
+    // Arithmetic
     pub fn LLVMBuildAdd(B: BuilderRef,
                         LHS: ValueRef,
                         RHS: ValueRef,
@@ -1210,7 +1098,7 @@ extern {
                        LHS: ValueRef,
                        RHS: ValueRef,
                        Name: *const c_char)
-                           -> ValueRef;
+                       -> ValueRef;
     pub fn LLVMBuildXor(B: BuilderRef,
                         LHS: ValueRef,
                         RHS: ValueRef,
@@ -1222,29 +1110,19 @@ extern {
                           RHS: ValueRef,
                           Name: *const c_char)
                           -> ValueRef;
-    pub fn LLVMBuildNeg(B: BuilderRef, V: ValueRef, Name: *const c_char)
-                        -> ValueRef;
-    pub fn LLVMBuildNSWNeg(B: BuilderRef, V: ValueRef, Name: *const c_char)
-                           -> ValueRef;
-    pub fn LLVMBuildNUWNeg(B: BuilderRef, V: ValueRef, Name: *const c_char)
-                           -> ValueRef;
-    pub fn LLVMBuildFNeg(B: BuilderRef, V: ValueRef, Name: *const c_char)
-                         -> ValueRef;
-    pub fn LLVMBuildNot(B: BuilderRef, V: ValueRef, Name: *const c_char)
-                        -> ValueRef;
+    pub fn LLVMBuildNeg(B: BuilderRef, V: ValueRef, Name: *const c_char) -> ValueRef;
+    pub fn LLVMBuildNSWNeg(B: BuilderRef, V: ValueRef, Name: *const c_char) -> ValueRef;
+    pub fn LLVMBuildNUWNeg(B: BuilderRef, V: ValueRef, Name: *const c_char) -> ValueRef;
+    pub fn LLVMBuildFNeg(B: BuilderRef, V: ValueRef, Name: *const c_char) -> ValueRef;
+    pub fn LLVMBuildNot(B: BuilderRef, V: ValueRef, Name: *const c_char) -> ValueRef;
     pub fn LLVMRustSetHasUnsafeAlgebra(Instr: ValueRef);
 
-    /* Memory */
-    pub fn LLVMBuildAlloca(B: BuilderRef, Ty: TypeRef, Name: *const c_char)
-                           -> ValueRef;
+    // Memory
+    pub fn LLVMBuildAlloca(B: BuilderRef, Ty: TypeRef, Name: *const c_char) -> ValueRef;
     pub fn LLVMBuildFree(B: BuilderRef, PointerVal: ValueRef) -> ValueRef;
-    pub fn LLVMBuildLoad(B: BuilderRef,
-                         PointerVal: ValueRef,
-                         Name: *const c_char)
-                         -> ValueRef;
+    pub fn LLVMBuildLoad(B: BuilderRef, PointerVal: ValueRef, Name: *const c_char) -> ValueRef;
 
-    pub fn LLVMBuildStore(B: BuilderRef, Val: ValueRef, Ptr: ValueRef)
-                          -> ValueRef;
+    pub fn LLVMBuildStore(B: BuilderRef, Val: ValueRef, Ptr: ValueRef) -> ValueRef;
 
     pub fn LLVMBuildGEP(B: BuilderRef,
                         Pointer: ValueRef,
@@ -1272,7 +1150,7 @@ extern {
                                     Name: *const c_char)
                                     -> ValueRef;
 
-    /* Casts */
+    // Casts
     pub fn LLVMBuildTrunc(B: BuilderRef,
                           Val: ValueRef,
                           DestTy: TypeRef,
@@ -1352,7 +1230,8 @@ extern {
                          Op: Opcode,
                          Val: ValueRef,
                          DestTy: TypeRef,
-                         Name: *const c_char) -> ValueRef;
+                         Name: *const c_char)
+                         -> ValueRef;
     pub fn LLVMBuildPointerCast(B: BuilderRef,
                                 Val: ValueRef,
                                 DestTy: TypeRef,
@@ -1369,7 +1248,7 @@ extern {
                            Name: *const c_char)
                            -> ValueRef;
 
-    /* Comparisons */
+    // Comparisons
     pub fn LLVMBuildICmp(B: BuilderRef,
                          Op: c_uint,
                          LHS: ValueRef,
@@ -1383,9 +1262,8 @@ extern {
                          Name: *const c_char)
                          -> ValueRef;
 
-    /* Miscellaneous instructions */
-    pub fn LLVMBuildPhi(B: BuilderRef, Ty: TypeRef, Name: *const c_char)
-                        -> ValueRef;
+    // Miscellaneous instructions
+    pub fn LLVMBuildPhi(B: BuilderRef, Ty: TypeRef, Name: *const c_char) -> ValueRef;
     pub fn LLVMRustBuildCall(B: BuilderRef,
                              Fn: ValueRef,
                              Args: *const ValueRef,
@@ -1433,17 +1311,15 @@ extern {
                                 Name: *const c_char)
                                 -> ValueRef;
 
-    pub fn LLVMBuildIsNull(B: BuilderRef, Val: ValueRef, Name: *const c_char)
-                           -> ValueRef;
-    pub fn LLVMBuildIsNotNull(B: BuilderRef, Val: ValueRef, Name: *const c_char)
-                              -> ValueRef;
+    pub fn LLVMBuildIsNull(B: BuilderRef, Val: ValueRef, Name: *const c_char) -> ValueRef;
+    pub fn LLVMBuildIsNotNull(B: BuilderRef, Val: ValueRef, Name: *const c_char) -> ValueRef;
     pub fn LLVMBuildPtrDiff(B: BuilderRef,
                             LHS: ValueRef,
                             RHS: ValueRef,
                             Name: *const c_char)
                             -> ValueRef;
 
-    /* Atomic Operations */
+    // Atomic Operations
     pub fn LLVMRustBuildAtomicLoad(B: BuilderRef,
                                    PointerVal: ValueRef,
                                    Name: *const c_char,
@@ -1480,7 +1356,7 @@ extern {
                                     Scope: SynchronizationScope);
 
 
-    /* Selected entries from the downcasts. */
+    // Selected entries from the downcasts.
     pub fn LLVMIsATerminatorInst(Inst: ValueRef) -> ValueRef;
     pub fn LLVMIsAStoreInst(Inst: ValueRef) -> ValueRef;
 
@@ -1490,22 +1366,18 @@ extern {
     /// Creates target data from a target layout string.
     pub fn LLVMCreateTargetData(StringRep: *const c_char) -> TargetDataRef;
     /// Number of bytes clobbered when doing a Store to *T.
-    pub fn LLVMStoreSizeOfType(TD: TargetDataRef, Ty: TypeRef)
-                               -> c_ulonglong;
+    pub fn LLVMStoreSizeOfType(TD: TargetDataRef, Ty: TypeRef) -> c_ulonglong;
 
     /// Number of bytes clobbered when doing a Store to *T.
-    pub fn LLVMSizeOfTypeInBits(TD: TargetDataRef, Ty: TypeRef)
-                                -> c_ulonglong;
+    pub fn LLVMSizeOfTypeInBits(TD: TargetDataRef, Ty: TypeRef) -> c_ulonglong;
 
     /// Distance between successive elements in an array of T. Includes ABI padding.
     pub fn LLVMABISizeOfType(TD: TargetDataRef, Ty: TypeRef) -> c_ulonglong;
 
     /// Returns the preferred alignment of a type.
-    pub fn LLVMPreferredAlignmentOfType(TD: TargetDataRef, Ty: TypeRef)
-                                        -> c_uint;
+    pub fn LLVMPreferredAlignmentOfType(TD: TargetDataRef, Ty: TypeRef) -> c_uint;
     /// Returns the minimum alignment of a type.
-    pub fn LLVMABIAlignmentOfType(TD: TargetDataRef, Ty: TypeRef)
-                                  -> c_uint;
+    pub fn LLVMABIAlignmentOfType(TD: TargetDataRef, Ty: TypeRef) -> c_uint;
 
     /// Computes the byte offset of the indexed struct element for a
     /// target.
@@ -1515,8 +1387,7 @@ extern {
                                -> c_ulonglong;
 
     /// Returns the minimum alignment of a type when part of a call frame.
-    pub fn LLVMCallFrameAlignmentOfType(TD: TargetDataRef, Ty: TypeRef)
-                                        -> c_uint;
+    pub fn LLVMCallFrameAlignmentOfType(TD: TargetDataRef, Ty: TypeRef) -> c_uint;
 
     /// Disposes target data.
     pub fn LLVMDisposeTargetData(TD: TargetDataRef);
@@ -1525,8 +1396,7 @@ extern {
     pub fn LLVMCreatePassManager() -> PassManagerRef;
 
     /// Creates a function-by-function pass manager
-    pub fn LLVMCreateFunctionPassManagerForModule(M: ModuleRef)
-                                                  -> PassManagerRef;
+    pub fn LLVMCreateFunctionPassManagerForModule(M: ModuleRef) -> PassManagerRef;
 
     /// Disposes a pass manager.
     pub fn LLVMDisposePassManager(PM: PassManagerRef);
@@ -1535,8 +1405,7 @@ extern {
     pub fn LLVMRunPassManager(PM: PassManagerRef, M: ModuleRef) -> Bool;
 
     /// Runs the function passes on the provided function.
-    pub fn LLVMRunFunctionPassManager(FPM: PassManagerRef, F: ValueRef)
-                                      -> Bool;
+    pub fn LLVMRunFunctionPassManager(FPM: PassManagerRef, F: ValueRef) -> Bool;
 
     /// Initializes all the function passes scheduled in the manager
     pub fn LLVMInitializeFunctionPassManager(FPM: PassManagerRef) -> Bool;
@@ -1589,38 +1458,28 @@ extern {
     pub fn LLVMPassManagerBuilderDispose(PMB: PassManagerBuilderRef);
     pub fn LLVMPassManagerBuilderSetOptLevel(PMB: PassManagerBuilderRef,
                                              OptimizationLevel: c_uint);
-    pub fn LLVMPassManagerBuilderSetSizeLevel(PMB: PassManagerBuilderRef,
-                                              Value: Bool);
-    pub fn LLVMPassManagerBuilderSetDisableUnitAtATime(
-        PMB: PassManagerBuilderRef,
-        Value: Bool);
-    pub fn LLVMPassManagerBuilderSetDisableUnrollLoops(
-        PMB: PassManagerBuilderRef,
-        Value: Bool);
-    pub fn LLVMPassManagerBuilderSetDisableSimplifyLibCalls(
-        PMB: PassManagerBuilderRef,
-        Value: Bool);
-    pub fn LLVMPassManagerBuilderUseInlinerWithThreshold(
-        PMB: PassManagerBuilderRef,
-        threshold: c_uint);
-    pub fn LLVMPassManagerBuilderPopulateModulePassManager(
-        PMB: PassManagerBuilderRef,
-        PM: PassManagerRef);
-
-    pub fn LLVMPassManagerBuilderPopulateFunctionPassManager(
-        PMB: PassManagerBuilderRef,
-        PM: PassManagerRef);
-    pub fn LLVMPassManagerBuilderPopulateLTOPassManager(
-        PMB: PassManagerBuilderRef,
-        PM: PassManagerRef,
-        Internalize: Bool,
-        RunInliner: Bool);
+    pub fn LLVMPassManagerBuilderSetSizeLevel(PMB: PassManagerBuilderRef, Value: Bool);
+    pub fn LLVMPassManagerBuilderSetDisableUnitAtATime(PMB: PassManagerBuilderRef, Value: Bool);
+    pub fn LLVMPassManagerBuilderSetDisableUnrollLoops(PMB: PassManagerBuilderRef, Value: Bool);
+    pub fn LLVMPassManagerBuilderSetDisableSimplifyLibCalls(PMB: PassManagerBuilderRef,
+                                                            Value: Bool);
+    pub fn LLVMPassManagerBuilderUseInlinerWithThreshold(PMB: PassManagerBuilderRef,
+                                                         threshold: c_uint);
+    pub fn LLVMPassManagerBuilderPopulateModulePassManager(PMB: PassManagerBuilderRef,
+                                                           PM: PassManagerRef);
+
+    pub fn LLVMPassManagerBuilderPopulateFunctionPassManager(PMB: PassManagerBuilderRef,
+                                                             PM: PassManagerRef);
+    pub fn LLVMPassManagerBuilderPopulateLTOPassManager(PMB: PassManagerBuilderRef,
+                                                        PM: PassManagerRef,
+                                                        Internalize: Bool,
+                                                        RunInliner: Bool);
 
     /// Destroys a memory buffer.
     pub fn LLVMDisposeMemoryBuffer(MemBuf: MemoryBufferRef);
 
 
-    /* Stuff that's in rustllvm/ because it's not upstream yet. */
+    // Stuff that's in rustllvm/ because it's not upstream yet.
 
     /// Opens an object file.
     pub fn LLVMCreateObjectFile(MemBuf: MemoryBufferRef) -> ObjectFileRef;
@@ -1633,9 +1492,7 @@ extern {
     pub fn LLVMDisposeSectionIterator(SI: SectionIteratorRef);
     /// Returns true if the section iterator is at the end of the section
     /// list:
-    pub fn LLVMIsSectionIteratorAtEnd(ObjFile: ObjectFileRef,
-                                      SI: SectionIteratorRef)
-                                      -> Bool;
+    pub fn LLVMIsSectionIteratorAtEnd(ObjFile: ObjectFileRef, SI: SectionIteratorRef) -> Bool;
     /// Moves the section iterator to point to the next section.
     pub fn LLVMMoveToNextSection(SI: SectionIteratorRef);
     /// Returns the current section size.
@@ -1645,8 +1502,7 @@ extern {
 
     /// Reads the given file and returns it as a memory buffer. Use
     /// LLVMDisposeMemoryBuffer() to get rid of it.
-    pub fn LLVMRustCreateMemoryBufferWithContentsOfFile(Path: *const c_char)
-                                                        -> MemoryBufferRef;
+    pub fn LLVMRustCreateMemoryBufferWithContentsOfFile(Path: *const c_char) -> MemoryBufferRef;
     /// Borrows the contents of the memory buffer (doesn't copy it)
     pub fn LLVMCreateMemoryBufferWithMemoryRange(InputData: *const c_char,
                                                  InputDataLength: size_t,
@@ -1695,9 +1551,7 @@ extern {
     pub fn LLVMRustVersionMajor() -> u32;
     pub fn LLVMRustVersionMinor() -> u32;
 
-    pub fn LLVMRustAddModuleFlag(M: ModuleRef,
-                                 name: *const c_char,
-                                 value: u32);
+    pub fn LLVMRustAddModuleFlag(M: ModuleRef, name: *const c_char, value: u32);
 
     pub fn LLVMRustDIBuilderCreate(M: ModuleRef) -> DIBuilderRef;
 
@@ -1751,11 +1605,11 @@ extern {
                                             -> DIBasicType;
 
     pub fn LLVMRustDIBuilderCreatePointerType(Builder: DIBuilderRef,
-                                          PointeeTy: DIType,
-                                          SizeInBits: u64,
-                                          AlignInBits: u64,
-                                          Name: *const c_char)
-                                          -> DIDerivedType;
+                                              PointeeTy: DIType,
+                                              SizeInBits: u64,
+                                              AlignInBits: u64,
+                                              Name: *const c_char)
+                                              -> DIDerivedType;
 
     pub fn LLVMRustDIBuilderCreateStructType(Builder: DIBuilderRef,
                                              Scope: DIDescriptor,
@@ -1926,8 +1780,7 @@ extern {
     pub fn LLVMRustFindAndCreatePass(Pass: *const c_char) -> PassRef;
     pub fn LLVMRustAddPass(PM: PassManagerRef, Pass: PassRef);
 
-    pub fn LLVMRustHasFeature(T: TargetMachineRef,
-                              s: *const c_char) -> bool;
+    pub fn LLVMRustHasFeature(T: TargetMachineRef, s: *const c_char) -> bool;
 
     pub fn LLVMRustPrintTargetCPUs(T: TargetMachineRef);
     pub fn LLVMRustPrintTargetFeatures(T: TargetMachineRef);
@@ -1941,11 +1794,10 @@ extern {
                                        UseSoftFP: bool,
                                        PositionIndependentExecutable: bool,
                                        FunctionSections: bool,
-                                       DataSections: bool) -> TargetMachineRef;
+                                       DataSections: bool)
+                                       -> TargetMachineRef;
     pub fn LLVMRustDisposeTargetMachine(T: TargetMachineRef);
-    pub fn LLVMRustAddAnalysisPasses(T: TargetMachineRef,
-                                     PM: PassManagerRef,
-                                     M: ModuleRef);
+    pub fn LLVMRustAddAnalysisPasses(T: TargetMachineRef, PM: PassManagerRef, M: ModuleRef);
     pub fn LLVMRustAddBuilderLibraryInfo(PMB: PassManagerBuilderRef,
                                          M: ModuleRef,
                                          DisableSimplifyLibCalls: bool);
@@ -1954,7 +1806,8 @@ extern {
                                                MergeFunctions: bool,
                                                SLPVectorize: bool,
                                                LoopVectorize: bool);
-    pub fn LLVMRustAddLibraryInfo(PM: PassManagerRef, M: ModuleRef,
+    pub fn LLVMRustAddLibraryInfo(PM: PassManagerRef,
+                                  M: ModuleRef,
                                   DisableSimplifyLibCalls: bool);
     pub fn LLVMRustRunFunctionPassManager(PM: PassManagerRef, M: ModuleRef);
     pub fn LLVMRustWriteOutputFile(T: TargetMachineRef,
@@ -1963,35 +1816,25 @@ extern {
                                    Output: *const c_char,
                                    FileType: FileType)
                                    -> LLVMRustResult;
-    pub fn LLVMRustPrintModule(PM: PassManagerRef,
-                               M: ModuleRef,
-                               Output: *const c_char);
+    pub fn LLVMRustPrintModule(PM: PassManagerRef, M: ModuleRef, Output: *const c_char);
     pub fn LLVMRustSetLLVMOptions(Argc: c_int, Argv: *const *const c_char);
     pub fn LLVMRustPrintPasses();
     pub fn LLVMRustSetNormalizedTarget(M: ModuleRef, triple: *const c_char);
-    pub fn LLVMRustAddAlwaysInlinePass(P: PassManagerBuilderRef,
-                                       AddLifetimes: bool);
-    pub fn LLVMRustLinkInExternalBitcode(M: ModuleRef,
-                                         bc: *const c_char,
-                                         len: size_t) -> bool;
-    pub fn LLVMRustRunRestrictionPass(M: ModuleRef,
-                                      syms: *const *const c_char,
-                                      len: size_t);
+    pub fn LLVMRustAddAlwaysInlinePass(P: PassManagerBuilderRef, AddLifetimes: bool);
+    pub fn LLVMRustLinkInExternalBitcode(M: ModuleRef, bc: *const c_char, len: size_t) -> bool;
+    pub fn LLVMRustRunRestrictionPass(M: ModuleRef, syms: *const *const c_char, len: size_t);
     pub fn LLVMRustMarkAllFunctionsNounwind(M: ModuleRef);
 
     pub fn LLVMRustOpenArchive(path: *const c_char) -> ArchiveRef;
     pub fn LLVMRustArchiveIteratorNew(AR: ArchiveRef) -> ArchiveIteratorRef;
     pub fn LLVMRustArchiveIteratorNext(AIR: ArchiveIteratorRef) -> ArchiveChildRef;
-    pub fn LLVMRustArchiveChildName(ACR: ArchiveChildRef,
-                                    size: *mut size_t) -> *const c_char;
-    pub fn LLVMRustArchiveChildData(ACR: ArchiveChildRef,
-                                    size: *mut size_t) -> *const c_char;
+    pub fn LLVMRustArchiveChildName(ACR: ArchiveChildRef, size: *mut size_t) -> *const c_char;
+    pub fn LLVMRustArchiveChildData(ACR: ArchiveChildRef, size: *mut size_t) -> *const c_char;
     pub fn LLVMRustArchiveChildFree(ACR: ArchiveChildRef);
     pub fn LLVMRustArchiveIteratorFree(AIR: ArchiveIteratorRef);
     pub fn LLVMRustDestroyArchive(AR: ArchiveRef);
 
-    pub fn LLVMRustGetSectionName(SI: SectionIteratorRef,
-                                  data: *mut *const c_char) -> size_t;
+    pub fn LLVMRustGetSectionName(SI: SectionIteratorRef, data: *mut *const c_char) -> size_t;
 
     pub fn LLVMRustWriteTwineToString(T: TwineRef, s: RustStringRef);
 
@@ -2009,14 +1852,11 @@ extern {
                                              message_out: *mut TwineRef,
                                              instruction_out: *mut ValueRef);
 
-    pub fn LLVMRustWriteDiagnosticInfoToString(DI: DiagnosticInfoRef,
-                                               s: RustStringRef);
+    pub fn LLVMRustWriteDiagnosticInfoToString(DI: DiagnosticInfoRef, s: RustStringRef);
     pub fn LLVMGetDiagInfoSeverity(DI: DiagnosticInfoRef) -> DiagnosticSeverity;
     pub fn LLVMRustGetDiagInfoKind(DI: DiagnosticInfoRef) -> DiagnosticKind;
 
-    pub fn LLVMRustWriteDebugLocToString(C: ContextRef,
-                                         DL: DebugLocRef,
-                                         s: RustStringRef);
+    pub fn LLVMRustWriteDebugLocToString(C: ContextRef, DL: DebugLocRef, s: RustStringRef);
 
     pub fn LLVMRustSetInlineAsmDiagnosticHandler(C: ContextRef,
                                                  H: InlineAsmDiagHandler,
@@ -2028,15 +1868,15 @@ extern {
                                 NumMembers: size_t,
                                 Members: *const RustArchiveMemberRef,
                                 WriteSymbtab: bool,
-                                Kind: ArchiveKind) ->
-                                LLVMRustResult;
+                                Kind: ArchiveKind)
+                                -> LLVMRustResult;
     pub fn LLVMRustArchiveMemberNew(Filename: *const c_char,
                                     Name: *const c_char,
-                                    Child: ArchiveChildRef) -> RustArchiveMemberRef;
+                                    Child: ArchiveChildRef)
+                                    -> RustArchiveMemberRef;
     pub fn LLVMRustArchiveMemberFree(Member: RustArchiveMemberRef);
 
-    pub fn LLVMRustSetDataLayoutFromTargetMachine(M: ModuleRef,
-                                                  TM: TargetMachineRef);
+    pub fn LLVMRustSetDataLayoutFromTargetMachine(M: ModuleRef, TM: TargetMachineRef);
     pub fn LLVMRustGetModuleDataLayout(M: ModuleRef) -> TargetDataRef;
 
     pub fn LLVMRustBuildOperandBundleDef(Name: *const c_char,
@@ -2057,4 +1897,4 @@ extern {
 // during llvm-config?
 #[cfg(windows)]
 #[link(name = "ole32")]
-extern {}
+extern "C" {}
diff --git a/src/librustc_llvm/lib.rs b/src/librustc_llvm/lib.rs
index 3946b44ead5..da09bfa66d2 100644
--- a/src/librustc_llvm/lib.rs
+++ b/src/librustc_llvm/lib.rs
@@ -31,7 +31,9 @@
 #![feature(concat_idents)]
 
 extern crate libc;
-#[macro_use] #[no_link] extern crate rustc_bitflags;
+#[macro_use]
+#[no_link]
+extern crate rustc_bitflags;
 
 pub use self::IntPredicate::*;
 pub use self::RealPredicate::*;
@@ -68,7 +70,7 @@ impl LLVMRustResult {
 #[derive(Copy, Clone, Default, Debug)]
 pub struct Attributes {
     regular: Attribute,
-    dereferenceable_bytes: u64
+    dereferenceable_bytes: u64,
 }
 
 impl Attributes {
@@ -96,10 +98,7 @@ impl Attributes {
         unsafe {
             self.regular.apply_llfn(idx, llfn);
             if self.dereferenceable_bytes != 0 {
-                LLVMRustAddDereferenceableAttr(
-                    llfn,
-                    idx.as_uint(),
-                    self.dereferenceable_bytes);
+                LLVMRustAddDereferenceableAttr(llfn, idx.as_uint(), self.dereferenceable_bytes);
             }
         }
     }
@@ -108,27 +107,23 @@ impl Attributes {
         unsafe {
             self.regular.apply_callsite(idx, callsite);
             if self.dereferenceable_bytes != 0 {
-                LLVMRustAddDereferenceableCallSiteAttr(
-                    callsite,
-                    idx.as_uint(),
-                    self.dereferenceable_bytes);
+                LLVMRustAddDereferenceableCallSiteAttr(callsite,
+                                                       idx.as_uint(),
+                                                       self.dereferenceable_bytes);
             }
         }
     }
 }
 
-pub fn AddFunctionAttrStringValue(
-    llfn: ValueRef,
-    idx: AttributePlace,
-    attr: &'static str,
-    value: &'static str
-) {
+pub fn AddFunctionAttrStringValue(llfn: ValueRef,
+                                  idx: AttributePlace,
+                                  attr: &'static str,
+                                  value: &'static str) {
     unsafe {
-        LLVMRustAddFunctionAttrStringValue(
-            llfn,
-            idx.as_uint(),
-            attr.as_ptr() as *const _,
-            value.as_ptr() as *const _)
+        LLVMRustAddFunctionAttrStringValue(llfn,
+                                           idx.as_uint(),
+                                           attr.as_ptr() as *const _,
+                                           value.as_ptr() as *const _)
     }
 }
 
@@ -233,44 +228,30 @@ pub fn set_thread_local(global: ValueRef, is_thread_local: bool) {
 
 impl Attribute {
     pub fn apply_llfn(&self, idx: AttributePlace, llfn: ValueRef) {
-        unsafe {
-            LLVMRustAddFunctionAttribute(
-                llfn, idx.as_uint(), self.bits())
-        }
+        unsafe { LLVMRustAddFunctionAttribute(llfn, idx.as_uint(), self.bits()) }
     }
 
     pub fn apply_callsite(&self, idx: AttributePlace, callsite: ValueRef) {
-        unsafe {
-            LLVMRustAddCallSiteAttribute(
-                callsite, idx.as_uint(), self.bits())
-        }
+        unsafe { LLVMRustAddCallSiteAttribute(callsite, idx.as_uint(), self.bits()) }
     }
 
     pub fn unapply_llfn(&self, idx: AttributePlace, llfn: ValueRef) {
-        unsafe {
-            LLVMRustRemoveFunctionAttributes(
-                llfn, idx.as_uint(), self.bits())
-        }
+        unsafe { LLVMRustRemoveFunctionAttributes(llfn, idx.as_uint(), self.bits()) }
     }
 
-    pub fn toggle_llfn(&self,
-                       idx: AttributePlace,
-                       llfn: ValueRef,
-                       set: bool)
-    {
+    pub fn toggle_llfn(&self, idx: AttributePlace, llfn: ValueRef, set: bool) {
         if set {
             self.apply_llfn(idx, llfn);
         } else {
             self.unapply_llfn(idx, llfn);
         }
     }
-
 }
 
-/* Memory-managed interface to target data. */
+// Memory-managed interface to target data.
 
 pub struct TargetData {
-    pub lltd: TargetDataRef
+    pub lltd: TargetDataRef,
 }
 
 impl Drop for TargetData {
@@ -283,12 +264,10 @@ impl Drop for TargetData {
 
 pub fn mk_target_data(string_rep: &str) -> TargetData {
     let string_rep = CString::new(string_rep).unwrap();
-    TargetData {
-        lltd: unsafe { LLVMCreateTargetData(string_rep.as_ptr()) }
-    }
+    TargetData { lltd: unsafe { LLVMCreateTargetData(string_rep.as_ptr()) } }
 }
 
-/* Memory-managed interface to object files. */
+// Memory-managed interface to object files.
 
 pub struct ObjectFile {
     pub llof: ObjectFileRef,
@@ -301,12 +280,10 @@ impl ObjectFile {
             let llof = LLVMCreateObjectFile(llmb);
             if llof as isize == 0 {
                 // LLVMCreateObjectFile took ownership of llmb
-                return None
+                return None;
             }
 
-            Some(ObjectFile {
-                llof: llof,
-            })
+            Some(ObjectFile { llof: llof })
         }
     }
 }
@@ -319,10 +296,10 @@ impl Drop for ObjectFile {
     }
 }
 
-/* Memory-managed interface to section iterators. */
+// Memory-managed interface to section iterators.
 
 pub struct SectionIter {
-    pub llsi: SectionIteratorRef
+    pub llsi: SectionIteratorRef,
 }
 
 impl Drop for SectionIter {
@@ -334,11 +311,7 @@ impl Drop for SectionIter {
 }
 
 pub fn mk_section_iter(llof: ObjectFileRef) -> SectionIter {
-    unsafe {
-        SectionIter {
-            llsi: LLVMGetSections(llof)
-        }
-    }
+    unsafe { SectionIter { llsi: LLVMGetSections(llof) } }
 }
 
 /// Safe wrapper around `LLVMGetParam`, because segfaults are no fun.
@@ -361,15 +334,16 @@ pub fn get_params(llfn: ValueRef) -> Vec<ValueRef> {
     }
 }
 
-pub fn build_string<F>(f: F) -> Option<String> where F: FnOnce(RustStringRef){
+pub fn build_string<F>(f: F) -> Option<String>
+    where F: FnOnce(RustStringRef)
+{
     let mut buf = RefCell::new(Vec::new());
     f(&mut buf as RustStringRepr as RustStringRef);
     String::from_utf8(buf.into_inner()).ok()
 }
 
 pub unsafe fn twine_to_string(tr: TwineRef) -> String {
-    build_string(|s| LLVMRustWriteTwineToString(tr, s))
-        .expect("got a non-UTF8 Twine from LLVM")
+    build_string(|s| LLVMRustWriteTwineToString(tr, s)).expect("got a non-UTF8 Twine from LLVM")
 }
 
 pub unsafe fn debug_loc_to_string(c: ContextRef, tr: DebugLocRef) -> String {
@@ -462,9 +436,7 @@ impl OperandBundleDef {
     pub fn new(name: &str, vals: &[ValueRef]) -> OperandBundleDef {
         let name = CString::new(name).unwrap();
         let def = unsafe {
-            LLVMRustBuildOperandBundleDef(name.as_ptr(),
-                                          vals.as_ptr(),
-                                          vals.len() as c_uint)
+            LLVMRustBuildOperandBundleDef(name.as_ptr(), vals.as_ptr(), vals.len() as c_uint)
         };
         OperandBundleDef { inner: def }
     }