From e17c16d55b20b9d2702fafa017263406d1e94042 Mon Sep 17 00:00:00 2001
From: DianQK <dianqk@dianqk.net>
Date: Tue, 4 Jun 2024 22:46:20 +0800
Subject: [PATCH] Format C++ files in `llvm-wrapper`

---
 .../llvm-wrapper/ArchiveWrapper.cpp           |   33 +-
 compiler/rustc_llvm/llvm-wrapper/Linker.cpp   |   18 +-
 .../rustc_llvm/llvm-wrapper/PassWrapper.cpp   |  472 ++++----
 .../rustc_llvm/llvm-wrapper/RustWrapper.cpp   | 1005 ++++++++---------
 .../llvm-wrapper/SuppressLLVMWarnings.h       |   14 +-
 .../rustc_llvm/llvm-wrapper/SymbolWrapper.cpp |   23 +-
 6 files changed, 754 insertions(+), 811 deletions(-)

diff --git a/compiler/rustc_llvm/llvm-wrapper/ArchiveWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/ArchiveWrapper.cpp
index 8871f410e36..a8c278741a7 100644
--- a/compiler/rustc_llvm/llvm-wrapper/ArchiveWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/ArchiveWrapper.cpp
@@ -13,10 +13,7 @@ struct RustArchiveMember {
   Archive::Child Child;
 
   RustArchiveMember()
-      : Filename(nullptr), Name(nullptr),
-        Child(nullptr, nullptr, nullptr)
-  {
-  }
+      : Filename(nullptr), Name(nullptr), Child(nullptr, nullptr, nullptr) {}
   ~RustArchiveMember() {}
 };
 
@@ -27,11 +24,8 @@ struct RustArchiveIterator {
   std::unique_ptr<Error> Err;
 
   RustArchiveIterator(Archive::child_iterator Cur, Archive::child_iterator End,
-      std::unique_ptr<Error> Err)
-    : First(true),
-      Cur(Cur),
-      End(End),
-      Err(std::move(Err)) {}
+                      std::unique_ptr<Error> Err)
+      : First(true), Cur(Cur), End(End), Err(std::move(Err)) {}
 };
 
 enum class LLVMRustArchiveKind {
@@ -66,8 +60,8 @@ typedef Archive::Child const *LLVMRustArchiveChildConstRef;
 typedef RustArchiveIterator *LLVMRustArchiveIteratorRef;
 
 extern "C" LLVMRustArchiveRef LLVMRustOpenArchive(char *Path) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BufOr =
-      MemoryBuffer::getFile(Path, /*IsText*/false, /*RequiresNullTerminator=*/false);
+  ErrorOr<std::unique_ptr<MemoryBuffer>> BufOr = MemoryBuffer::getFile(
+      Path, /*IsText*/ false, /*RequiresNullTerminator=*/false);
   if (!BufOr) {
     LLVMRustSetLastError(BufOr.getError().message().c_str());
     return nullptr;
@@ -146,8 +140,8 @@ extern "C" const char *
 LLVMRustArchiveChildName(LLVMRustArchiveChildConstRef Child, size_t *Size) {
   Expected<StringRef> NameOrErr = Child->getName();
   if (!NameOrErr) {
-    // rustc_codegen_llvm currently doesn't use this error string, but it might be
-    // useful in the future, and in the meantime this tells LLVM that the
+    // rustc_codegen_llvm currently doesn't use this error string, but it might
+    // be useful in the future, and in the meantime this tells LLVM that the
     // error was not ignored and that it shouldn't abort the process.
     LLVMRustSetLastError(toString(NameOrErr.takeError()).c_str());
     return nullptr;
@@ -172,10 +166,9 @@ extern "C" void LLVMRustArchiveMemberFree(LLVMRustArchiveMemberRef Member) {
   delete Member;
 }
 
-extern "C" LLVMRustResult
-LLVMRustWriteArchive(char *Dst, size_t NumMembers,
-                     const LLVMRustArchiveMemberRef *NewMembers,
-                     bool WriteSymbtab, LLVMRustArchiveKind RustKind, bool isEC) {
+extern "C" LLVMRustResult LLVMRustWriteArchive(
+    char *Dst, size_t NumMembers, const LLVMRustArchiveMemberRef *NewMembers,
+    bool WriteSymbtab, LLVMRustArchiveKind RustKind, bool isEC) {
 
   std::vector<NewArchiveMember> Members;
   auto Kind = fromRust(RustKind);
@@ -206,8 +199,10 @@ LLVMRustWriteArchive(char *Dst, size_t NumMembers,
 #if LLVM_VERSION_LT(18, 0)
   auto Result = writeArchive(Dst, Members, WriteSymbtab, Kind, true, false);
 #else
-  auto SymtabMode = WriteSymbtab ? SymtabWritingMode::NormalSymtab : SymtabWritingMode::NoSymtab;
-  auto Result = writeArchive(Dst, Members, SymtabMode, Kind, true, false, nullptr, isEC);
+  auto SymtabMode = WriteSymbtab ? SymtabWritingMode::NormalSymtab
+                                 : SymtabWritingMode::NoSymtab;
+  auto Result =
+      writeArchive(Dst, Members, SymtabMode, Kind, true, false, nullptr, isEC);
 #endif
   if (!Result)
     return LLVMRustResult::Success;
diff --git a/compiler/rustc_llvm/llvm-wrapper/Linker.cpp b/compiler/rustc_llvm/llvm-wrapper/Linker.cpp
index 533df0f75f8..f43128ed550 100644
--- a/compiler/rustc_llvm/llvm-wrapper/Linker.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/Linker.cpp
@@ -1,5 +1,5 @@
-#include "SuppressLLVMWarnings.h"
 #include "llvm/Linker/Linker.h"
+#include "SuppressLLVMWarnings.h"
 
 #include "LLVMWrapper.h"
 
@@ -9,26 +9,18 @@ struct RustLinker {
   Linker L;
   LLVMContext &Ctx;
 
-  RustLinker(Module &M) :
-    L(M),
-    Ctx(M.getContext())
-  {}
+  RustLinker(Module &M) : L(M), Ctx(M.getContext()) {}
 };
 
-extern "C" RustLinker*
-LLVMRustLinkerNew(LLVMModuleRef DstRef) {
+extern "C" RustLinker *LLVMRustLinkerNew(LLVMModuleRef DstRef) {
   Module *Dst = unwrap(DstRef);
 
   return new RustLinker(*Dst);
 }
 
-extern "C" void
-LLVMRustLinkerFree(RustLinker *L) {
-  delete L;
-}
+extern "C" void LLVMRustLinkerFree(RustLinker *L) { delete L; }
 
-extern "C" bool
-LLVMRustLinkerAdd(RustLinker *L, char *BC, size_t Len) {
+extern "C" bool LLVMRustLinkerAdd(RustLinker *L, char *BC, size_t Len) {
   std::unique_ptr<MemoryBuffer> Buf =
       MemoryBuffer::getMemBufferCopy(StringRef(BC, Len));
 
diff --git a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
index a027ddcc150..c4cfc0b6dc6 100644
--- a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
@@ -2,23 +2,25 @@
 
 #include <cstddef>
 #include <iomanip>
-#include <vector>
 #include <set>
+#include <vector>
 
 #include "LLVMWrapper.h"
 
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
+#include "llvm/Bitcode/BitcodeWriter.h"
 #include "llvm/CodeGen/CommandFlags.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
-#include "llvm/IR/AutoUpgrade.h"
 #include "llvm/IR/AssemblyAnnotationWriter.h"
+#include "llvm/IR/AutoUpgrade.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Verifier.h"
+#include "llvm/LTO/LTO.h"
 #include "llvm/MC/TargetRegistry.h"
-#include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/IRObjectFile.h"
+#include "llvm/Object/ObjectFile.h"
 #include "llvm/Passes/PassBuilder.h"
 #include "llvm/Passes/PassPlugin.h"
 #include "llvm/Passes/StandardInstrumentations.h"
@@ -33,26 +35,24 @@
 #include "llvm/Transforms/IPO/ThinLTOBitcodeWriter.h"
 #include "llvm/Transforms/Utils/AddDiscriminators.h"
 #include "llvm/Transforms/Utils/FunctionImportUtils.h"
-#include "llvm/LTO/LTO.h"
-#include "llvm/Bitcode/BitcodeWriter.h"
 #if LLVM_VERSION_GE(18, 0)
 #include "llvm/TargetParser/Host.h"
 #endif
+#include "llvm/Support/TimeProfiler.h"
 #include "llvm/Transforms/Instrumentation.h"
 #include "llvm/Transforms/Instrumentation/AddressSanitizer.h"
 #include "llvm/Transforms/Instrumentation/DataFlowSanitizer.h"
-#include "llvm/Support/TimeProfiler.h"
 #if LLVM_VERSION_GE(19, 0)
 #include "llvm/Support/PGOOptions.h"
 #endif
 #include "llvm/Transforms/Instrumentation/GCOVProfiler.h"
-#include "llvm/Transforms/Instrumentation/InstrProfiling.h"
-#include "llvm/Transforms/Instrumentation/ThreadSanitizer.h"
-#include "llvm/Transforms/Instrumentation/MemorySanitizer.h"
 #include "llvm/Transforms/Instrumentation/HWAddressSanitizer.h"
+#include "llvm/Transforms/Instrumentation/InstrProfiling.h"
+#include "llvm/Transforms/Instrumentation/MemorySanitizer.h"
+#include "llvm/Transforms/Instrumentation/ThreadSanitizer.h"
+#include "llvm/Transforms/Utils.h"
 #include "llvm/Transforms/Utils/CanonicalizeAliases.h"
 #include "llvm/Transforms/Utils/NameAnonGlobals.h"
-#include "llvm/Transforms/Utils.h"
 
 using namespace llvm;
 
@@ -74,7 +74,7 @@ extern "C" void LLVMRustTimeTraceProfilerFinishThread() {
   timeTraceProfilerFinishThread();
 }
 
-extern "C" void LLVMRustTimeTraceProfilerFinish(const char* FileName) {
+extern "C" void LLVMRustTimeTraceProfilerFinish(const char *FileName) {
   auto FN = StringRef(FileName);
   std::error_code EC;
   auto OS = raw_fd_ostream(FN, EC, sys::fs::CD_CreateAlways);
@@ -188,7 +188,7 @@ extern "C" void LLVMRustTimeTraceProfilerFinish(const char* FileName) {
   SUBTARGET_HEXAGON                                                            \
   SUBTARGET_XTENSA                                                             \
   SUBTARGET_RISCV                                                              \
-  SUBTARGET_LOONGARCH                                                          \
+  SUBTARGET_LOONGARCH
 
 #define SUBTARGET(x)                                                           \
   namespace llvm {                                                             \
@@ -215,8 +215,7 @@ enum class LLVMRustCodeModel {
   None,
 };
 
-static std::optional<CodeModel::Model>
-fromRust(LLVMRustCodeModel Model) {
+static std::optional<CodeModel::Model> fromRust(LLVMRustCodeModel Model) {
   switch (Model) {
   case LLVMRustCodeModel::Tiny:
     return CodeModel::Tiny;
@@ -243,9 +242,9 @@ enum class LLVMRustCodeGenOptLevel {
 };
 
 #if LLVM_VERSION_GE(18, 0)
-  using CodeGenOptLevelEnum = llvm::CodeGenOptLevel;
+using CodeGenOptLevelEnum = llvm::CodeGenOptLevel;
 #else
-  using CodeGenOptLevelEnum = llvm::CodeGenOpt::Level;
+using CodeGenOptLevelEnum = llvm::CodeGenOpt::Level;
 #endif
 
 static CodeGenOptLevelEnum fromRust(LLVMRustCodeGenOptLevel Level) {
@@ -319,48 +318,49 @@ static Reloc::Model fromRust(LLVMRustRelocModel RustReloc) {
 }
 
 /// getLongestEntryLength - Return the length of the longest entry in the table.
-template<typename KV>
-static size_t getLongestEntryLength(ArrayRef<KV> Table) {
+template <typename KV> static size_t getLongestEntryLength(ArrayRef<KV> Table) {
   size_t MaxLen = 0;
   for (auto &I : Table)
     MaxLen = std::max(MaxLen, std::strlen(I.Key));
   return MaxLen;
 }
 
-using PrintBackendInfo = void(void*, const char* Data, size_t Len);
+using PrintBackendInfo = void(void *, const char *Data, size_t Len);
 
 extern "C" void LLVMRustPrintTargetCPUs(LLVMTargetMachineRef TM,
-                                        const char* TargetCPU,
-                                        PrintBackendInfo Print,
-                                        void* Out) {
+                                        const char *TargetCPU,
+                                        PrintBackendInfo Print, void *Out) {
   const TargetMachine *Target = unwrap(TM);
-  const Triple::ArchType HostArch = Triple(sys::getDefaultTargetTriple()).getArch();
+  const Triple::ArchType HostArch =
+      Triple(sys::getDefaultTargetTriple()).getArch();
   const Triple::ArchType TargetArch = Target->getTargetTriple().getArch();
 
   std::ostringstream Buf;
 
   const MCSubtargetInfo *MCInfo = Target->getMCSubtargetInfo();
-  const ArrayRef<SubtargetSubTypeKV> CPUTable = MCInfo->getAllProcessorDescriptions();
+  const ArrayRef<SubtargetSubTypeKV> CPUTable =
+      MCInfo->getAllProcessorDescriptions();
   unsigned MaxCPULen = getLongestEntryLength(CPUTable);
 
   Buf << "Available CPUs for this target:\n";
   // Don't print the "native" entry when the user specifies --target with a
   // different arch since that could be wrong or misleading.
   if (HostArch == TargetArch) {
-    MaxCPULen = std::max(MaxCPULen, (unsigned) std::strlen("native"));
+    MaxCPULen = std::max(MaxCPULen, (unsigned)std::strlen("native"));
     const StringRef HostCPU = sys::getHostCPUName();
     Buf << "    " << std::left << std::setw(MaxCPULen) << "native"
         << " - Select the CPU of the current host "
-           "(currently " << HostCPU.str() << ").\n";
+           "(currently "
+        << HostCPU.str() << ").\n";
   }
   for (auto &CPU : CPUTable) {
     // Compare cpu against current target to label the default
     if (strcmp(CPU.Key, TargetCPU) == 0) {
       Buf << "    " << std::left << std::setw(MaxCPULen) << CPU.Key
           << " - This is the default target CPU for the current build target "
-             "(currently " << Target->getTargetTriple().str() << ").";
-    }
-    else {
+             "(currently "
+          << Target->getTargetTriple().str() << ").";
+    } else {
       Buf << "    " << CPU.Key;
     }
     Buf << "\n";
@@ -374,7 +374,8 @@ extern "C" size_t LLVMRustGetTargetFeaturesCount(LLVMTargetMachineRef TM) {
 #if LLVM_VERSION_GE(18, 0)
   const TargetMachine *Target = unwrap(TM);
   const MCSubtargetInfo *MCInfo = Target->getMCSubtargetInfo();
-  const ArrayRef<SubtargetFeatureKV> FeatTable = MCInfo->getAllProcessorFeatures();
+  const ArrayRef<SubtargetFeatureKV> FeatTable =
+      MCInfo->getAllProcessorFeatures();
   return FeatTable.size();
 #else
   return 0;
@@ -382,18 +383,20 @@ extern "C" size_t LLVMRustGetTargetFeaturesCount(LLVMTargetMachineRef TM) {
 }
 
 extern "C" void LLVMRustGetTargetFeature(LLVMTargetMachineRef TM, size_t Index,
-                                         const char** Feature, const char** Desc) {
+                                         const char **Feature,
+                                         const char **Desc) {
 #if LLVM_VERSION_GE(18, 0)
   const TargetMachine *Target = unwrap(TM);
   const MCSubtargetInfo *MCInfo = Target->getMCSubtargetInfo();
-  const ArrayRef<SubtargetFeatureKV> FeatTable = MCInfo->getAllProcessorFeatures();
+  const ArrayRef<SubtargetFeatureKV> FeatTable =
+      MCInfo->getAllProcessorFeatures();
   const SubtargetFeatureKV Feat = FeatTable[Index];
   *Feature = Feat.Key;
   *Desc = Feat.Desc;
 #endif
 }
 
-extern "C" const char* LLVMRustGetHostCPUName(size_t *len) {
+extern "C" const char *LLVMRustGetHostCPUName(size_t *len) {
   StringRef Name = sys::getHostCPUName();
   *len = Name.size();
   return Name.data();
@@ -403,19 +406,11 @@ extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
     const char *TripleStr, const char *CPU, const char *Feature,
     const char *ABIStr, LLVMRustCodeModel RustCM, LLVMRustRelocModel RustReloc,
     LLVMRustCodeGenOptLevel RustOptLevel, bool UseSoftFloat,
-    bool FunctionSections,
-    bool DataSections,
-    bool UniqueSectionNames,
-    bool TrapUnreachable,
-    bool Singlethread,
-    bool AsmComments,
-    bool EmitStackSizeSection,
-    bool RelaxELFRelocations,
-    bool UseInitArray,
-    const char *SplitDwarfFile,
-    const char *OutputObjFile,
-    const char *DebugInfoCompression,
-    bool UseEmulatedTls,
+    bool FunctionSections, bool DataSections, bool UniqueSectionNames,
+    bool TrapUnreachable, bool Singlethread, bool AsmComments,
+    bool EmitStackSizeSection, bool RelaxELFRelocations, bool UseInitArray,
+    const char *SplitDwarfFile, const char *OutputObjFile,
+    const char *DebugInfoCompression, bool UseEmulatedTls,
     const char *ArgsCstrBuff, size_t ArgsCstrBuffLen) {
 
   auto OptLevel = fromRust(RustOptLevel);
@@ -444,18 +439,20 @@ extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
   Options.MCOptions.PreserveAsmComments = AsmComments;
   Options.MCOptions.ABIName = ABIStr;
   if (SplitDwarfFile) {
-      Options.MCOptions.SplitDwarfFile = SplitDwarfFile;
+    Options.MCOptions.SplitDwarfFile = SplitDwarfFile;
   }
   if (OutputObjFile) {
-      Options.ObjectFilenameForDebug = OutputObjFile;
+    Options.ObjectFilenameForDebug = OutputObjFile;
   }
-  if (!strcmp("zlib", DebugInfoCompression) && llvm::compression::zlib::isAvailable()) {
+  if (!strcmp("zlib", DebugInfoCompression) &&
+      llvm::compression::zlib::isAvailable()) {
 #if LLVM_VERSION_GE(19, 0)
     Options.MCOptions.CompressDebugSections = DebugCompressionType::Zlib;
 #else
     Options.CompressDebugSections = DebugCompressionType::Zlib;
 #endif
-  } else if (!strcmp("zstd", DebugInfoCompression) && llvm::compression::zstd::isAvailable()) {
+  } else if (!strcmp("zstd", DebugInfoCompression) &&
+             llvm::compression::zstd::isAvailable()) {
 #if LLVM_VERSION_GE(19, 0)
     Options.MCOptions.CompressDebugSections = DebugCompressionType::Zstd;
 #else
@@ -499,24 +496,21 @@ extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
 
   Options.EmitStackSizeSection = EmitStackSizeSection;
 
-
-  if (ArgsCstrBuff != nullptr)
-  {
+  if (ArgsCstrBuff != nullptr) {
     int buffer_offset = 0;
     assert(ArgsCstrBuff[ArgsCstrBuffLen - 1] == '\0');
 
     const size_t arg0_len = std::strlen(ArgsCstrBuff);
-    char* arg0 = new char[arg0_len + 1];
+    char *arg0 = new char[arg0_len + 1];
     memcpy(arg0, ArgsCstrBuff, arg0_len);
     arg0[arg0_len] = '\0';
     buffer_offset += arg0_len + 1;
 
-    const int num_cmd_arg_strings =
-      std::count(&ArgsCstrBuff[buffer_offset], &ArgsCstrBuff[ArgsCstrBuffLen], '\0');
+    const int num_cmd_arg_strings = std::count(
+        &ArgsCstrBuff[buffer_offset], &ArgsCstrBuff[ArgsCstrBuffLen], '\0');
 
-    std::string* cmd_arg_strings = new std::string[num_cmd_arg_strings];
-    for (int i = 0; i < num_cmd_arg_strings; ++i)
-    {
+    std::string *cmd_arg_strings = new std::string[num_cmd_arg_strings];
+    for (int i = 0; i < num_cmd_arg_strings; ++i) {
       assert(buffer_offset < ArgsCstrBuffLen);
       const int len = std::strlen(ArgsCstrBuff + buffer_offset);
       cmd_arg_strings[i] = std::string(&ArgsCstrBuff[buffer_offset], len);
@@ -527,7 +521,7 @@ extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
 
     Options.MCOptions.Argv0 = arg0;
     Options.MCOptions.CommandLineArgs =
-      llvm::ArrayRef<std::string>(cmd_arg_strings, num_cmd_arg_strings);
+        llvm::ArrayRef<std::string>(cmd_arg_strings, num_cmd_arg_strings);
   }
 
   TargetMachine *TM = TheTarget->createTargetMachine(
@@ -537,7 +531,7 @@ extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
 
 extern "C" void LLVMRustDisposeTargetMachine(LLVMTargetMachineRef TM) {
 
-  MCTargetOptions& MCOptions = unwrap(TM)->Options.MCOptions;
+  MCTargetOptions &MCOptions = unwrap(TM)->Options.MCOptions;
   delete[] MCOptions.Argv0;
   delete[] MCOptions.CommandLineArgs.data();
 
@@ -613,7 +607,7 @@ LLVMRustWriteOutputFile(LLVMTargetMachineRef Target, LLVMPassManagerRef PMR,
     auto DOS = raw_fd_ostream(DwoPath, EC, sys::fs::OF_None);
     EC.clear();
     if (EC)
-        ErrorInfo = EC.message();
+      ErrorInfo = EC.message();
     if (ErrorInfo != "") {
       LLVMRustSetLastError(ErrorInfo.c_str());
       return LLVMRustResult::Failure;
@@ -633,10 +627,12 @@ LLVMRustWriteOutputFile(LLVMTargetMachineRef Target, LLVMPassManagerRef PMR,
   return LLVMRustResult::Success;
 }
 
-extern "C" typedef void (*LLVMRustSelfProfileBeforePassCallback)(void*, // LlvmSelfProfiler
-                                                      const char*,      // pass name
-                                                      const char*);     // IR name
-extern "C" typedef void (*LLVMRustSelfProfileAfterPassCallback)(void*); // LlvmSelfProfiler
+extern "C" typedef void (*LLVMRustSelfProfileBeforePassCallback)(
+    void *,        // LlvmSelfProfiler
+    const char *,  // pass name
+    const char *); // IR name
+extern "C" typedef void (*LLVMRustSelfProfileAfterPassCallback)(
+    void *); // LlvmSelfProfiler
 
 std::string LLVMRustwrappedIrGetName(const llvm::Any &WrappedIr) {
   if (const auto *Cast = any_cast<const Module *>(&WrappedIr))
@@ -650,35 +646,35 @@ std::string LLVMRustwrappedIrGetName(const llvm::Any &WrappedIr) {
   return "<UNKNOWN>";
 }
 
-
 void LLVMSelfProfileInitializeCallbacks(
-    PassInstrumentationCallbacks& PIC, void* LlvmSelfProfiler,
+    PassInstrumentationCallbacks &PIC, void *LlvmSelfProfiler,
     LLVMRustSelfProfileBeforePassCallback BeforePassCallback,
     LLVMRustSelfProfileAfterPassCallback AfterPassCallback) {
-  PIC.registerBeforeNonSkippedPassCallback([LlvmSelfProfiler, BeforePassCallback](
-                                           StringRef Pass, llvm::Any Ir) {
-    std::string PassName = Pass.str();
-    std::string IrName = LLVMRustwrappedIrGetName(Ir);
-    BeforePassCallback(LlvmSelfProfiler, PassName.c_str(), IrName.c_str());
-  });
+  PIC.registerBeforeNonSkippedPassCallback(
+      [LlvmSelfProfiler, BeforePassCallback](StringRef Pass, llvm::Any Ir) {
+        std::string PassName = Pass.str();
+        std::string IrName = LLVMRustwrappedIrGetName(Ir);
+        BeforePassCallback(LlvmSelfProfiler, PassName.c_str(), IrName.c_str());
+      });
 
   PIC.registerAfterPassCallback(
-      [LlvmSelfProfiler, AfterPassCallback](StringRef Pass, llvm::Any IR,
-                                            const PreservedAnalyses &Preserved) {
+      [LlvmSelfProfiler, AfterPassCallback](
+          StringRef Pass, llvm::Any IR, const PreservedAnalyses &Preserved) {
         AfterPassCallback(LlvmSelfProfiler);
       });
 
   PIC.registerAfterPassInvalidatedCallback(
-      [LlvmSelfProfiler, AfterPassCallback](StringRef Pass, const PreservedAnalyses &Preserved) {
+      [LlvmSelfProfiler,
+       AfterPassCallback](StringRef Pass, const PreservedAnalyses &Preserved) {
         AfterPassCallback(LlvmSelfProfiler);
       });
 
-  PIC.registerBeforeAnalysisCallback([LlvmSelfProfiler, BeforePassCallback](
-                                         StringRef Pass, llvm::Any Ir) {
-    std::string PassName = Pass.str();
-    std::string IrName = LLVMRustwrappedIrGetName(Ir);
-    BeforePassCallback(LlvmSelfProfiler, PassName.c_str(), IrName.c_str());
-  });
+  PIC.registerBeforeAnalysisCallback(
+      [LlvmSelfProfiler, BeforePassCallback](StringRef Pass, llvm::Any Ir) {
+        std::string PassName = Pass.str();
+        std::string IrName = LLVMRustwrappedIrGetName(Ir);
+        BeforePassCallback(LlvmSelfProfiler, PassName.c_str(), IrName.c_str());
+      });
 
   PIC.registerAfterAnalysisCallback(
       [LlvmSelfProfiler, AfterPassCallback](StringRef Pass, llvm::Any Ir) {
@@ -704,7 +700,7 @@ struct LLVMRustSanitizerOptions {
   bool SanitizeKCFI;
   bool SanitizeMemory;
   bool SanitizeMemoryRecover;
-  int  SanitizeMemoryTrackOrigins;
+  int SanitizeMemoryTrackOrigins;
   bool SanitizeThread;
   bool SanitizeHWAddress;
   bool SanitizeHWAddressRecover;
@@ -712,31 +708,25 @@ struct LLVMRustSanitizerOptions {
   bool SanitizeKernelAddressRecover;
 };
 
-extern "C" LLVMRustResult
-LLVMRustOptimize(
-    LLVMModuleRef ModuleRef,
-    LLVMTargetMachineRef TMRef,
-    LLVMRustPassBuilderOptLevel OptLevelRust,
-    LLVMRustOptStage OptStage,
-    bool IsLinkerPluginLTO,
-    bool NoPrepopulatePasses, bool VerifyIR, bool UseThinLTOBuffers,
-    bool MergeFunctions, bool UnrollLoops, bool SLPVectorize, bool LoopVectorize,
-    bool DisableSimplifyLibCalls, bool EmitLifetimeMarkers,
-    LLVMRustSanitizerOptions *SanitizerOptions,
-    const char *PGOGenPath, const char *PGOUsePath,
-    bool InstrumentCoverage, const char *InstrProfileOutput,
-    bool InstrumentGCOV,
+extern "C" LLVMRustResult LLVMRustOptimize(
+    LLVMModuleRef ModuleRef, LLVMTargetMachineRef TMRef,
+    LLVMRustPassBuilderOptLevel OptLevelRust, LLVMRustOptStage OptStage,
+    bool IsLinkerPluginLTO, bool NoPrepopulatePasses, bool VerifyIR,
+    bool UseThinLTOBuffers, bool MergeFunctions, bool UnrollLoops,
+    bool SLPVectorize, bool LoopVectorize, bool DisableSimplifyLibCalls,
+    bool EmitLifetimeMarkers, LLVMRustSanitizerOptions *SanitizerOptions,
+    const char *PGOGenPath, const char *PGOUsePath, bool InstrumentCoverage,
+    const char *InstrProfileOutput, bool InstrumentGCOV,
     const char *PGOSampleUsePath, bool DebugInfoForProfiling,
-    void* LlvmSelfProfiler,
+    void *LlvmSelfProfiler,
     LLVMRustSelfProfileBeforePassCallback BeforePassCallback,
     LLVMRustSelfProfileAfterPassCallback AfterPassCallback,
-    const char *ExtraPasses, size_t ExtraPassesLen,
-    const char *LLVMPlugins, size_t LLVMPluginsLen) {
+    const char *ExtraPasses, size_t ExtraPassesLen, const char *LLVMPlugins,
+    size_t LLVMPluginsLen) {
   Module *TheModule = unwrap(ModuleRef);
   TargetMachine *TM = unwrap(TMRef);
   OptimizationLevel OptLevel = fromRust(OptLevelRust);
 
-
   PipelineTuningOptions PTO;
   PTO.LoopUnrolling = UnrollLoops;
   PTO.LoopInterleaving = UnrollLoops;
@@ -751,38 +741,39 @@ LLVMRustOptimize(
   StandardInstrumentations SI(TheModule->getContext(), DebugPassManager);
   SI.registerCallbacks(PIC);
 
-  if (LlvmSelfProfiler){
-    LLVMSelfProfileInitializeCallbacks(PIC,LlvmSelfProfiler,BeforePassCallback,AfterPassCallback);
+  if (LlvmSelfProfiler) {
+    LLVMSelfProfileInitializeCallbacks(PIC, LlvmSelfProfiler,
+                                       BeforePassCallback, AfterPassCallback);
   }
 
   std::optional<PGOOptions> PGOOpt;
   auto FS = vfs::getRealFileSystem();
   if (PGOGenPath) {
     assert(!PGOUsePath && !PGOSampleUsePath);
-    PGOOpt = PGOOptions(PGOGenPath, "", "", "", FS,
-                        PGOOptions::IRInstr, PGOOptions::NoCSAction,
+    PGOOpt = PGOOptions(PGOGenPath, "", "", "", FS, PGOOptions::IRInstr,
+                        PGOOptions::NoCSAction,
 #if LLVM_VERSION_GE(19, 0)
                         PGOOptions::ColdFuncOpt::Default,
 #endif
                         DebugInfoForProfiling);
   } else if (PGOUsePath) {
     assert(!PGOSampleUsePath);
-    PGOOpt = PGOOptions(PGOUsePath, "", "", "", FS,
-                        PGOOptions::IRUse, PGOOptions::NoCSAction,
+    PGOOpt = PGOOptions(PGOUsePath, "", "", "", FS, PGOOptions::IRUse,
+                        PGOOptions::NoCSAction,
 #if LLVM_VERSION_GE(19, 0)
                         PGOOptions::ColdFuncOpt::Default,
 #endif
                         DebugInfoForProfiling);
   } else if (PGOSampleUsePath) {
-    PGOOpt = PGOOptions(PGOSampleUsePath, "", "", "", FS,
-                        PGOOptions::SampleUse, PGOOptions::NoCSAction,
+    PGOOpt = PGOOptions(PGOSampleUsePath, "", "", "", FS, PGOOptions::SampleUse,
+                        PGOOptions::NoCSAction,
 #if LLVM_VERSION_GE(19, 0)
                         PGOOptions::ColdFuncOpt::Default,
 #endif
                         DebugInfoForProfiling);
   } else if (DebugInfoForProfiling) {
-    PGOOpt = PGOOptions("", "", "", "", FS,
-                        PGOOptions::NoAction, PGOOptions::NoCSAction,
+    PGOOpt = PGOOptions("", "", "", "", FS, PGOOptions::NoAction,
+                        PGOOptions::NoCSAction,
 #if LLVM_VERSION_GE(19, 0)
                         PGOOptions::ColdFuncOpt::Default,
 #endif
@@ -799,7 +790,7 @@ LLVMRustOptimize(
     auto PluginsStr = StringRef(LLVMPlugins, LLVMPluginsLen);
     SmallVector<StringRef> Plugins;
     PluginsStr.split(Plugins, ',', -1, false);
-    for (auto PluginPath: Plugins) {
+    for (auto PluginPath : Plugins) {
       auto Plugin = PassPlugin::Load(PluginPath.str());
       if (!Plugin) {
         auto Err = Plugin.takeError();
@@ -814,7 +805,8 @@ LLVMRustOptimize(
   FAM.registerPass([&] { return PB.buildDefaultAAPipeline(); });
 
   Triple TargetTriple(TheModule->getTargetTriple());
-  std::unique_ptr<TargetLibraryInfoImpl> TLII(new TargetLibraryInfoImpl(TargetTriple));
+  std::unique_ptr<TargetLibraryInfoImpl> TLII(
+      new TargetLibraryInfoImpl(TargetTriple));
   if (DisableSimplifyLibCalls)
     TLII->disableAllFunctions();
   FAM.registerPass([&] { return TargetLibraryAnalysis(*TLII); });
@@ -825,58 +817,53 @@ LLVMRustOptimize(
   PB.registerLoopAnalyses(LAM);
   PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
 
-  // We manually collect pipeline callbacks so we can apply them at O0, where the
-  // PassBuilder does not create a pipeline.
+  // We manually collect pipeline callbacks so we can apply them at O0, where
+  // the PassBuilder does not create a pipeline.
   std::vector<std::function<void(ModulePassManager &, OptimizationLevel)>>
       PipelineStartEPCallbacks;
   std::vector<std::function<void(ModulePassManager &, OptimizationLevel)>>
       OptimizerLastEPCallbacks;
 
-  if (!IsLinkerPluginLTO
-      && SanitizerOptions && SanitizerOptions->SanitizeCFI
-      && !NoPrepopulatePasses) {
+  if (!IsLinkerPluginLTO && SanitizerOptions && SanitizerOptions->SanitizeCFI &&
+      !NoPrepopulatePasses) {
     PipelineStartEPCallbacks.push_back(
-      [](ModulePassManager &MPM, OptimizationLevel Level) {
-        MPM.addPass(LowerTypeTestsPass(/*ExportSummary=*/nullptr,
-                                       /*ImportSummary=*/nullptr,
-                                       /*DropTypeTests=*/false));
-      }
-    );
+        [](ModulePassManager &MPM, OptimizationLevel Level) {
+          MPM.addPass(LowerTypeTestsPass(/*ExportSummary=*/nullptr,
+                                         /*ImportSummary=*/nullptr,
+                                         /*DropTypeTests=*/false));
+        });
   }
 
   if (VerifyIR) {
     PipelineStartEPCallbacks.push_back(
-      [VerifyIR](ModulePassManager &MPM, OptimizationLevel Level) {
-        MPM.addPass(VerifierPass());
-      }
-    );
+        [VerifyIR](ModulePassManager &MPM, OptimizationLevel Level) {
+          MPM.addPass(VerifierPass());
+        });
   }
 
   if (InstrumentGCOV) {
     PipelineStartEPCallbacks.push_back(
-      [](ModulePassManager &MPM, OptimizationLevel Level) {
-        MPM.addPass(GCOVProfilerPass(GCOVOptions::getDefault()));
-      }
-    );
+        [](ModulePassManager &MPM, OptimizationLevel Level) {
+          MPM.addPass(GCOVProfilerPass(GCOVOptions::getDefault()));
+        });
   }
 
   if (InstrumentCoverage) {
     PipelineStartEPCallbacks.push_back(
-      [InstrProfileOutput](ModulePassManager &MPM, OptimizationLevel Level) {
-        InstrProfOptions Options;
-        if (InstrProfileOutput) {
-          Options.InstrProfileOutput = InstrProfileOutput;
-        }
-        // cargo run tests in multhreading mode by default
-        // so use atomics for coverage counters
-        Options.Atomic = true;
+        [InstrProfileOutput](ModulePassManager &MPM, OptimizationLevel Level) {
+          InstrProfOptions Options;
+          if (InstrProfileOutput) {
+            Options.InstrProfileOutput = InstrProfileOutput;
+          }
+          // cargo run tests in multhreading mode by default
+          // so use atomics for coverage counters
+          Options.Atomic = true;
 #if LLVM_VERSION_GE(18, 0)
-        MPM.addPass(InstrProfilingLoweringPass(Options, false));
+          MPM.addPass(InstrProfilingLoweringPass(Options, false));
 #else
-        MPM.addPass(InstrProfiling(Options, false));
+          MPM.addPass(InstrProfiling(Options, false));
 #endif
-      }
-    );
+        });
   }
 
   if (SanitizerOptions) {
@@ -886,10 +873,9 @@ LLVMRustOptimize(
           SanitizerOptions->SanitizeDataFlowABIList +
               SanitizerOptions->SanitizeDataFlowABIListLen);
       OptimizerLastEPCallbacks.push_back(
-        [ABIListFiles](ModulePassManager &MPM, OptimizationLevel Level) {
-          MPM.addPass(DataFlowSanitizerPass(ABIListFiles));
-        }
-      );
+          [ABIListFiles](ModulePassManager &MPM, OptimizationLevel Level) {
+            MPM.addPass(DataFlowSanitizerPass(ABIListFiles));
+          });
     }
 
     if (SanitizerOptions->SanitizeMemory) {
@@ -899,54 +885,54 @@ LLVMRustOptimize(
           /*CompileKernel=*/false,
           /*EagerChecks=*/true);
       OptimizerLastEPCallbacks.push_back(
-        [Options](ModulePassManager &MPM, OptimizationLevel Level) {
-          MPM.addPass(MemorySanitizerPass(Options));
-        }
-      );
+          [Options](ModulePassManager &MPM, OptimizationLevel Level) {
+            MPM.addPass(MemorySanitizerPass(Options));
+          });
     }
 
     if (SanitizerOptions->SanitizeThread) {
-      OptimizerLastEPCallbacks.push_back(
-        [](ModulePassManager &MPM, OptimizationLevel Level) {
-          MPM.addPass(ModuleThreadSanitizerPass());
-          MPM.addPass(createModuleToFunctionPassAdaptor(ThreadSanitizerPass()));
-        }
-      );
+      OptimizerLastEPCallbacks.push_back([](ModulePassManager &MPM,
+                                            OptimizationLevel Level) {
+        MPM.addPass(ModuleThreadSanitizerPass());
+        MPM.addPass(createModuleToFunctionPassAdaptor(ThreadSanitizerPass()));
+      });
     }
 
-    if (SanitizerOptions->SanitizeAddress || SanitizerOptions->SanitizeKernelAddress) {
+    if (SanitizerOptions->SanitizeAddress ||
+        SanitizerOptions->SanitizeKernelAddress) {
       OptimizerLastEPCallbacks.push_back(
-        [SanitizerOptions](ModulePassManager &MPM, OptimizationLevel Level) {
-          auto CompileKernel = SanitizerOptions->SanitizeKernelAddress;
-          AddressSanitizerOptions opts = AddressSanitizerOptions{
-            CompileKernel,
-            SanitizerOptions->SanitizeAddressRecover
-              || SanitizerOptions->SanitizeKernelAddressRecover,
-            /*UseAfterScope=*/true,
-            AsanDetectStackUseAfterReturnMode::Runtime,
-          };
-          MPM.addPass(AddressSanitizerPass(opts));
-        }
-      );
+          [SanitizerOptions](ModulePassManager &MPM, OptimizationLevel Level) {
+            auto CompileKernel = SanitizerOptions->SanitizeKernelAddress;
+            AddressSanitizerOptions opts = AddressSanitizerOptions{
+                CompileKernel,
+                SanitizerOptions->SanitizeAddressRecover ||
+                    SanitizerOptions->SanitizeKernelAddressRecover,
+                /*UseAfterScope=*/true,
+                AsanDetectStackUseAfterReturnMode::Runtime,
+            };
+            MPM.addPass(AddressSanitizerPass(opts));
+          });
     }
     if (SanitizerOptions->SanitizeHWAddress) {
       OptimizerLastEPCallbacks.push_back(
-        [SanitizerOptions](ModulePassManager &MPM, OptimizationLevel Level) {
-          HWAddressSanitizerOptions opts(
-              /*CompileKernel=*/false, SanitizerOptions->SanitizeHWAddressRecover,
-              /*DisableOptimization=*/false);
-          MPM.addPass(HWAddressSanitizerPass(opts));
-        }
-      );
+          [SanitizerOptions](ModulePassManager &MPM, OptimizationLevel Level) {
+            HWAddressSanitizerOptions opts(
+                /*CompileKernel=*/false,
+                SanitizerOptions->SanitizeHWAddressRecover,
+                /*DisableOptimization=*/false);
+            MPM.addPass(HWAddressSanitizerPass(opts));
+          });
     }
   }
 
   ModulePassManager MPM;
   bool NeedThinLTOBufferPasses = UseThinLTOBuffers;
   if (!NoPrepopulatePasses) {
-    // The pre-link pipelines don't support O0 and require using buildO0DefaultPipeline() instead.
-    // At the same time, the LTO pipelines do support O0 and using them is required.
-    bool IsLTO = OptStage == LLVMRustOptStage::ThinLTO || OptStage == LLVMRustOptStage::FatLTO;
+    // The pre-link pipelines don't support O0 and require using
+    // buildO0DefaultPipeline() instead. At the same time, the LTO pipelines do
+    // support O0 and using them is required.
+    bool IsLTO = OptStage == LLVMRustOptStage::ThinLTO ||
+                 OptStage == LLVMRustOptStage::FatLTO;
     if (OptLevel == OptimizationLevel::O0 && !IsLTO) {
       for (const auto &C : PipelineStartEPCallbacks)
         PB.registerPipelineStartEPCallback(C);
@@ -993,7 +979,8 @@ LLVMRustOptimize(
   }
 
   if (ExtraPassesLen) {
-    if (auto Err = PB.parsePassPipeline(MPM, StringRef(ExtraPasses, ExtraPassesLen))) {
+    if (auto Err =
+            PB.parsePassPipeline(MPM, StringRef(ExtraPasses, ExtraPassesLen))) {
       std::string ErrMsg = toString(std::move(Err));
       LLVMRustSetLastError(ErrMsg.c_str());
       return LLVMRustResult::Failure;
@@ -1020,8 +1007,7 @@ LLVMRustOptimize(
 // * output buffer
 // * output buffer len
 // Returns len of demangled string, or 0 if demangle failed.
-typedef size_t (*DemangleFn)(const char*, size_t, char*, size_t);
-
+typedef size_t (*DemangleFn)(const char *, size_t, char *, size_t);
 
 namespace {
 
@@ -1064,7 +1050,7 @@ public:
                          formatted_raw_ostream &OS) override {
     StringRef Demangled = CallDemangle(F->getName());
     if (Demangled.empty()) {
-        return;
+      return;
     }
 
     OS << "; " << Demangled << "\n";
@@ -1077,7 +1063,7 @@ public:
     if (const CallInst *CI = dyn_cast<CallInst>(I)) {
       Name = "call";
       Value = CI->getCalledOperand();
-    } else if (const InvokeInst* II = dyn_cast<InvokeInst>(I)) {
+    } else if (const InvokeInst *II = dyn_cast<InvokeInst>(I)) {
       Name = "invoke";
       Value = II->getCalledOperand();
     } else {
@@ -1101,8 +1087,8 @@ public:
 
 } // namespace
 
-extern "C" LLVMRustResult
-LLVMRustPrintModule(LLVMModuleRef M, const char *Path, DemangleFn Demangle) {
+extern "C" LLVMRustResult LLVMRustPrintModule(LLVMModuleRef M, const char *Path,
+                                              DemangleFn Demangle) {
   std::string ErrorInfo;
   std::error_code EC;
   auto OS = raw_fd_ostream(Path, EC, sys::fs::OF_None);
@@ -1264,11 +1250,9 @@ getFirstDefinitionForLinker(const GlobalValueSummaryList &GVSummaryList) {
 // The main entry point for creating the global ThinLTO analysis. The structure
 // here is basically the same as before threads are spawned in the `run`
 // function of `lib/LTO/ThinLTOCodeGenerator.cpp`.
-extern "C" LLVMRustThinLTOData*
-LLVMRustCreateThinLTOData(LLVMRustThinLTOModule *modules,
-                          int num_modules,
-                          const char **preserved_symbols,
-                          int num_symbols) {
+extern "C" LLVMRustThinLTOData *
+LLVMRustCreateThinLTOData(LLVMRustThinLTOModule *modules, int num_modules,
+                          const char **preserved_symbols, int num_symbols) {
   auto Ret = std::make_unique<LLVMRustThinLTOData>();
 
   // Load each module's summary and merge it into one combined index
@@ -1290,7 +1274,8 @@ LLVMRustCreateThinLTOData(LLVMRustThinLTOModule *modules,
   }
 
   // Collect for each module the list of function it defines (GUID -> Summary)
-  Ret->Index.collectDefinedGVSummariesPerModule(Ret->ModuleToDefinedGVSummaries);
+  Ret->Index.collectDefinedGVSummariesPerModule(
+      Ret->ModuleToDefinedGVSummaries);
 
   // Convert the preserved symbols set from string to GUID, this is then needed
   // for internalization.
@@ -1310,7 +1295,8 @@ LLVMRustCreateThinLTOData(LLVMRustThinLTOModule *modules,
   // crate, so we need `ImportEnabled = false` to limit internalization.
   // Otherwise, we sometimes lose `static` values -- see #60184.
   computeDeadSymbolsWithConstProp(Ret->Index, Ret->GUIDPreservedSymbols,
-                                  deadIsPrevailing, /* ImportEnabled = */ false);
+                                  deadIsPrevailing,
+                                  /* ImportEnabled = */ false);
   // Resolve LinkOnce/Weak symbols, this has to be computed early be cause it
   // impacts the caching.
   //
@@ -1319,7 +1305,8 @@ LLVMRustCreateThinLTOData(LLVMRustThinLTOModule *modules,
   DenseMap<GlobalValue::GUID, const GlobalValueSummary *> PrevailingCopy;
   for (auto &I : Ret->Index) {
     if (I.second.SummaryList.size() > 1)
-      PrevailingCopy[I.first] = getFirstDefinitionForLinker(I.second.SummaryList);
+      PrevailingCopy[I.first] =
+          getFirstDefinitionForLinker(I.second.SummaryList);
   }
   auto isPrevailing = [&](GlobalValue::GUID GUID, const GlobalValueSummary *S) {
     const auto &Prevailing = PrevailingCopy.find(GUID);
@@ -1327,13 +1314,8 @@ LLVMRustCreateThinLTOData(LLVMRustThinLTOModule *modules,
       return true;
     return Prevailing->second == S;
   };
-  ComputeCrossModuleImport(
-    Ret->Index,
-    Ret->ModuleToDefinedGVSummaries,
-    isPrevailing,
-    Ret->ImportLists,
-    Ret->ExportLists
-  );
+  ComputeCrossModuleImport(Ret->Index, Ret->ModuleToDefinedGVSummaries,
+                           isPrevailing, Ret->ImportLists, Ret->ExportLists);
 
   auto recordNewLinkage = [&](StringRef ModuleIdentifier,
                               GlobalValue::GUID GUID,
@@ -1345,8 +1327,8 @@ LLVMRustCreateThinLTOData(LLVMRustThinLTOModule *modules,
   // formats. We probably could and should use ELF visibility scheme for many of
   // our targets, however.
   lto::Config conf;
-  thinLTOResolvePrevailingInIndex(conf, Ret->Index, isPrevailing, recordNewLinkage,
-                                  Ret->GUIDPreservedSymbols);
+  thinLTOResolvePrevailingInIndex(conf, Ret->Index, isPrevailing,
+                                  recordNewLinkage, Ret->GUIDPreservedSymbols);
 
   // Here we calculate an `ExportedGUIDs` set for use in the `isExported`
   // callback below. This callback below will dictate the linkage for all
@@ -1355,7 +1337,7 @@ LLVMRustCreateThinLTOData(LLVMRustThinLTOModule *modules,
   // linkage will stay as external, and internal will stay as internal.
   std::set<GlobalValue::GUID> ExportedGUIDs;
   for (auto &List : Ret->Index) {
-    for (auto &GVS: List.second.SummaryList) {
+    for (auto &GVS : List.second.SummaryList) {
       if (GlobalValue::isLocalLinkage(GVS->linkage()))
         continue;
       auto GUID = GVS->getOriginalName();
@@ -1366,16 +1348,15 @@ LLVMRustCreateThinLTOData(LLVMRustThinLTOModule *modules,
   auto isExported = [&](StringRef ModuleIdentifier, ValueInfo VI) {
     const auto &ExportList = Ret->ExportLists.find(ModuleIdentifier);
     return (ExportList != Ret->ExportLists.end() &&
-      ExportList->second.count(VI)) ||
-      ExportedGUIDs.count(VI.getGUID());
+            ExportList->second.count(VI)) ||
+           ExportedGUIDs.count(VI.getGUID());
   };
   thinLTOInternalizeAndPromoteInIndex(Ret->Index, isExported, isPrevailing);
 
   return Ret.release();
 }
 
-extern "C" void
-LLVMRustFreeThinLTOData(LLVMRustThinLTOData *Data) {
+extern "C" void LLVMRustFreeThinLTOData(LLVMRustThinLTOData *Data) {
   delete Data;
 }
 
@@ -1387,20 +1368,18 @@ LLVMRustFreeThinLTOData(LLVMRustThinLTOData *Data) {
 // `ProcessThinLTOModule` function. Here they're split up into separate steps
 // so rustc can save off the intermediate bytecode between each step.
 
-static bool
-clearDSOLocalOnDeclarations(Module &Mod, TargetMachine &TM) {
+static bool clearDSOLocalOnDeclarations(Module &Mod, TargetMachine &TM) {
   // When linking an ELF shared object, dso_local should be dropped. We
   // conservatively do this for -fpic.
-  bool ClearDSOLocalOnDeclarations =
-      TM.getTargetTriple().isOSBinFormatELF() &&
-      TM.getRelocationModel() != Reloc::Static &&
-      Mod.getPIELevel() == PIELevel::Default;
+  bool ClearDSOLocalOnDeclarations = TM.getTargetTriple().isOSBinFormatELF() &&
+                                     TM.getRelocationModel() != Reloc::Static &&
+                                     Mod.getPIELevel() == PIELevel::Default;
   return ClearDSOLocalOnDeclarations;
 }
 
-extern "C" bool
-LLVMRustPrepareThinLTORename(const LLVMRustThinLTOData *Data, LLVMModuleRef M,
-                             LLVMTargetMachineRef TM) {
+extern "C" bool LLVMRustPrepareThinLTORename(const LLVMRustThinLTOData *Data,
+                                             LLVMModuleRef M,
+                                             LLVMTargetMachineRef TM) {
   Module &Mod = *unwrap(M);
   TargetMachine &Target = *unwrap(TM);
 
@@ -1415,24 +1394,28 @@ LLVMRustPrepareThinLTORename(const LLVMRustThinLTOData *Data, LLVMModuleRef M,
 }
 
 extern "C" bool
-LLVMRustPrepareThinLTOResolveWeak(const LLVMRustThinLTOData *Data, LLVMModuleRef M) {
+LLVMRustPrepareThinLTOResolveWeak(const LLVMRustThinLTOData *Data,
+                                  LLVMModuleRef M) {
   Module &Mod = *unwrap(M);
-  const auto &DefinedGlobals = Data->ModuleToDefinedGVSummaries.lookup(Mod.getModuleIdentifier());
+  const auto &DefinedGlobals =
+      Data->ModuleToDefinedGVSummaries.lookup(Mod.getModuleIdentifier());
   thinLTOFinalizeInModule(Mod, DefinedGlobals, /*PropagateAttrs=*/true);
   return true;
 }
 
 extern "C" bool
-LLVMRustPrepareThinLTOInternalize(const LLVMRustThinLTOData *Data, LLVMModuleRef M) {
+LLVMRustPrepareThinLTOInternalize(const LLVMRustThinLTOData *Data,
+                                  LLVMModuleRef M) {
   Module &Mod = *unwrap(M);
-  const auto &DefinedGlobals = Data->ModuleToDefinedGVSummaries.lookup(Mod.getModuleIdentifier());
+  const auto &DefinedGlobals =
+      Data->ModuleToDefinedGVSummaries.lookup(Mod.getModuleIdentifier());
   thinLTOInternalizeModule(Mod, DefinedGlobals);
   return true;
 }
 
-extern "C" bool
-LLVMRustPrepareThinLTOImport(const LLVMRustThinLTOData *Data, LLVMModuleRef M,
-                             LLVMTargetMachineRef TM) {
+extern "C" bool LLVMRustPrepareThinLTOImport(const LLVMRustThinLTOData *Data,
+                                             LLVMModuleRef M,
+                                             LLVMTargetMachineRef TM) {
   Module &Mod = *unwrap(M);
   TargetMachine &Target = *unwrap(TM);
 
@@ -1464,7 +1447,8 @@ LLVMRustPrepareThinLTOImport(const LLVMRustThinLTOData *Data, LLVMModuleRef M,
       return Ret;
     }
 
-    auto *WasmCustomSections = (*MOrErr)->getNamedMetadata("wasm.custom_sections");
+    auto *WasmCustomSections =
+        (*MOrErr)->getNamedMetadata("wasm.custom_sections");
     if (WasmCustomSections)
       WasmCustomSections->eraseFromParent();
 
@@ -1498,7 +1482,7 @@ struct LLVMRustThinLTOBuffer {
   std::string thin_link_data;
 };
 
-extern "C" LLVMRustThinLTOBuffer*
+extern "C" LLVMRustThinLTOBuffer *
 LLVMRustThinLTOBufferCreate(LLVMModuleRef M, bool is_thin, bool emit_summary) {
   auto Ret = std::make_unique<LLVMRustThinLTOBuffer>();
   {
@@ -1520,7 +1504,8 @@ LLVMRustThinLTOBufferCreate(LLVMModuleRef M, bool is_thin, bool emit_summary) {
         // We only pass ThinLinkOS to be filled in if we want the summary,
         // because otherwise LLVM does extra work and may double-emit some
         // errors or warnings.
-        MPM.addPass(ThinLTOBitcodeWriterPass(OS, emit_summary ? &ThinLinkOS : nullptr));
+        MPM.addPass(
+            ThinLTOBitcodeWriterPass(OS, emit_summary ? &ThinLinkOS : nullptr));
         MPM.run(*unwrap(M), MAM);
       } else {
         WriteBitcodeToFile(*unwrap(M), OS);
@@ -1530,12 +1515,11 @@ LLVMRustThinLTOBufferCreate(LLVMModuleRef M, bool is_thin, bool emit_summary) {
   return Ret.release();
 }
 
-extern "C" void
-LLVMRustThinLTOBufferFree(LLVMRustThinLTOBuffer *Buffer) {
+extern "C" void LLVMRustThinLTOBufferFree(LLVMRustThinLTOBuffer *Buffer) {
   delete Buffer;
 }
 
-extern "C" const void*
+extern "C" const void *
 LLVMRustThinLTOBufferPtr(const LLVMRustThinLTOBuffer *Buffer) {
   return Buffer->data.data();
 }
@@ -1545,7 +1529,7 @@ LLVMRustThinLTOBufferLen(const LLVMRustThinLTOBuffer *Buffer) {
   return Buffer->data.length();
 }
 
-extern "C" const void*
+extern "C" const void *
 LLVMRustThinLTOBufferThinLinkDataPtr(const LLVMRustThinLTOBuffer *Buffer) {
   return Buffer->thin_link_data.data();
 }
@@ -1558,11 +1542,10 @@ LLVMRustThinLTOBufferThinLinkDataLen(const LLVMRustThinLTOBuffer *Buffer) {
 // This is what we used to parse upstream bitcode for actual ThinLTO
 // processing. We'll call this once per module optimized through ThinLTO, and
 // it'll be called concurrently on many threads.
-extern "C" LLVMModuleRef
-LLVMRustParseBitcodeForLTO(LLVMContextRef Context,
-                           const char *data,
-                           size_t len,
-                           const char *identifier) {
+extern "C" LLVMModuleRef LLVMRustParseBitcodeForLTO(LLVMContextRef Context,
+                                                    const char *data,
+                                                    size_t len,
+                                                    const char *identifier) {
   auto Data = StringRef(data, len);
   auto Buffer = MemoryBufferRef(Data, identifier);
   unwrap(Context)->enableDebugTypeODRUniquing();
@@ -1614,8 +1597,9 @@ extern "C" const char *LLVMRustGetSliceFromObjectDataByName(const char *data,
 // of access globals, etc).
 // The precise details are determined by LLVM in `computeLTOCacheKey`, which is
 // used during the normal linker-plugin incremental thin-LTO process.
-extern "C" void
-LLVMRustComputeLTOCacheKey(RustStringRef KeyOut, const char *ModId, LLVMRustThinLTOData *Data) {
+extern "C" void LLVMRustComputeLTOCacheKey(RustStringRef KeyOut,
+                                           const char *ModId,
+                                           LLVMRustThinLTOData *Data) {
   SmallString<40> Key;
   llvm::lto::Config conf;
   const auto &ImportList = Data->ImportLists.lookup(ModId);
@@ -1633,9 +1617,9 @@ LLVMRustComputeLTOCacheKey(RustStringRef KeyOut, const char *ModId, LLVMRustThin
     CfiFunctionDecls.insert(
         GlobalValue::getGUID(GlobalValue::dropLLVMManglingEscape(Name)));
 
-  llvm::computeLTOCacheKey(Key, conf, Data->Index, ModId,
-      ImportList, ExportList, ResolvedODR, DefinedGlobals, CfiFunctionDefs, CfiFunctionDecls
-  );
+  llvm::computeLTOCacheKey(Key, conf, Data->Index, ModId, ImportList,
+                           ExportList, ResolvedODR, DefinedGlobals,
+                           CfiFunctionDefs, CfiFunctionDecls);
 
   LLVMRustStringWriteImpl(KeyOut, Key.c_str(), Key.size());
 }
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index 20167a4b45e..b6790b7df50 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -1,5 +1,6 @@
 #include "LLVMWrapper.h"
 #include "llvm/ADT/Statistic.h"
+#include "llvm/Bitcode/BitcodeWriter.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DiagnosticHandler.h"
 #include "llvm/IR/DiagnosticInfo.h"
@@ -11,17 +12,16 @@
 #include "llvm/IR/LLVMRemarkStreamer.h"
 #include "llvm/IR/Mangler.h"
 #include "llvm/IR/Value.h"
-#include "llvm/Remarks/RemarkStreamer.h"
-#include "llvm/Remarks/RemarkSerializer.h"
-#include "llvm/Remarks/RemarkFormat.h"
-#include "llvm/Support/ToolOutputFile.h"
-#include "llvm/Support/ModRef.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFFImportFile.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Pass.h"
-#include "llvm/Bitcode/BitcodeWriter.h"
+#include "llvm/Remarks/RemarkFormat.h"
+#include "llvm/Remarks/RemarkSerializer.h"
+#include "llvm/Remarks/RemarkStreamer.h"
+#include "llvm/Support/ModRef.h"
 #include "llvm/Support/Signals.h"
+#include "llvm/Support/ToolOutputFile.h"
 
 #include <iostream>
 
@@ -71,12 +71,12 @@ static LLVM_THREAD_LOCAL char *LastError;
 // Custom error handler for fatal LLVM errors.
 //
 // Notably it exits the process with code 101, unlike LLVM's default of 1.
-static void FatalErrorHandler(void *UserData,
-                              const char* Reason,
+static void FatalErrorHandler(void *UserData, const char *Reason,
                               bool GenCrashDiag) {
   // Once upon a time we emitted "LLVM ERROR:" specifically to mimic LLVM. Then,
-  // we developed crater and other tools which only expose logs, not error codes.
-  // Use a more greppable prefix that will still match the "LLVM ERROR:" prefix.
+  // we developed crater and other tools which only expose logs, not error
+  // codes. Use a more greppable prefix that will still match the "LLVM ERROR:"
+  // prefix.
   std::cerr << "rustc-LLVM ERROR: " << Reason << std::endl;
 
   // Since this error handler exits the process, we have to run any cleanup that
@@ -99,8 +99,7 @@ static void FatalErrorHandler(void *UserData,
 //
 // It aborts the process without any further allocations, similar to LLVM's
 // default except that may be configured to `throw std::bad_alloc()` instead.
-static void BadAllocErrorHandler(void *UserData,
-                                 const char* Reason,
+static void BadAllocErrorHandler(void *UserData, const char *Reason,
                                  bool GenCrashDiag) {
   const char *OOM = "rustc-LLVM ERROR: out of memory\n";
   (void)!::write(2, OOM, strlen(OOM));
@@ -190,7 +189,8 @@ static CallInst::TailCallKind fromRust(LLVMRustTailCallKind Kind) {
   }
 }
 
-extern "C" void LLVMRustSetTailCallKind(LLVMValueRef Call, LLVMRustTailCallKind TCK) {
+extern "C" void LLVMRustSetTailCallKind(LLVMValueRef Call,
+                                        LLVMRustTailCallKind TCK) {
   unwrap<CallInst>(Call)->setTailCallKind(fromRust(TCK));
 }
 
@@ -201,12 +201,13 @@ extern "C" LLVMValueRef LLVMRustGetOrInsertFunction(LLVMModuleRef M,
   return wrap(unwrap(M)
                   ->getOrInsertFunction(StringRef(Name, NameLen),
                                         unwrap<FunctionType>(FunctionTy))
-                  .getCallee()
-  );
+                  .getCallee());
 }
 
-extern "C" LLVMValueRef
-LLVMRustGetOrInsertGlobal(LLVMModuleRef M, const char *Name, size_t NameLen, LLVMTypeRef Ty) {
+extern "C" LLVMValueRef LLVMRustGetOrInsertGlobal(LLVMModuleRef M,
+                                                  const char *Name,
+                                                  size_t NameLen,
+                                                  LLVMTypeRef Ty) {
   Module *Mod = unwrap(M);
   auto NameRef = StringRef(Name, NameLen);
 
@@ -221,13 +222,10 @@ LLVMRustGetOrInsertGlobal(LLVMModuleRef M, const char *Name, size_t NameLen, LLV
   return wrap(GV);
 }
 
-extern "C" LLVMValueRef
-LLVMRustInsertPrivateGlobal(LLVMModuleRef M, LLVMTypeRef Ty) {
-  return wrap(new GlobalVariable(*unwrap(M),
-                                 unwrap(Ty),
-                                 false,
-                                 GlobalValue::PrivateLinkage,
-                                 nullptr));
+extern "C" LLVMValueRef LLVMRustInsertPrivateGlobal(LLVMModuleRef M,
+                                                    LLVMTypeRef Ty) {
+  return wrap(new GlobalVariable(*unwrap(M), unwrap(Ty), false,
+                                 GlobalValue::PrivateLinkage, nullptr));
 }
 
 static Attribute::AttrKind fromRust(LLVMRustAttribute Kind) {
@@ -326,8 +324,9 @@ static Attribute::AttrKind fromRust(LLVMRustAttribute Kind) {
   report_fatal_error("bad AttributeKind");
 }
 
-template<typename T> static inline void AddAttributes(T *t, unsigned Index,
-                                                      LLVMAttributeRef *Attrs, size_t AttrsLen) {
+template <typename T>
+static inline void AddAttributes(T *t, unsigned Index, LLVMAttributeRef *Attrs,
+                                 size_t AttrsLen) {
   AttributeList PAL = t->getAttributes();
   auto B = AttrBuilder(t->getContext());
   for (LLVMAttributeRef Attr : ArrayRef<LLVMAttributeRef>(Attrs, AttrsLen))
@@ -337,19 +336,22 @@ template<typename T> static inline void AddAttributes(T *t, unsigned Index,
 }
 
 extern "C" void LLVMRustAddFunctionAttributes(LLVMValueRef Fn, unsigned Index,
-                                              LLVMAttributeRef *Attrs, size_t AttrsLen) {
+                                              LLVMAttributeRef *Attrs,
+                                              size_t AttrsLen) {
   Function *F = unwrap<Function>(Fn);
   AddAttributes(F, Index, Attrs, AttrsLen);
 }
 
-extern "C" void LLVMRustAddCallSiteAttributes(LLVMValueRef Instr, unsigned Index,
-                                              LLVMAttributeRef *Attrs, size_t AttrsLen) {
+extern "C" void LLVMRustAddCallSiteAttributes(LLVMValueRef Instr,
+                                              unsigned Index,
+                                              LLVMAttributeRef *Attrs,
+                                              size_t AttrsLen) {
   CallBase *Call = unwrap<CallBase>(Instr);
   AddAttributes(Call, Index, Attrs, AttrsLen);
 }
 
-extern "C" LLVMAttributeRef LLVMRustCreateAttrNoValue(LLVMContextRef C,
-                                                      LLVMRustAttribute RustAttr) {
+extern "C" LLVMAttributeRef
+LLVMRustCreateAttrNoValue(LLVMContextRef C, LLVMRustAttribute RustAttr) {
   return wrap(Attribute::get(*unwrap(C), fromRust(RustAttr)));
 }
 
@@ -363,30 +365,36 @@ extern "C" LLVMAttributeRef LLVMRustCreateDereferenceableAttr(LLVMContextRef C,
   return wrap(Attribute::getWithDereferenceableBytes(*unwrap(C), Bytes));
 }
 
-extern "C" LLVMAttributeRef LLVMRustCreateDereferenceableOrNullAttr(LLVMContextRef C,
-                                                                    uint64_t Bytes) {
+extern "C" LLVMAttributeRef
+LLVMRustCreateDereferenceableOrNullAttr(LLVMContextRef C, uint64_t Bytes) {
   return wrap(Attribute::getWithDereferenceableOrNullBytes(*unwrap(C), Bytes));
 }
 
-extern "C" LLVMAttributeRef LLVMRustCreateByValAttr(LLVMContextRef C, LLVMTypeRef Ty) {
+extern "C" LLVMAttributeRef LLVMRustCreateByValAttr(LLVMContextRef C,
+                                                    LLVMTypeRef Ty) {
   return wrap(Attribute::getWithByValType(*unwrap(C), unwrap(Ty)));
 }
 
-extern "C" LLVMAttributeRef LLVMRustCreateStructRetAttr(LLVMContextRef C, LLVMTypeRef Ty) {
+extern "C" LLVMAttributeRef LLVMRustCreateStructRetAttr(LLVMContextRef C,
+                                                        LLVMTypeRef Ty) {
   return wrap(Attribute::getWithStructRetType(*unwrap(C), unwrap(Ty)));
 }
 
-extern "C" LLVMAttributeRef LLVMRustCreateElementTypeAttr(LLVMContextRef C, LLVMTypeRef Ty) {
+extern "C" LLVMAttributeRef LLVMRustCreateElementTypeAttr(LLVMContextRef C,
+                                                          LLVMTypeRef Ty) {
   return wrap(Attribute::get(*unwrap(C), Attribute::ElementType, unwrap(Ty)));
 }
 
-extern "C" LLVMAttributeRef LLVMRustCreateUWTableAttr(LLVMContextRef C, bool Async) {
+extern "C" LLVMAttributeRef LLVMRustCreateUWTableAttr(LLVMContextRef C,
+                                                      bool Async) {
   return wrap(Attribute::getWithUWTableKind(
       *unwrap(C), Async ? UWTableKind::Async : UWTableKind::Sync));
 }
 
-extern "C" LLVMAttributeRef LLVMRustCreateAllocSizeAttr(LLVMContextRef C, uint32_t ElementSizeArg) {
-  return wrap(Attribute::getWithAllocSizeArgs(*unwrap(C), ElementSizeArg, std::nullopt));
+extern "C" LLVMAttributeRef
+LLVMRustCreateAllocSizeAttr(LLVMContextRef C, uint32_t ElementSizeArg) {
+  return wrap(Attribute::getWithAllocSizeArgs(*unwrap(C), ElementSizeArg,
+                                              std::nullopt));
 }
 
 // These values **must** match ffi::AllocKindFlags.
@@ -403,12 +411,15 @@ enum class LLVMRustAllocKindFlags : uint64_t {
   Aligned = 1 << 5,
 };
 
-static LLVMRustAllocKindFlags operator&(LLVMRustAllocKindFlags A, LLVMRustAllocKindFlags B) {
+static LLVMRustAllocKindFlags operator&(LLVMRustAllocKindFlags A,
+                                        LLVMRustAllocKindFlags B) {
   return static_cast<LLVMRustAllocKindFlags>(static_cast<uint64_t>(A) &
-                                      static_cast<uint64_t>(B));
+                                             static_cast<uint64_t>(B));
 }
 
-static bool isSet(LLVMRustAllocKindFlags F) { return F != LLVMRustAllocKindFlags::Unknown; }
+static bool isSet(LLVMRustAllocKindFlags F) {
+  return F != LLVMRustAllocKindFlags::Unknown;
+}
 
 static llvm::AllocFnKind allocKindFromRust(LLVMRustAllocKindFlags F) {
   llvm::AllocFnKind AFK = llvm::AllocFnKind::Unknown;
@@ -433,40 +444,47 @@ static llvm::AllocFnKind allocKindFromRust(LLVMRustAllocKindFlags F) {
   return AFK;
 }
 
-extern "C" LLVMAttributeRef LLVMRustCreateAllocKindAttr(LLVMContextRef C, uint64_t AllocKindArg) {
-  return wrap(Attribute::get(*unwrap(C), Attribute::AllocKind,
-      static_cast<uint64_t>(allocKindFromRust(static_cast<LLVMRustAllocKindFlags>(AllocKindArg)))));
+extern "C" LLVMAttributeRef LLVMRustCreateAllocKindAttr(LLVMContextRef C,
+                                                        uint64_t AllocKindArg) {
+  return wrap(
+      Attribute::get(*unwrap(C), Attribute::AllocKind,
+                     static_cast<uint64_t>(allocKindFromRust(
+                         static_cast<LLVMRustAllocKindFlags>(AllocKindArg)))));
 }
 
 // Simplified representation of `MemoryEffects` across the FFI boundary.
 //
-// Each variant corresponds to one of the static factory methods on `MemoryEffects`.
+// Each variant corresponds to one of the static factory methods on
+// `MemoryEffects`.
 enum class LLVMRustMemoryEffects {
   None,
   ReadOnly,
   InaccessibleMemOnly,
 };
 
-extern "C" LLVMAttributeRef LLVMRustCreateMemoryEffectsAttr(LLVMContextRef C,
-                                                            LLVMRustMemoryEffects Effects) {
+extern "C" LLVMAttributeRef
+LLVMRustCreateMemoryEffectsAttr(LLVMContextRef C,
+                                LLVMRustMemoryEffects Effects) {
   switch (Effects) {
-    case LLVMRustMemoryEffects::None:
-      return wrap(Attribute::getWithMemoryEffects(*unwrap(C), MemoryEffects::none()));
-    case LLVMRustMemoryEffects::ReadOnly:
-      return wrap(Attribute::getWithMemoryEffects(*unwrap(C), MemoryEffects::readOnly()));
-    case LLVMRustMemoryEffects::InaccessibleMemOnly:
-      return wrap(Attribute::getWithMemoryEffects(*unwrap(C),
-                                                  MemoryEffects::inaccessibleMemOnly()));
-    default:
-      report_fatal_error("bad MemoryEffects.");
+  case LLVMRustMemoryEffects::None:
+    return wrap(
+        Attribute::getWithMemoryEffects(*unwrap(C), MemoryEffects::none()));
+  case LLVMRustMemoryEffects::ReadOnly:
+    return wrap(
+        Attribute::getWithMemoryEffects(*unwrap(C), MemoryEffects::readOnly()));
+  case LLVMRustMemoryEffects::InaccessibleMemOnly:
+    return wrap(Attribute::getWithMemoryEffects(
+        *unwrap(C), MemoryEffects::inaccessibleMemOnly()));
+  default:
+    report_fatal_error("bad MemoryEffects.");
   }
 }
 
-// Enable all fast-math flags, including those which will cause floating-point operations
-// to return poison for some well-defined inputs. This function can only be used to build
-// unsafe Rust intrinsics. That unsafety does permit additional optimizations, but at the
-// time of writing, their value is not well-understood relative to those enabled by
-// LLVMRustSetAlgebraicMath.
+// Enable all fast-math flags, including those which will cause floating-point
+// operations to return poison for some well-defined inputs. This function can
+// only be used to build unsafe Rust intrinsics. That unsafety does permit
+// additional optimizations, but at the time of writing, their value is not
+// well-understood relative to those enabled by LLVMRustSetAlgebraicMath.
 //
 // https://llvm.org/docs/LangRef.html#fast-math-flags
 extern "C" void LLVMRustSetFastMath(LLVMValueRef V) {
@@ -475,14 +493,12 @@ extern "C" void LLVMRustSetFastMath(LLVMValueRef V) {
   }
 }
 
-// Enable fast-math flags which permit algebraic transformations that are not allowed by
-// IEEE floating point. For example:
-// a + (b + c) = (a + b) + c
-// and
-// a / b = a * (1 / b)
-// Note that this does NOT enable any flags which can cause a floating-point operation on
-// well-defined inputs to return poison, and therefore this function can be used to build
-// safe Rust intrinsics (such as fadd_algebraic).
+// Enable fast-math flags which permit algebraic transformations that are not
+// allowed by IEEE floating point. For example: a + (b + c) = (a + b) + c and a
+// / b = a * (1 / b) Note that this does NOT enable any flags which can cause a
+// floating-point operation on well-defined inputs to return poison, and
+// therefore this function can be used to build safe Rust intrinsics (such as
+// fadd_algebraic).
 //
 // https://llvm.org/docs/LangRef.html#fast-math-flags
 extern "C" void LLVMRustSetAlgebraicMath(LLVMValueRef V) {
@@ -497,9 +513,9 @@ extern "C" void LLVMRustSetAlgebraicMath(LLVMValueRef V) {
 // Enable the reassoc fast-math flag, allowing transformations that pretend
 // floating-point addition and multiplication are associative.
 //
-// Note that this does NOT enable any flags which can cause a floating-point operation on
-// well-defined inputs to return poison, and therefore this function can be used to build
-// safe Rust intrinsics (such as fadd_algebraic).
+// Note that this does NOT enable any flags which can cause a floating-point
+// operation on well-defined inputs to return poison, and therefore this
+// function can be used to build safe Rust intrinsics (such as fadd_algebraic).
 //
 // https://llvm.org/docs/LangRef.html#fast-math-flags
 extern "C" void LLVMRustSetAllowReassoc(LLVMValueRef V) {
@@ -547,11 +563,10 @@ LLVMRustInlineAsm(LLVMTypeRef Ty, char *AsmString, size_t AsmStringLen,
                   char *Constraints, size_t ConstraintsLen,
                   LLVMBool HasSideEffects, LLVMBool IsAlignStack,
                   LLVMRustAsmDialect Dialect, LLVMBool CanThrow) {
-  return wrap(InlineAsm::get(unwrap<FunctionType>(Ty),
-                             StringRef(AsmString, AsmStringLen),
-                             StringRef(Constraints, ConstraintsLen),
-                             HasSideEffects, IsAlignStack,
-                             fromRust(Dialect), CanThrow));
+  return wrap(InlineAsm::get(
+      unwrap<FunctionType>(Ty), StringRef(AsmString, AsmStringLen),
+      StringRef(Constraints, ConstraintsLen), HasSideEffects, IsAlignStack,
+      fromRust(Dialect), CanThrow));
 }
 
 extern "C" bool LLVMRustInlineAsmVerify(LLVMTypeRef Ty, char *Constraints,
@@ -705,19 +720,22 @@ enum class LLVMRustDISPFlags : uint32_t {
 
 inline LLVMRustDISPFlags operator&(LLVMRustDISPFlags A, LLVMRustDISPFlags B) {
   return static_cast<LLVMRustDISPFlags>(static_cast<uint32_t>(A) &
-                                      static_cast<uint32_t>(B));
+                                        static_cast<uint32_t>(B));
 }
 
 inline LLVMRustDISPFlags operator|(LLVMRustDISPFlags A, LLVMRustDISPFlags B) {
   return static_cast<LLVMRustDISPFlags>(static_cast<uint32_t>(A) |
-                                      static_cast<uint32_t>(B));
+                                        static_cast<uint32_t>(B));
 }
 
-inline LLVMRustDISPFlags &operator|=(LLVMRustDISPFlags &A, LLVMRustDISPFlags B) {
+inline LLVMRustDISPFlags &operator|=(LLVMRustDISPFlags &A,
+                                     LLVMRustDISPFlags B) {
   return A = A | B;
 }
 
-inline bool isSet(LLVMRustDISPFlags F) { return F != LLVMRustDISPFlags::SPFlagZero; }
+inline bool isSet(LLVMRustDISPFlags F) {
+  return F != LLVMRustDISPFlags::SPFlagZero;
+}
 
 inline LLVMRustDISPFlags virtuality(LLVMRustDISPFlags F) {
   return static_cast<LLVMRustDISPFlags>(static_cast<uint32_t>(F) & 0x3);
@@ -761,7 +779,8 @@ enum class LLVMRustDebugEmissionKind {
   DebugDirectivesOnly,
 };
 
-static DICompileUnit::DebugEmissionKind fromRust(LLVMRustDebugEmissionKind Kind) {
+static DICompileUnit::DebugEmissionKind
+fromRust(LLVMRustDebugEmissionKind Kind) {
   switch (Kind) {
   case LLVMRustDebugEmissionKind::NoDebug:
     return DICompileUnit::DebugEmissionKind::NoDebug;
@@ -777,12 +796,13 @@ static DICompileUnit::DebugEmissionKind fromRust(LLVMRustDebugEmissionKind Kind)
 }
 
 enum class LLVMRustDebugNameTableKind {
-    Default,
-    GNU,
-    None,
+  Default,
+  GNU,
+  None,
 };
 
-static DICompileUnit::DebugNameTableKind fromRust(LLVMRustDebugNameTableKind Kind) {
+static DICompileUnit::DebugNameTableKind
+fromRust(LLVMRustDebugNameTableKind Kind) {
   switch (Kind) {
   case LLVMRustDebugNameTableKind::Default:
     return DICompileUnit::DebugNameTableKind::Default;
@@ -827,22 +847,18 @@ extern "C" uint32_t LLVMRustVersionMinor() { return LLVM_VERSION_MINOR; }
 
 extern "C" uint32_t LLVMRustVersionMajor() { return LLVM_VERSION_MAJOR; }
 
-extern "C" void LLVMRustAddModuleFlagU32(
-    LLVMModuleRef M,
-    Module::ModFlagBehavior MergeBehavior,
-    const char *Name,
-    uint32_t Value) {
+extern "C" void LLVMRustAddModuleFlagU32(LLVMModuleRef M,
+                                         Module::ModFlagBehavior MergeBehavior,
+                                         const char *Name, uint32_t Value) {
   unwrap(M)->addModuleFlag(MergeBehavior, Name, Value);
 }
 
 extern "C" void LLVMRustAddModuleFlagString(
-    LLVMModuleRef M,
-    Module::ModFlagBehavior MergeBehavior,
-    const char *Name,
-    const char *Value,
-    size_t ValueLen) {
-  unwrap(M)->addModuleFlag(MergeBehavior, Name,
-    MDString::get(unwrap(M)->getContext(), StringRef(Value, ValueLen)));
+    LLVMModuleRef M, Module::ModFlagBehavior MergeBehavior, const char *Name,
+    const char *Value, size_t ValueLen) {
+  unwrap(M)->addModuleFlag(
+      MergeBehavior, Name,
+      MDString::get(unwrap(M)->getContext(), StringRef(Value, ValueLen)));
 }
 
 extern "C" bool LLVMRustHasModuleFlag(LLVMModuleRef M, const char *Name,
@@ -850,8 +866,8 @@ extern "C" bool LLVMRustHasModuleFlag(LLVMModuleRef M, const char *Name,
   return unwrap(M)->getModuleFlag(StringRef(Name, Len)) != nullptr;
 }
 
-extern "C" void LLVMRustGlobalAddMetadata(
-    LLVMValueRef Global, unsigned Kind, LLVMMetadataRef MD) {
+extern "C" void LLVMRustGlobalAddMetadata(LLVMValueRef Global, unsigned Kind,
+                                          LLVMMetadataRef MD) {
   unwrap<GlobalObject>(Global)->addMetadata(Kind, *unwrap<MDNode>(MD));
 }
 
@@ -870,33 +886,29 @@ extern "C" void LLVMRustDIBuilderFinalize(LLVMRustDIBuilderRef Builder) {
 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateCompileUnit(
     LLVMRustDIBuilderRef Builder, unsigned Lang, LLVMMetadataRef FileRef,
     const char *Producer, size_t ProducerLen, bool isOptimized,
-    const char *Flags, unsigned RuntimeVer,
-    const char *SplitName, size_t SplitNameLen,
-    LLVMRustDebugEmissionKind Kind,
-    uint64_t DWOId, bool SplitDebugInlining,
-    LLVMRustDebugNameTableKind TableKind) {
+    const char *Flags, unsigned RuntimeVer, const char *SplitName,
+    size_t SplitNameLen, LLVMRustDebugEmissionKind Kind, uint64_t DWOId,
+    bool SplitDebugInlining, LLVMRustDebugNameTableKind TableKind) {
   auto *File = unwrapDI<DIFile>(FileRef);
 
-  return wrap(Builder->createCompileUnit(Lang, File, StringRef(Producer, ProducerLen),
-                                         isOptimized, Flags, RuntimeVer,
-                                         StringRef(SplitName, SplitNameLen),
-                                         fromRust(Kind), DWOId, SplitDebugInlining,
-                                         false, fromRust(TableKind)));
+  return wrap(Builder->createCompileUnit(
+      Lang, File, StringRef(Producer, ProducerLen), isOptimized, Flags,
+      RuntimeVer, StringRef(SplitName, SplitNameLen), fromRust(Kind), DWOId,
+      SplitDebugInlining, false, fromRust(TableKind)));
 }
 
-extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateFile(
-    LLVMRustDIBuilderRef Builder,
-    const char *Filename, size_t FilenameLen,
-    const char *Directory, size_t DirectoryLen, LLVMRustChecksumKind CSKind,
-    const char *Checksum, size_t ChecksumLen) {
+extern "C" LLVMMetadataRef
+LLVMRustDIBuilderCreateFile(LLVMRustDIBuilderRef Builder, const char *Filename,
+                            size_t FilenameLen, const char *Directory,
+                            size_t DirectoryLen, LLVMRustChecksumKind CSKind,
+                            const char *Checksum, size_t ChecksumLen) {
 
   std::optional<DIFile::ChecksumKind> llvmCSKind = fromRust(CSKind);
   std::optional<DIFile::ChecksumInfo<StringRef>> CSInfo{};
   if (llvmCSKind)
     CSInfo.emplace(*llvmCSKind, StringRef{Checksum, ChecksumLen});
   return wrap(Builder->createFile(StringRef(Filename, FilenameLen),
-                                  StringRef(Directory, DirectoryLen),
-                                  CSInfo));
+                                  StringRef(Directory, DirectoryLen), CSInfo));
 }
 
 extern "C" LLVMMetadataRef
@@ -907,63 +919,59 @@ LLVMRustDIBuilderCreateSubroutineType(LLVMRustDIBuilderRef Builder,
 }
 
 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateFunction(
-    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
-    const char *Name, size_t NameLen,
-    const char *LinkageName, size_t LinkageNameLen,
-    LLVMMetadataRef File, unsigned LineNo,
-    LLVMMetadataRef Ty, unsigned ScopeLine, LLVMRustDIFlags Flags,
-    LLVMRustDISPFlags SPFlags, LLVMValueRef MaybeFn, LLVMMetadataRef TParam,
-    LLVMMetadataRef Decl) {
+    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
+    size_t NameLen, const char *LinkageName, size_t LinkageNameLen,
+    LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty,
+    unsigned ScopeLine, LLVMRustDIFlags Flags, LLVMRustDISPFlags SPFlags,
+    LLVMValueRef MaybeFn, LLVMMetadataRef TParam, LLVMMetadataRef Decl) {
   DITemplateParameterArray TParams =
       DITemplateParameterArray(unwrap<MDTuple>(TParam));
   DISubprogram::DISPFlags llvmSPFlags = fromRust(SPFlags);
   DINode::DIFlags llvmFlags = fromRust(Flags);
   DISubprogram *Sub = Builder->createFunction(
-      unwrapDI<DIScope>(Scope),
-      StringRef(Name, NameLen),
-      StringRef(LinkageName, LinkageNameLen),
-      unwrapDI<DIFile>(File), LineNo,
-      unwrapDI<DISubroutineType>(Ty), ScopeLine, llvmFlags,
-      llvmSPFlags, TParams, unwrapDIPtr<DISubprogram>(Decl));
+      unwrapDI<DIScope>(Scope), StringRef(Name, NameLen),
+      StringRef(LinkageName, LinkageNameLen), unwrapDI<DIFile>(File), LineNo,
+      unwrapDI<DISubroutineType>(Ty), ScopeLine, llvmFlags, llvmSPFlags,
+      TParams, unwrapDIPtr<DISubprogram>(Decl));
   if (MaybeFn)
     unwrap<Function>(MaybeFn)->setSubprogram(Sub);
   return wrap(Sub);
 }
 
 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateMethod(
-    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
-    const char *Name, size_t NameLen,
-    const char *LinkageName, size_t LinkageNameLen,
-    LLVMMetadataRef File, unsigned LineNo,
-    LLVMMetadataRef Ty, LLVMRustDIFlags Flags,
-    LLVMRustDISPFlags SPFlags, LLVMMetadataRef TParam) {
+    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
+    size_t NameLen, const char *LinkageName, size_t LinkageNameLen,
+    LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty,
+    LLVMRustDIFlags Flags, LLVMRustDISPFlags SPFlags, LLVMMetadataRef TParam) {
   DITemplateParameterArray TParams =
       DITemplateParameterArray(unwrap<MDTuple>(TParam));
   DISubprogram::DISPFlags llvmSPFlags = fromRust(SPFlags);
   DINode::DIFlags llvmFlags = fromRust(Flags);
   DISubprogram *Sub = Builder->createMethod(
-      unwrapDI<DIScope>(Scope),
-      StringRef(Name, NameLen),
-      StringRef(LinkageName, LinkageNameLen),
-      unwrapDI<DIFile>(File), LineNo,
-      unwrapDI<DISubroutineType>(Ty),
-      0, 0, nullptr, // VTable params aren't used
+      unwrapDI<DIScope>(Scope), StringRef(Name, NameLen),
+      StringRef(LinkageName, LinkageNameLen), unwrapDI<DIFile>(File), LineNo,
+      unwrapDI<DISubroutineType>(Ty), 0, 0,
+      nullptr, // VTable params aren't used
       llvmFlags, llvmSPFlags, TParams);
   return wrap(Sub);
 }
 
-extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateBasicType(
-    LLVMRustDIBuilderRef Builder, const char *Name, size_t NameLen,
-    uint64_t SizeInBits, unsigned Encoding) {
-  return wrap(Builder->createBasicType(StringRef(Name, NameLen), SizeInBits, Encoding));
+extern "C" LLVMMetadataRef
+LLVMRustDIBuilderCreateBasicType(LLVMRustDIBuilderRef Builder, const char *Name,
+                                 size_t NameLen, uint64_t SizeInBits,
+                                 unsigned Encoding) {
+  return wrap(
+      Builder->createBasicType(StringRef(Name, NameLen), SizeInBits, Encoding));
 }
 
-extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateTypedef(
-    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Type, const char *Name, size_t NameLen,
-    LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Scope) {
+extern "C" LLVMMetadataRef
+LLVMRustDIBuilderCreateTypedef(LLVMRustDIBuilderRef Builder,
+                               LLVMMetadataRef Type, const char *Name,
+                               size_t NameLen, LLVMMetadataRef File,
+                               unsigned LineNo, LLVMMetadataRef Scope) {
   return wrap(Builder->createTypedef(
-    unwrap<DIType>(Type), StringRef(Name, NameLen), unwrap<DIFile>(File),
-    LineNo, unwrapDIPtr<DIScope>(Scope)));
+      unwrap<DIType>(Type), StringRef(Name, NameLen), unwrap<DIFile>(File),
+      LineNo, unwrapDIPtr<DIScope>(Scope)));
 }
 
 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreatePointerType(
@@ -971,118 +979,98 @@ extern "C" LLVMMetadataRef LLVMRustDIBuilderCreatePointerType(
     uint64_t SizeInBits, uint32_t AlignInBits, unsigned AddressSpace,
     const char *Name, size_t NameLen) {
   return wrap(Builder->createPointerType(unwrapDI<DIType>(PointeeTy),
-                                         SizeInBits, AlignInBits,
-                                         AddressSpace,
+                                         SizeInBits, AlignInBits, AddressSpace,
                                          StringRef(Name, NameLen)));
 }
 
 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStructType(
-    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
-    const char *Name, size_t NameLen,
-    LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
-    uint32_t AlignInBits, LLVMRustDIFlags Flags,
-    LLVMMetadataRef DerivedFrom, LLVMMetadataRef Elements,
-    unsigned RunTimeLang, LLVMMetadataRef VTableHolder,
-    const char *UniqueId, size_t UniqueIdLen) {
+    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
+    size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
+    uint64_t SizeInBits, uint32_t AlignInBits, LLVMRustDIFlags Flags,
+    LLVMMetadataRef DerivedFrom, LLVMMetadataRef Elements, unsigned RunTimeLang,
+    LLVMMetadataRef VTableHolder, const char *UniqueId, size_t UniqueIdLen) {
   return wrap(Builder->createStructType(
       unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
-      unwrapDI<DIFile>(File), LineNumber,
-      SizeInBits, AlignInBits, fromRust(Flags), unwrapDI<DIType>(DerivedFrom),
+      unwrapDI<DIFile>(File), LineNumber, SizeInBits, AlignInBits,
+      fromRust(Flags), unwrapDI<DIType>(DerivedFrom),
       DINodeArray(unwrapDI<MDTuple>(Elements)), RunTimeLang,
       unwrapDI<DIType>(VTableHolder), StringRef(UniqueId, UniqueIdLen)));
 }
 
 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariantPart(
-    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
-    const char *Name, size_t NameLen,
-    LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
-    uint32_t AlignInBits, LLVMRustDIFlags Flags, LLVMMetadataRef Discriminator,
-    LLVMMetadataRef Elements, const char *UniqueId, size_t UniqueIdLen) {
+    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
+    size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
+    uint64_t SizeInBits, uint32_t AlignInBits, LLVMRustDIFlags Flags,
+    LLVMMetadataRef Discriminator, LLVMMetadataRef Elements,
+    const char *UniqueId, size_t UniqueIdLen) {
   return wrap(Builder->createVariantPart(
       unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
-      unwrapDI<DIFile>(File), LineNumber,
-      SizeInBits, AlignInBits, fromRust(Flags), unwrapDI<DIDerivedType>(Discriminator),
-      DINodeArray(unwrapDI<MDTuple>(Elements)), StringRef(UniqueId, UniqueIdLen)));
+      unwrapDI<DIFile>(File), LineNumber, SizeInBits, AlignInBits,
+      fromRust(Flags), unwrapDI<DIDerivedType>(Discriminator),
+      DINodeArray(unwrapDI<MDTuple>(Elements)),
+      StringRef(UniqueId, UniqueIdLen)));
 }
 
 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateMemberType(
-    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
-    const char *Name, size_t NameLen,
-    LLVMMetadataRef File, unsigned LineNo, uint64_t SizeInBits,
+    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
+    size_t NameLen, LLVMMetadataRef File, unsigned LineNo, uint64_t SizeInBits,
     uint32_t AlignInBits, uint64_t OffsetInBits, LLVMRustDIFlags Flags,
     LLVMMetadataRef Ty) {
-  return wrap(Builder->createMemberType(unwrapDI<DIDescriptor>(Scope),
-                                        StringRef(Name, NameLen),
-                                        unwrapDI<DIFile>(File), LineNo,
-                                        SizeInBits, AlignInBits, OffsetInBits,
-                                        fromRust(Flags), unwrapDI<DIType>(Ty)));
+  return wrap(Builder->createMemberType(
+      unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
+      unwrapDI<DIFile>(File), LineNo, SizeInBits, AlignInBits, OffsetInBits,
+      fromRust(Flags), unwrapDI<DIType>(Ty)));
 }
 
 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariantMemberType(
-    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
-    const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNo,
-    uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, LLVMValueRef Discriminant,
+    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
+    size_t NameLen, LLVMMetadataRef File, unsigned LineNo, uint64_t SizeInBits,
+    uint32_t AlignInBits, uint64_t OffsetInBits, LLVMValueRef Discriminant,
     LLVMRustDIFlags Flags, LLVMMetadataRef Ty) {
-  llvm::ConstantInt* D = nullptr;
+  llvm::ConstantInt *D = nullptr;
   if (Discriminant) {
     D = unwrap<llvm::ConstantInt>(Discriminant);
   }
-  return wrap(Builder->createVariantMemberType(unwrapDI<DIDescriptor>(Scope),
-                                               StringRef(Name, NameLen),
-                                               unwrapDI<DIFile>(File), LineNo,
-                                               SizeInBits, AlignInBits, OffsetInBits, D,
-                                               fromRust(Flags), unwrapDI<DIType>(Ty)));
+  return wrap(Builder->createVariantMemberType(
+      unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
+      unwrapDI<DIFile>(File), LineNo, SizeInBits, AlignInBits, OffsetInBits, D,
+      fromRust(Flags), unwrapDI<DIType>(Ty)));
 }
 
 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStaticMemberType(
-    LLVMRustDIBuilderRef Builder,
-    LLVMMetadataRef Scope,
-    const char *Name,
-    size_t NameLen,
-    LLVMMetadataRef File,
-    unsigned LineNo,
-    LLVMMetadataRef Ty,
-    LLVMRustDIFlags Flags,
-    LLVMValueRef val,
-    uint32_t AlignInBits
-) {
+    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
+    size_t NameLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty,
+    LLVMRustDIFlags Flags, LLVMValueRef val, uint32_t AlignInBits) {
   return wrap(Builder->createStaticMemberType(
-    unwrapDI<DIDescriptor>(Scope),
-    StringRef(Name, NameLen),
-    unwrapDI<DIFile>(File),
-    LineNo,
-    unwrapDI<DIType>(Ty),
-    fromRust(Flags),
-    unwrap<llvm::ConstantInt>(val),
+      unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
+      unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), fromRust(Flags),
+      unwrap<llvm::ConstantInt>(val),
 #if LLVM_VERSION_GE(18, 0)
-    llvm::dwarf::DW_TAG_member,
+      llvm::dwarf::DW_TAG_member,
 #endif
-    AlignInBits
-  ));
+      AlignInBits));
 }
 
-extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateLexicalBlock(
-    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
-    LLVMMetadataRef File, unsigned Line, unsigned Col) {
+extern "C" LLVMMetadataRef
+LLVMRustDIBuilderCreateLexicalBlock(LLVMRustDIBuilderRef Builder,
+                                    LLVMMetadataRef Scope, LLVMMetadataRef File,
+                                    unsigned Line, unsigned Col) {
   return wrap(Builder->createLexicalBlock(unwrapDI<DIDescriptor>(Scope),
                                           unwrapDI<DIFile>(File), Line, Col));
 }
 
-extern "C" LLVMMetadataRef
-LLVMRustDIBuilderCreateLexicalBlockFile(LLVMRustDIBuilderRef Builder,
-                                        LLVMMetadataRef Scope,
-                                        LLVMMetadataRef File) {
+extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateLexicalBlockFile(
+    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, LLVMMetadataRef File) {
   return wrap(Builder->createLexicalBlockFile(unwrapDI<DIDescriptor>(Scope),
                                               unwrapDI<DIFile>(File)));
 }
 
 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStaticVariable(
-    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Context,
-    const char *Name, size_t NameLen,
-    const char *LinkageName, size_t LinkageNameLen,
-    LLVMMetadataRef File, unsigned LineNo,
-    LLVMMetadataRef Ty, bool IsLocalToUnit, LLVMValueRef V,
-    LLVMMetadataRef Decl = nullptr, uint32_t AlignInBits = 0) {
+    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Context, const char *Name,
+    size_t NameLen, const char *LinkageName, size_t LinkageNameLen,
+    LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty,
+    bool IsLocalToUnit, LLVMValueRef V, LLVMMetadataRef Decl = nullptr,
+    uint32_t AlignInBits = 0) {
   llvm::GlobalVariable *InitVal = cast<llvm::GlobalVariable>(unwrap(V));
 
   llvm::DIExpression *InitExpr = nullptr;
@@ -1095,14 +1083,13 @@ extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStaticVariable(
         FPVal->getValueAPF().bitcastToAPInt().getZExtValue());
   }
 
-  llvm::DIGlobalVariableExpression *VarExpr = Builder->createGlobalVariableExpression(
-      unwrapDI<DIDescriptor>(Context), StringRef(Name, NameLen),
-      StringRef(LinkageName, LinkageNameLen),
-      unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), IsLocalToUnit,
-      /* isDefined */ true,
-      InitExpr, unwrapDIPtr<MDNode>(Decl),
-      /* templateParams */ nullptr,
-      AlignInBits);
+  llvm::DIGlobalVariableExpression *VarExpr =
+      Builder->createGlobalVariableExpression(
+          unwrapDI<DIDescriptor>(Context), StringRef(Name, NameLen),
+          StringRef(LinkageName, LinkageNameLen), unwrapDI<DIFile>(File),
+          LineNo, unwrapDI<DIType>(Ty), IsLocalToUnit,
+          /* isDefined */ true, InitExpr, unwrapDIPtr<MDNode>(Decl),
+          /* templateParams */ nullptr, AlignInBits);
 
   InitVal->setMetadata("dbg", VarExpr);
 
@@ -1111,20 +1098,19 @@ extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStaticVariable(
 
 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariable(
     LLVMRustDIBuilderRef Builder, unsigned Tag, LLVMMetadataRef Scope,
-    const char *Name, size_t NameLen,
-    LLVMMetadataRef File, unsigned LineNo,
+    const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNo,
     LLVMMetadataRef Ty, bool AlwaysPreserve, LLVMRustDIFlags Flags,
     unsigned ArgNo, uint32_t AlignInBits) {
   if (Tag == 0x100) { // DW_TAG_auto_variable
     return wrap(Builder->createAutoVariable(
         unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
-        unwrapDI<DIFile>(File), LineNo,
-        unwrapDI<DIType>(Ty), AlwaysPreserve, fromRust(Flags), AlignInBits));
+        unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), AlwaysPreserve,
+        fromRust(Flags), AlignInBits));
   } else {
     return wrap(Builder->createParameterVariable(
         unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen), ArgNo,
-        unwrapDI<DIFile>(File), LineNo,
-        unwrapDI<DIType>(Ty), AlwaysPreserve, fromRust(Flags)));
+        unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), AlwaysPreserve,
+        fromRust(Flags)));
   }
 }
 
@@ -1157,9 +1143,9 @@ extern "C" LLVMValueRef LLVMRustDIBuilderInsertDeclareAtEnd(
     LLVMBasicBlockRef InsertAtEnd) {
   auto Result = Builder->insertDeclare(
       unwrap(V), unwrap<DILocalVariable>(VarInfo),
-      Builder->createExpression(llvm::ArrayRef<uint64_t>(AddrOps, AddrOpsCount)),
-      DebugLoc(cast<MDNode>(unwrap(DL))),
-      unwrap(InsertAtEnd));
+      Builder->createExpression(
+          llvm::ArrayRef<uint64_t>(AddrOps, AddrOpsCount)),
+      DebugLoc(cast<MDNode>(unwrap(DL))), unwrap(InsertAtEnd));
 #if LLVM_VERSION_GE(19, 0)
   return wrap(Result.get<llvm::Instruction *>());
 #else
@@ -1170,21 +1156,20 @@ extern "C" LLVMValueRef LLVMRustDIBuilderInsertDeclareAtEnd(
 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateEnumerator(
     LLVMRustDIBuilderRef Builder, const char *Name, size_t NameLen,
     const uint64_t Value[2], unsigned SizeInBits, bool IsUnsigned) {
-  return wrap(Builder->createEnumerator(StringRef(Name, NameLen),
+  return wrap(Builder->createEnumerator(
+      StringRef(Name, NameLen),
       APSInt(APInt(SizeInBits, ArrayRef<uint64_t>(Value, 2)), IsUnsigned)));
 }
 
 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateEnumerationType(
-    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
-    const char *Name, size_t NameLen,
-    LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
-    uint32_t AlignInBits, LLVMMetadataRef Elements,
+    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
+    size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
+    uint64_t SizeInBits, uint32_t AlignInBits, LLVMMetadataRef Elements,
     LLVMMetadataRef ClassTy, bool IsScoped) {
   return wrap(Builder->createEnumerationType(
       unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
-      unwrapDI<DIFile>(File), LineNumber,
-      SizeInBits, AlignInBits, DINodeArray(unwrapDI<MDTuple>(Elements)),
-      unwrapDI<DIType>(ClassTy),
+      unwrapDI<DIFile>(File), LineNumber, SizeInBits, AlignInBits,
+      DINodeArray(unwrapDI<MDTuple>(Elements)), unwrapDI<DIType>(ClassTy),
 #if LLVM_VERSION_GE(18, 0)
       /* RunTimeLang */ 0,
 #endif
@@ -1192,39 +1177,38 @@ extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateEnumerationType(
 }
 
 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateUnionType(
-    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
-    const char *Name, size_t NameLen,
-    LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
-    uint32_t AlignInBits, LLVMRustDIFlags Flags, LLVMMetadataRef Elements,
-    unsigned RunTimeLang, const char *UniqueId, size_t UniqueIdLen) {
+    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
+    size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
+    uint64_t SizeInBits, uint32_t AlignInBits, LLVMRustDIFlags Flags,
+    LLVMMetadataRef Elements, unsigned RunTimeLang, const char *UniqueId,
+    size_t UniqueIdLen) {
   return wrap(Builder->createUnionType(
-      unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen), unwrapDI<DIFile>(File),
-      LineNumber, SizeInBits, AlignInBits, fromRust(Flags),
-      DINodeArray(unwrapDI<MDTuple>(Elements)), RunTimeLang,
+      unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
+      unwrapDI<DIFile>(File), LineNumber, SizeInBits, AlignInBits,
+      fromRust(Flags), DINodeArray(unwrapDI<MDTuple>(Elements)), RunTimeLang,
       StringRef(UniqueId, UniqueIdLen)));
 }
 
 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateTemplateTypeParameter(
-    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
-    const char *Name, size_t NameLen, LLVMMetadataRef Ty) {
+    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
+    size_t NameLen, LLVMMetadataRef Ty) {
   bool IsDefault = false; // FIXME: should we ever set this true?
   return wrap(Builder->createTemplateTypeParameter(
-      unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen), unwrapDI<DIType>(Ty), IsDefault));
+      unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
+      unwrapDI<DIType>(Ty), IsDefault));
 }
 
-extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateNameSpace(
-    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
-    const char *Name, size_t NameLen, bool ExportSymbols) {
+extern "C" LLVMMetadataRef
+LLVMRustDIBuilderCreateNameSpace(LLVMRustDIBuilderRef Builder,
+                                 LLVMMetadataRef Scope, const char *Name,
+                                 size_t NameLen, bool ExportSymbols) {
   return wrap(Builder->createNameSpace(
-      unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen), ExportSymbols
-  ));
+      unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen), ExportSymbols));
 }
 
-extern "C" void
-LLVMRustDICompositeTypeReplaceArrays(LLVMRustDIBuilderRef Builder,
-                                     LLVMMetadataRef CompositeTy,
-                                     LLVMMetadataRef Elements,
-                                     LLVMMetadataRef Params) {
+extern "C" void LLVMRustDICompositeTypeReplaceArrays(
+    LLVMRustDIBuilderRef Builder, LLVMMetadataRef CompositeTy,
+    LLVMMetadataRef Elements, LLVMMetadataRef Params) {
   DICompositeType *Tmp = unwrapDI<DICompositeType>(CompositeTy);
   Builder->replaceArrays(Tmp, DINodeArray(unwrap<MDTuple>(Elements)),
                          DINodeArray(unwrap<MDTuple>(Params)));
@@ -1235,9 +1219,8 @@ LLVMRustDIBuilderCreateDebugLocation(unsigned Line, unsigned Column,
                                      LLVMMetadataRef ScopeRef,
                                      LLVMMetadataRef InlinedAt) {
   MDNode *Scope = unwrapDIPtr<MDNode>(ScopeRef);
-  DILocation *Loc = DILocation::get(
-      Scope->getContext(), Line, Column, Scope,
-      unwrapDIPtr<MDNode>(InlinedAt));
+  DILocation *Loc = DILocation::get(Scope->getContext(), Line, Column, Scope,
+                                    unwrapDIPtr<MDNode>(InlinedAt));
   return wrap(Loc);
 }
 
@@ -1258,8 +1241,7 @@ extern "C" void LLVMRustWriteTypeToString(LLVMTypeRef Ty, RustStringRef Str) {
   unwrap<llvm::Type>(Ty)->print(OS);
 }
 
-extern "C" void LLVMRustWriteValueToString(LLVMValueRef V,
-                                           RustStringRef Str) {
+extern "C" void LLVMRustWriteValueToString(LLVMValueRef V, RustStringRef Str) {
   auto OS = RawRustStringOstream(Str);
   if (!V) {
     OS << "(null)";
@@ -1281,7 +1263,7 @@ extern "C" void LLVMRustWriteTwineToString(LLVMTwineRef T, RustStringRef Str) {
 
 extern "C" void LLVMRustUnpackOptimizationDiagnostic(
     LLVMDiagnosticInfoRef DI, RustStringRef PassNameOut,
-    LLVMValueRef *FunctionOut, unsigned* Line, unsigned* Column,
+    LLVMValueRef *FunctionOut, unsigned *Line, unsigned *Column,
     RustStringRef FilenameOut, RustStringRef MessageOut) {
   // Undefined to call this not on an optimization diagnostic!
   llvm::DiagnosticInfoOptimizationBase *Opt =
@@ -1304,17 +1286,15 @@ extern "C" void LLVMRustUnpackOptimizationDiagnostic(
 }
 
 enum class LLVMRustDiagnosticLevel {
-    Error,
-    Warning,
-    Note,
-    Remark,
+  Error,
+  Warning,
+  Note,
+  Remark,
 };
 
-extern "C" void
-LLVMRustUnpackInlineAsmDiagnostic(LLVMDiagnosticInfoRef DI,
-                                  LLVMRustDiagnosticLevel *LevelOut,
-                                  uint64_t *CookieOut,
-                                  LLVMTwineRef *MessageOut) {
+extern "C" void LLVMRustUnpackInlineAsmDiagnostic(
+    LLVMDiagnosticInfoRef DI, LLVMRustDiagnosticLevel *LevelOut,
+    uint64_t *CookieOut, LLVMTwineRef *MessageOut) {
   // Undefined to call this not on an inline assembly diagnostic!
   llvm::DiagnosticInfoInlineAsm *IA =
       static_cast<llvm::DiagnosticInfoInlineAsm *>(unwrap(DI));
@@ -1323,20 +1303,20 @@ LLVMRustUnpackInlineAsmDiagnostic(LLVMDiagnosticInfoRef DI,
   *MessageOut = wrap(&IA->getMsgStr());
 
   switch (IA->getSeverity()) {
-    case DS_Error:
-      *LevelOut = LLVMRustDiagnosticLevel::Error;
-      break;
-    case DS_Warning:
-      *LevelOut = LLVMRustDiagnosticLevel::Warning;
-      break;
-    case DS_Note:
-      *LevelOut = LLVMRustDiagnosticLevel::Note;
-      break;
-    case DS_Remark:
-      *LevelOut = LLVMRustDiagnosticLevel::Remark;
-      break;
-    default:
-      report_fatal_error("Invalid LLVMRustDiagnosticLevel value!");
+  case DS_Error:
+    *LevelOut = LLVMRustDiagnosticLevel::Error;
+    break;
+  case DS_Warning:
+    *LevelOut = LLVMRustDiagnosticLevel::Warning;
+    break;
+  case DS_Note:
+    *LevelOut = LLVMRustDiagnosticLevel::Note;
+    break;
+  case DS_Remark:
+    *LevelOut = LLVMRustDiagnosticLevel::Remark;
+    break;
+  default:
+    report_fatal_error("Invalid LLVMRustDiagnosticLevel value!");
   }
 }
 
@@ -1454,61 +1434,61 @@ extern "C" LLVMTypeKind LLVMRustGetTypeKind(LLVMTypeRef Ty) {
     return LLVMBFloatTypeKind;
   case Type::X86_AMXTyID:
     return LLVMX86_AMXTypeKind;
-  default:
-    {
-      std::string error;
-      auto stream = llvm::raw_string_ostream(error);
-      stream << "Rust does not support the TypeID: " << unwrap(Ty)->getTypeID()
-             << " for the type: " << *unwrap(Ty);
-      stream.flush();
-      report_fatal_error(error.c_str());
-    }
+  default: {
+    std::string error;
+    auto stream = llvm::raw_string_ostream(error);
+    stream << "Rust does not support the TypeID: " << unwrap(Ty)->getTypeID()
+           << " for the type: " << *unwrap(Ty);
+    stream.flush();
+    report_fatal_error(error.c_str());
+  }
   }
 }
 
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(SMDiagnostic, LLVMSMDiagnosticRef)
 
-extern "C" LLVMSMDiagnosticRef LLVMRustGetSMDiagnostic(
-    LLVMDiagnosticInfoRef DI, unsigned *Cookie) {
-  llvm::DiagnosticInfoSrcMgr *SM = static_cast<llvm::DiagnosticInfoSrcMgr *>(unwrap(DI));
+extern "C" LLVMSMDiagnosticRef LLVMRustGetSMDiagnostic(LLVMDiagnosticInfoRef DI,
+                                                       unsigned *Cookie) {
+  llvm::DiagnosticInfoSrcMgr *SM =
+      static_cast<llvm::DiagnosticInfoSrcMgr *>(unwrap(DI));
   *Cookie = SM->getLocCookie();
   return wrap(&SM->getSMDiag());
 }
 
-extern "C" bool LLVMRustUnpackSMDiagnostic(LLVMSMDiagnosticRef DRef,
-                                           RustStringRef MessageOut,
-                                           RustStringRef BufferOut,
-                                           LLVMRustDiagnosticLevel* LevelOut,
-                                           unsigned* LocOut,
-                                           unsigned* RangesOut,
-                                           size_t* NumRanges) {
-  SMDiagnostic& D = *unwrap(DRef);
+extern "C" bool
+LLVMRustUnpackSMDiagnostic(LLVMSMDiagnosticRef DRef, RustStringRef MessageOut,
+                           RustStringRef BufferOut,
+                           LLVMRustDiagnosticLevel *LevelOut, unsigned *LocOut,
+                           unsigned *RangesOut, size_t *NumRanges) {
+  SMDiagnostic &D = *unwrap(DRef);
   auto MessageOS = RawRustStringOstream(MessageOut);
   MessageOS << D.getMessage();
 
   switch (D.getKind()) {
-    case SourceMgr::DK_Error:
-      *LevelOut = LLVMRustDiagnosticLevel::Error;
-      break;
-    case SourceMgr::DK_Warning:
-      *LevelOut = LLVMRustDiagnosticLevel::Warning;
-      break;
-    case SourceMgr::DK_Note:
-      *LevelOut = LLVMRustDiagnosticLevel::Note;
-      break;
-    case SourceMgr::DK_Remark:
-      *LevelOut = LLVMRustDiagnosticLevel::Remark;
-      break;
-    default:
-      report_fatal_error("Invalid LLVMRustDiagnosticLevel value!");
+  case SourceMgr::DK_Error:
+    *LevelOut = LLVMRustDiagnosticLevel::Error;
+    break;
+  case SourceMgr::DK_Warning:
+    *LevelOut = LLVMRustDiagnosticLevel::Warning;
+    break;
+  case SourceMgr::DK_Note:
+    *LevelOut = LLVMRustDiagnosticLevel::Note;
+    break;
+  case SourceMgr::DK_Remark:
+    *LevelOut = LLVMRustDiagnosticLevel::Remark;
+    break;
+  default:
+    report_fatal_error("Invalid LLVMRustDiagnosticLevel value!");
   }
 
   if (D.getLoc() == SMLoc())
     return false;
 
   const SourceMgr &LSM = *D.getSourceMgr();
-  const MemoryBuffer *LBuf = LSM.getMemoryBuffer(LSM.FindBufferContainingLoc(D.getLoc()));
-  LLVMRustStringWriteImpl(BufferOut, LBuf->getBufferStart(), LBuf->getBufferSize());
+  const MemoryBuffer *LBuf =
+      LSM.getMemoryBuffer(LSM.FindBufferContainingLoc(D.getLoc()));
+  LLVMRustStringWriteImpl(BufferOut, LBuf->getBufferStart(),
+                          LBuf->getBufferSize());
 
   *LocOut = D.getLoc().getPointer() - LBuf->getBufferStart();
 
@@ -1525,7 +1505,8 @@ extern "C" bool LLVMRustUnpackSMDiagnostic(LLVMSMDiagnosticRef DRef,
 extern "C" OperandBundleDef *LLVMRustBuildOperandBundleDef(const char *Name,
                                                            LLVMValueRef *Inputs,
                                                            unsigned NumInputs) {
-  return new OperandBundleDef(Name, ArrayRef<Value*>(unwrap(Inputs), NumInputs));
+  return new OperandBundleDef(Name,
+                              ArrayRef<Value *>(unwrap(Inputs), NumInputs));
 }
 
 extern "C" void LLVMRustFreeOperandBundleDef(OperandBundleDef *Bundle) {
@@ -1533,8 +1514,9 @@ extern "C" void LLVMRustFreeOperandBundleDef(OperandBundleDef *Bundle) {
 }
 
 // OpBundlesIndirect is an array of pointers (*not* a pointer to an array).
-extern "C" LLVMValueRef LLVMRustBuildCall(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Fn,
-                                          LLVMValueRef *Args, unsigned NumArgs,
+extern "C" LLVMValueRef LLVMRustBuildCall(LLVMBuilderRef B, LLVMTypeRef Ty,
+                                          LLVMValueRef Fn, LLVMValueRef *Args,
+                                          unsigned NumArgs,
                                           OperandBundleDef **OpBundlesIndirect,
                                           unsigned NumOpBundles) {
   Value *Callee = unwrap(Fn);
@@ -1547,17 +1529,19 @@ extern "C" LLVMValueRef LLVMRustBuildCall(LLVMBuilderRef B, LLVMTypeRef Ty, LLVM
     OpBundles.push_back(*OpBundlesIndirect[i]);
   }
 
-  return wrap(unwrap(B)->CreateCall(
-      FTy, Callee, ArrayRef<Value*>(unwrap(Args), NumArgs),
-      ArrayRef<OperandBundleDef>(OpBundles)));
+  return wrap(unwrap(B)->CreateCall(FTy, Callee,
+                                    ArrayRef<Value *>(unwrap(Args), NumArgs),
+                                    ArrayRef<OperandBundleDef>(OpBundles)));
 }
 
-extern "C" LLVMValueRef LLVMRustGetInstrProfIncrementIntrinsic(LLVMModuleRef M) {
+extern "C" LLVMValueRef
+LLVMRustGetInstrProfIncrementIntrinsic(LLVMModuleRef M) {
   return wrap(llvm::Intrinsic::getDeclaration(
       unwrap(M), llvm::Intrinsic::instrprof_increment));
 }
 
-extern "C" LLVMValueRef LLVMRustGetInstrProfMCDCParametersIntrinsic(LLVMModuleRef M) {
+extern "C" LLVMValueRef
+LLVMRustGetInstrProfMCDCParametersIntrinsic(LLVMModuleRef M) {
 #if LLVM_VERSION_GE(18, 0)
   return wrap(llvm::Intrinsic::getDeclaration(
       unwrap(M), llvm::Intrinsic::instrprof_mcdc_parameters));
@@ -1566,7 +1550,8 @@ extern "C" LLVMValueRef LLVMRustGetInstrProfMCDCParametersIntrinsic(LLVMModuleRe
 #endif
 }
 
-extern "C" LLVMValueRef LLVMRustGetInstrProfMCDCTVBitmapUpdateIntrinsic(LLVMModuleRef M) {
+extern "C" LLVMValueRef
+LLVMRustGetInstrProfMCDCTVBitmapUpdateIntrinsic(LLVMModuleRef M) {
 #if LLVM_VERSION_GE(18, 0)
   return wrap(llvm::Intrinsic::getDeclaration(
       unwrap(M), llvm::Intrinsic::instrprof_mcdc_tvbitmap_update));
@@ -1575,7 +1560,8 @@ extern "C" LLVMValueRef LLVMRustGetInstrProfMCDCTVBitmapUpdateIntrinsic(LLVMModu
 #endif
 }
 
-extern "C" LLVMValueRef LLVMRustGetInstrProfMCDCCondBitmapIntrinsic(LLVMModuleRef M) {
+extern "C" LLVMValueRef
+LLVMRustGetInstrProfMCDCCondBitmapIntrinsic(LLVMModuleRef M) {
 #if LLVM_VERSION_GE(18, 0)
   return wrap(llvm::Intrinsic::getDeclaration(
       unwrap(M), llvm::Intrinsic::instrprof_mcdc_condbitmap_update));
@@ -1584,32 +1570,31 @@ extern "C" LLVMValueRef LLVMRustGetInstrProfMCDCCondBitmapIntrinsic(LLVMModuleRe
 #endif
 }
 
-extern "C" LLVMValueRef LLVMRustBuildMemCpy(LLVMBuilderRef B,
-                                            LLVMValueRef Dst, unsigned DstAlign,
-                                            LLVMValueRef Src, unsigned SrcAlign,
-                                            LLVMValueRef Size, bool IsVolatile) {
-  return wrap(unwrap(B)->CreateMemCpy(
-      unwrap(Dst), MaybeAlign(DstAlign),
-      unwrap(Src), MaybeAlign(SrcAlign),
-      unwrap(Size), IsVolatile));
+extern "C" LLVMValueRef LLVMRustBuildMemCpy(LLVMBuilderRef B, LLVMValueRef Dst,
+                                            unsigned DstAlign, LLVMValueRef Src,
+                                            unsigned SrcAlign,
+                                            LLVMValueRef Size,
+                                            bool IsVolatile) {
+  return wrap(unwrap(B)->CreateMemCpy(unwrap(Dst), MaybeAlign(DstAlign),
+                                      unwrap(Src), MaybeAlign(SrcAlign),
+                                      unwrap(Size), IsVolatile));
 }
 
-extern "C" LLVMValueRef LLVMRustBuildMemMove(LLVMBuilderRef B,
-                                             LLVMValueRef Dst, unsigned DstAlign,
-                                             LLVMValueRef Src, unsigned SrcAlign,
-                                             LLVMValueRef Size, bool IsVolatile) {
-  return wrap(unwrap(B)->CreateMemMove(
-      unwrap(Dst), MaybeAlign(DstAlign),
-      unwrap(Src), MaybeAlign(SrcAlign),
-      unwrap(Size), IsVolatile));
+extern "C" LLVMValueRef
+LLVMRustBuildMemMove(LLVMBuilderRef B, LLVMValueRef Dst, unsigned DstAlign,
+                     LLVMValueRef Src, unsigned SrcAlign, LLVMValueRef Size,
+                     bool IsVolatile) {
+  return wrap(unwrap(B)->CreateMemMove(unwrap(Dst), MaybeAlign(DstAlign),
+                                       unwrap(Src), MaybeAlign(SrcAlign),
+                                       unwrap(Size), IsVolatile));
 }
 
-extern "C" LLVMValueRef LLVMRustBuildMemSet(LLVMBuilderRef B,
-                                            LLVMValueRef Dst, unsigned DstAlign,
-                                            LLVMValueRef Val,
-                                            LLVMValueRef Size, bool IsVolatile) {
-  return wrap(unwrap(B)->CreateMemSet(
-      unwrap(Dst), unwrap(Val), unwrap(Size), MaybeAlign(DstAlign), IsVolatile));
+extern "C" LLVMValueRef LLVMRustBuildMemSet(LLVMBuilderRef B, LLVMValueRef Dst,
+                                            unsigned DstAlign, LLVMValueRef Val,
+                                            LLVMValueRef Size,
+                                            bool IsVolatile) {
+  return wrap(unwrap(B)->CreateMemSet(unwrap(Dst), unwrap(Val), unwrap(Size),
+                                      MaybeAlign(DstAlign), IsVolatile));
 }
 
 // OpBundlesIndirect is an array of pointers (*not* a pointer to an array).
@@ -1630,7 +1615,7 @@ LLVMRustBuildInvoke(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Fn,
   }
 
   return wrap(unwrap(B)->CreateInvoke(FTy, Callee, unwrap(Then), unwrap(Catch),
-                                      ArrayRef<Value*>(unwrap(Args), NumArgs),
+                                      ArrayRef<Value *>(unwrap(Args), NumArgs),
                                       ArrayRef<OperandBundleDef>(OpBundles),
                                       Name));
 }
@@ -1647,7 +1632,7 @@ LLVMRustBuildCallBr(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Fn,
   FunctionType *FTy = unwrap<FunctionType>(Ty);
 
   // FIXME: Is there a way around this?
-  std::vector<BasicBlock*> IndirectDestsUnwrapped;
+  std::vector<BasicBlock *> IndirectDestsUnwrapped;
   IndirectDestsUnwrapped.reserve(NumIndirectDests);
   for (unsigned i = 0; i < NumIndirectDests; ++i) {
     IndirectDestsUnwrapped.push_back(unwrap(IndirectDests[i]));
@@ -1660,12 +1645,11 @@ LLVMRustBuildCallBr(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Fn,
     OpBundles.push_back(*OpBundlesIndirect[i]);
   }
 
-  return wrap(unwrap(B)->CreateCallBr(
-      FTy, Callee, unwrap(DefaultDest),
-      ArrayRef<BasicBlock*>(IndirectDestsUnwrapped),
-      ArrayRef<Value*>(unwrap(Args), NumArgs),
-      ArrayRef<OperandBundleDef>(OpBundles),
-      Name));
+  return wrap(
+      unwrap(B)->CreateCallBr(FTy, Callee, unwrap(DefaultDest),
+                              ArrayRef<BasicBlock *>(IndirectDestsUnwrapped),
+                              ArrayRef<Value *>(unwrap(Args), NumArgs),
+                              ArrayRef<OperandBundleDef>(OpBundles), Name));
 }
 
 extern "C" void LLVMRustPositionBuilderAtStart(LLVMBuilderRef B,
@@ -1765,28 +1749,30 @@ extern "C" void LLVMRustSetLinkage(LLVMValueRef V,
 }
 
 extern "C" bool LLVMRustConstIntGetZExtValue(LLVMValueRef CV, uint64_t *value) {
-    auto C = unwrap<llvm::ConstantInt>(CV);
-    if (C->getBitWidth() > 64)
-      return false;
-    *value = C->getZExtValue();
-    return true;
+  auto C = unwrap<llvm::ConstantInt>(CV);
+  if (C->getBitWidth() > 64)
+    return false;
+  *value = C->getZExtValue();
+  return true;
 }
 
-// Returns true if both high and low were successfully set. Fails in case constant wasn’t any of
-// the common sizes (1, 8, 16, 32, 64, 128 bits)
-extern "C" bool LLVMRustConstInt128Get(LLVMValueRef CV, bool sext, uint64_t *high, uint64_t *low)
-{
-    auto C = unwrap<llvm::ConstantInt>(CV);
-    if (C->getBitWidth() > 128) { return false; }
-    APInt AP;
-    if (sext) {
-        AP = C->getValue().sext(128);
-    } else {
-        AP = C->getValue().zext(128);
-    }
-    *low = AP.getLoBits(64).getZExtValue();
-    *high = AP.getHiBits(64).getZExtValue();
-    return true;
+// Returns true if both high and low were successfully set. Fails in case
+// constant wasn’t any of the common sizes (1, 8, 16, 32, 64, 128 bits)
+extern "C" bool LLVMRustConstInt128Get(LLVMValueRef CV, bool sext,
+                                       uint64_t *high, uint64_t *low) {
+  auto C = unwrap<llvm::ConstantInt>(CV);
+  if (C->getBitWidth() > 128) {
+    return false;
+  }
+  APInt AP;
+  if (sext) {
+    AP = C->getValue().sext(128);
+  } else {
+    AP = C->getValue().zext(128);
+  }
+  *low = AP.getLoBits(64).getZExtValue();
+  *high = AP.getHiBits(64).getZExtValue();
+  return true;
 }
 
 enum class LLVMRustVisibility {
@@ -1836,8 +1822,7 @@ struct LLVMRustModuleBuffer {
   std::string data;
 };
 
-extern "C" LLVMRustModuleBuffer*
-LLVMRustModuleBufferCreate(LLVMModuleRef M) {
+extern "C" LLVMRustModuleBuffer *LLVMRustModuleBufferCreate(LLVMModuleRef M) {
   auto Ret = std::make_unique<LLVMRustModuleBuffer>();
   {
     auto OS = raw_string_ostream(Ret->data);
@@ -1846,30 +1831,26 @@ LLVMRustModuleBufferCreate(LLVMModuleRef M) {
   return Ret.release();
 }
 
-extern "C" void
-LLVMRustModuleBufferFree(LLVMRustModuleBuffer *Buffer) {
+extern "C" void LLVMRustModuleBufferFree(LLVMRustModuleBuffer *Buffer) {
   delete Buffer;
 }
 
-extern "C" const void*
+extern "C" const void *
 LLVMRustModuleBufferPtr(const LLVMRustModuleBuffer *Buffer) {
   return Buffer->data.data();
 }
 
-extern "C" size_t
-LLVMRustModuleBufferLen(const LLVMRustModuleBuffer *Buffer) {
+extern "C" size_t LLVMRustModuleBufferLen(const LLVMRustModuleBuffer *Buffer) {
   return Buffer->data.length();
 }
 
-extern "C" uint64_t
-LLVMRustModuleCost(LLVMModuleRef M) {
+extern "C" uint64_t LLVMRustModuleCost(LLVMModuleRef M) {
   auto f = unwrap(M)->functions();
   return std::distance(std::begin(f), std::end(f));
 }
 
-extern "C" void
-LLVMRustModuleInstructionStats(LLVMModuleRef M, RustStringRef Str)
-{
+extern "C" void LLVMRustModuleInstructionStats(LLVMModuleRef M,
+                                               RustStringRef Str) {
   auto OS = RawRustStringOstream(Str);
   auto JOS = llvm::json::OStream(OS);
   auto Module = unwrap(M);
@@ -1881,41 +1862,45 @@ LLVMRustModuleInstructionStats(LLVMModuleRef M, RustStringRef Str)
 }
 
 // Vector reductions:
-extern "C" LLVMValueRef
-LLVMRustBuildVectorReduceFAdd(LLVMBuilderRef B, LLVMValueRef Acc, LLVMValueRef Src) {
-    return wrap(unwrap(B)->CreateFAddReduce(unwrap(Acc),unwrap(Src)));
+extern "C" LLVMValueRef LLVMRustBuildVectorReduceFAdd(LLVMBuilderRef B,
+                                                      LLVMValueRef Acc,
+                                                      LLVMValueRef Src) {
+  return wrap(unwrap(B)->CreateFAddReduce(unwrap(Acc), unwrap(Src)));
 }
-extern "C" LLVMValueRef
-LLVMRustBuildVectorReduceFMul(LLVMBuilderRef B, LLVMValueRef Acc, LLVMValueRef Src) {
-    return wrap(unwrap(B)->CreateFMulReduce(unwrap(Acc),unwrap(Src)));
+extern "C" LLVMValueRef LLVMRustBuildVectorReduceFMul(LLVMBuilderRef B,
+                                                      LLVMValueRef Acc,
+                                                      LLVMValueRef Src) {
+  return wrap(unwrap(B)->CreateFMulReduce(unwrap(Acc), unwrap(Src)));
 }
-extern "C" LLVMValueRef
-LLVMRustBuildVectorReduceAdd(LLVMBuilderRef B, LLVMValueRef Src) {
-    return wrap(unwrap(B)->CreateAddReduce(unwrap(Src)));
+extern "C" LLVMValueRef LLVMRustBuildVectorReduceAdd(LLVMBuilderRef B,
+                                                     LLVMValueRef Src) {
+  return wrap(unwrap(B)->CreateAddReduce(unwrap(Src)));
 }
-extern "C" LLVMValueRef
-LLVMRustBuildVectorReduceMul(LLVMBuilderRef B, LLVMValueRef Src) {
-    return wrap(unwrap(B)->CreateMulReduce(unwrap(Src)));
+extern "C" LLVMValueRef LLVMRustBuildVectorReduceMul(LLVMBuilderRef B,
+                                                     LLVMValueRef Src) {
+  return wrap(unwrap(B)->CreateMulReduce(unwrap(Src)));
 }
-extern "C" LLVMValueRef
-LLVMRustBuildVectorReduceAnd(LLVMBuilderRef B, LLVMValueRef Src) {
-    return wrap(unwrap(B)->CreateAndReduce(unwrap(Src)));
+extern "C" LLVMValueRef LLVMRustBuildVectorReduceAnd(LLVMBuilderRef B,
+                                                     LLVMValueRef Src) {
+  return wrap(unwrap(B)->CreateAndReduce(unwrap(Src)));
 }
-extern "C" LLVMValueRef
-LLVMRustBuildVectorReduceOr(LLVMBuilderRef B, LLVMValueRef Src) {
-    return wrap(unwrap(B)->CreateOrReduce(unwrap(Src)));
+extern "C" LLVMValueRef LLVMRustBuildVectorReduceOr(LLVMBuilderRef B,
+                                                    LLVMValueRef Src) {
+  return wrap(unwrap(B)->CreateOrReduce(unwrap(Src)));
 }
-extern "C" LLVMValueRef
-LLVMRustBuildVectorReduceXor(LLVMBuilderRef B, LLVMValueRef Src) {
-    return wrap(unwrap(B)->CreateXorReduce(unwrap(Src)));
+extern "C" LLVMValueRef LLVMRustBuildVectorReduceXor(LLVMBuilderRef B,
+                                                     LLVMValueRef Src) {
+  return wrap(unwrap(B)->CreateXorReduce(unwrap(Src)));
 }
-extern "C" LLVMValueRef
-LLVMRustBuildVectorReduceMin(LLVMBuilderRef B, LLVMValueRef Src, bool IsSigned) {
-    return wrap(unwrap(B)->CreateIntMinReduce(unwrap(Src), IsSigned));
+extern "C" LLVMValueRef LLVMRustBuildVectorReduceMin(LLVMBuilderRef B,
+                                                     LLVMValueRef Src,
+                                                     bool IsSigned) {
+  return wrap(unwrap(B)->CreateIntMinReduce(unwrap(Src), IsSigned));
 }
-extern "C" LLVMValueRef
-LLVMRustBuildVectorReduceMax(LLVMBuilderRef B, LLVMValueRef Src, bool IsSigned) {
-    return wrap(unwrap(B)->CreateIntMaxReduce(unwrap(Src), IsSigned));
+extern "C" LLVMValueRef LLVMRustBuildVectorReduceMax(LLVMBuilderRef B,
+                                                     LLVMValueRef Src,
+                                                     bool IsSigned) {
+  return wrap(unwrap(B)->CreateIntMaxReduce(unwrap(Src), IsSigned));
 }
 extern "C" LLVMValueRef
 LLVMRustBuildVectorReduceFMin(LLVMBuilderRef B, LLVMValueRef Src, bool NoNaN) {
@@ -1930,32 +1915,28 @@ LLVMRustBuildVectorReduceFMax(LLVMBuilderRef B, LLVMValueRef Src, bool NoNaN) {
   return wrap(I);
 }
 
-extern "C" LLVMValueRef
-LLVMRustBuildMinNum(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS) {
-    return wrap(unwrap(B)->CreateMinNum(unwrap(LHS),unwrap(RHS)));
+extern "C" LLVMValueRef LLVMRustBuildMinNum(LLVMBuilderRef B, LLVMValueRef LHS,
+                                            LLVMValueRef RHS) {
+  return wrap(unwrap(B)->CreateMinNum(unwrap(LHS), unwrap(RHS)));
 }
-extern "C" LLVMValueRef
-LLVMRustBuildMaxNum(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS) {
-    return wrap(unwrap(B)->CreateMaxNum(unwrap(LHS),unwrap(RHS)));
+extern "C" LLVMValueRef LLVMRustBuildMaxNum(LLVMBuilderRef B, LLVMValueRef LHS,
+                                            LLVMValueRef RHS) {
+  return wrap(unwrap(B)->CreateMaxNum(unwrap(LHS), unwrap(RHS)));
 }
 
 // This struct contains all necessary info about a symbol exported from a DLL.
 struct LLVMRustCOFFShortExport {
-  const char* name;
+  const char *name;
   bool ordinal_present;
   // The value of `ordinal` is only meaningful if `ordinal_present` is true.
   uint16_t ordinal;
 };
 
 // Machine must be a COFF machine type, as defined in PE specs.
-extern "C" LLVMRustResult LLVMRustWriteImportLibrary(
-  const char* ImportName,
-  const char* Path,
-  const LLVMRustCOFFShortExport* Exports,
-  size_t NumExports,
-  uint16_t Machine,
-  bool MinGW)
-{
+extern "C" LLVMRustResult
+LLVMRustWriteImportLibrary(const char *ImportName, const char *Path,
+                           const LLVMRustCOFFShortExport *Exports,
+                           size_t NumExports, uint16_t Machine, bool MinGW) {
   std::vector<llvm::object::COFFShortExport> ConvertedExports;
   ConvertedExports.reserve(NumExports);
 
@@ -1963,27 +1944,24 @@ extern "C" LLVMRustResult LLVMRustWriteImportLibrary(
     bool ordinal_present = Exports[i].ordinal_present;
     uint16_t ordinal = ordinal_present ? Exports[i].ordinal : 0;
     ConvertedExports.push_back(llvm::object::COFFShortExport{
-      Exports[i].name,  // Name
-      std::string{},    // ExtName
-      std::string{},    // SymbolName
-      std::string{},    // AliasTarget
+        Exports[i].name, // Name
+        std::string{},   // ExtName
+        std::string{},   // SymbolName
+        std::string{},   // AliasTarget
 #if LLVM_VERSION_GE(19, 0)
-      std::string{},    // ExportAs
+        std::string{}, // ExportAs
 #endif
-      ordinal,          // Ordinal
-      ordinal_present,  // Noname
-      false,            // Data
-      false,            // Private
-      false             // Constant
+        ordinal,         // Ordinal
+        ordinal_present, // Noname
+        false,           // Data
+        false,           // Private
+        false            // Constant
     });
   }
 
   auto Error = llvm::object::writeImportLibrary(
-    ImportName,
-    Path,
-    ConvertedExports,
-    static_cast<llvm::COFF::MachineTypes>(Machine),
-    MinGW);
+      ImportName, Path, ConvertedExports,
+      static_cast<llvm::COFF::MachineTypes>(Machine), MinGW);
   if (Error) {
     std::string errorString;
     auto stream = llvm::raw_string_ostream(errorString);
@@ -2019,27 +1997,23 @@ using LLVMDiagnosticHandlerTy = DiagnosticHandler::DiagnosticHandlerTy;
 // the RemarkPasses array specifies individual passes for which remarks will be
 // enabled.
 //
-// If RemarkFilePath is not NULL, optimization remarks will be streamed directly into this file,
-// bypassing the diagnostics handler.
+// If RemarkFilePath is not NULL, optimization remarks will be streamed directly
+// into this file, bypassing the diagnostics handler.
 extern "C" void LLVMRustContextConfigureDiagnosticHandler(
     LLVMContextRef C, LLVMDiagnosticHandlerTy DiagnosticHandlerCallback,
     void *DiagnosticHandlerContext, bool RemarkAllPasses,
-    const char * const * RemarkPasses, size_t RemarkPassesLen,
-    const char * RemarkFilePath,
-    bool PGOAvailable
-) {
+    const char *const *RemarkPasses, size_t RemarkPassesLen,
+    const char *RemarkFilePath, bool PGOAvailable) {
 
   class RustDiagnosticHandler final : public DiagnosticHandler {
   public:
     RustDiagnosticHandler(
-      LLVMDiagnosticHandlerTy DiagnosticHandlerCallback,
-      void *DiagnosticHandlerContext,
-      bool RemarkAllPasses,
-      std::vector<std::string> RemarkPasses,
-      std::unique_ptr<ToolOutputFile> RemarksFile,
-      std::unique_ptr<llvm::remarks::RemarkStreamer> RemarkStreamer,
-      std::unique_ptr<LLVMRemarkStreamer> LlvmRemarkStreamer
-    )
+        LLVMDiagnosticHandlerTy DiagnosticHandlerCallback,
+        void *DiagnosticHandlerContext, bool RemarkAllPasses,
+        std::vector<std::string> RemarkPasses,
+        std::unique_ptr<ToolOutputFile> RemarksFile,
+        std::unique_ptr<llvm::remarks::RemarkStreamer> RemarkStreamer,
+        std::unique_ptr<LLVMRemarkStreamer> LlvmRemarkStreamer)
         : DiagnosticHandlerCallback(DiagnosticHandlerCallback),
           DiagnosticHandlerContext(DiagnosticHandlerContext),
           RemarkAllPasses(RemarkAllPasses),
@@ -2049,11 +2023,13 @@ extern "C" void LLVMRustContextConfigureDiagnosticHandler(
           LlvmRemarkStreamer(std::move(LlvmRemarkStreamer)) {}
 
     virtual bool handleDiagnostics(const DiagnosticInfo &DI) override {
-      // If this diagnostic is one of the optimization remark kinds, we can check if it's enabled
-      // before emitting it. This can avoid many short-lived allocations when unpacking the
-      // diagnostic and converting its various C++ strings into rust strings.
-      // FIXME: some diagnostic infos still allocate before we get here, and avoiding that would be
-      // good in the future. That will require changing a few call sites in LLVM.
+      // If this diagnostic is one of the optimization remark kinds, we can
+      // check if it's enabled before emitting it. This can avoid many
+      // short-lived allocations when unpacking the diagnostic and converting
+      // its various C++ strings into rust strings.
+      // FIXME: some diagnostic infos still allocate before we get here, and
+      // avoiding that would be good in the future. That will require changing a
+      // few call sites in LLVM.
       if (auto *OptDiagBase = dyn_cast<DiagnosticInfoOptimizationBase>(&DI)) {
         if (OptDiagBase->isEnabled()) {
           if (this->LlvmRemarkStreamer) {
@@ -2109,16 +2085,15 @@ extern "C" void LLVMRustContextConfigureDiagnosticHandler(
     bool RemarkAllPasses = false;
     std::vector<std::string> RemarkPasses;
 
-    // Since LlvmRemarkStreamer contains a pointer to RemarkStreamer, the ordering of the three
-    // members below is important.
+    // Since LlvmRemarkStreamer contains a pointer to RemarkStreamer, the
+    // ordering of the three members below is important.
     std::unique_ptr<ToolOutputFile> RemarksFile;
     std::unique_ptr<llvm::remarks::RemarkStreamer> RemarkStreamer;
     std::unique_ptr<LLVMRemarkStreamer> LlvmRemarkStreamer;
   };
 
   std::vector<std::string> Passes;
-  for (size_t I = 0; I != RemarkPassesLen; ++I)
-  {
+  for (size_t I = 0; I != RemarkPassesLen; ++I) {
     Passes.push_back(RemarkPasses[I]);
   }
 
@@ -2135,13 +2110,10 @@ extern "C" void LLVMRustContextConfigureDiagnosticHandler(
 
     std::error_code EC;
     RemarkFile = std::make_unique<ToolOutputFile>(
-      RemarkFilePath,
-      EC,
-      llvm::sys::fs::OF_TextWithCRLF
-    );
+        RemarkFilePath, EC, llvm::sys::fs::OF_TextWithCRLF);
     if (EC) {
       std::string Error = std::string("Cannot create remark file: ") +
-              toString(errorCodeToError(EC));
+                          toString(errorCodeToError(EC));
       report_fatal_error(Twine(Error));
     }
 
@@ -2149,28 +2121,22 @@ extern "C" void LLVMRustContextConfigureDiagnosticHandler(
     RemarkFile->keep();
 
     auto RemarkSerializer = remarks::createRemarkSerializer(
-      llvm::remarks::Format::YAML,
-      remarks::SerializerMode::Separate,
-      RemarkFile->os()
-    );
-    if (Error E = RemarkSerializer.takeError())
-    {
-      std::string Error = std::string("Cannot create remark serializer: ") + toString(std::move(E));
+        llvm::remarks::Format::YAML, remarks::SerializerMode::Separate,
+        RemarkFile->os());
+    if (Error E = RemarkSerializer.takeError()) {
+      std::string Error = std::string("Cannot create remark serializer: ") +
+                          toString(std::move(E));
       report_fatal_error(Twine(Error));
     }
-    RemarkStreamer = std::make_unique<llvm::remarks::RemarkStreamer>(std::move(*RemarkSerializer));
+    RemarkStreamer = std::make_unique<llvm::remarks::RemarkStreamer>(
+        std::move(*RemarkSerializer));
     LlvmRemarkStreamer = std::make_unique<LLVMRemarkStreamer>(*RemarkStreamer);
   }
 
   unwrap(C)->setDiagnosticHandler(std::make_unique<RustDiagnosticHandler>(
-    DiagnosticHandlerCallback,
-    DiagnosticHandlerContext,
-    RemarkAllPasses,
-    Passes,
-    std::move(RemarkFile),
-    std::move(RemarkStreamer),
-    std::move(LlvmRemarkStreamer)
-  ));
+      DiagnosticHandlerCallback, DiagnosticHandlerContext, RemarkAllPasses,
+      Passes, std::move(RemarkFile), std::move(RemarkStreamer),
+      std::move(LlvmRemarkStreamer)));
 }
 
 extern "C" void LLVMRustGetMangledName(LLVMValueRef V, RustStringRef Str) {
@@ -2180,14 +2146,14 @@ extern "C" void LLVMRustGetMangledName(LLVMValueRef V, RustStringRef Str) {
 }
 
 extern "C" int32_t LLVMRustGetElementTypeArgIndex(LLVMValueRef CallSite) {
-    auto *CB = unwrap<CallBase>(CallSite);
-    switch (CB->getIntrinsicID()) {
-        case Intrinsic::arm_ldrex:
-            return 0;
-        case Intrinsic::arm_strex:
-            return 1;
-    }
-    return -1;
+  auto *CB = unwrap<CallBase>(CallSite);
+  switch (CB->getIntrinsicID()) {
+  case Intrinsic::arm_ldrex:
+    return 0;
+  case Intrinsic::arm_strex:
+    return 1;
+  }
+  return -1;
 }
 
 extern "C" bool LLVMRustIsBitcode(char *ptr, size_t len) {
@@ -2214,10 +2180,10 @@ extern "C" bool LLVMRustLLVMHasZstdCompressionForDebugSymbols() {
 }
 
 // Operations on composite constants.
-// These are clones of LLVM api functions that will become available in future releases.
-// They can be removed once Rust's minimum supported LLVM version supports them.
-// See https://github.com/rust-lang/rust/issues/121868
-// See https://llvm.org/doxygen/group__LLVMCCoreValueConstantComposite.html
+// These are clones of LLVM api functions that will become available in future
+// releases. They can be removed once Rust's minimum supported LLVM version
+// supports them. See https://github.com/rust-lang/rust/issues/121868 See
+// https://llvm.org/doxygen/group__LLVMCCoreValueConstantComposite.html
 
 // FIXME: Remove when Rust's minimum supported LLVM version reaches 19.
 // https://github.com/llvm/llvm-project/commit/e1405e4f71c899420ebf8262d5e9745598419df8
@@ -2226,6 +2192,7 @@ extern "C" LLVMValueRef LLVMConstStringInContext2(LLVMContextRef C,
                                                   const char *Str,
                                                   size_t Length,
                                                   bool DontNullTerminate) {
-  return wrap(ConstantDataArray::getString(*unwrap(C), StringRef(Str, Length), !DontNullTerminate));
+  return wrap(ConstantDataArray::getString(*unwrap(C), StringRef(Str, Length),
+                                           !DontNullTerminate));
 }
 #endif
diff --git a/compiler/rustc_llvm/llvm-wrapper/SuppressLLVMWarnings.h b/compiler/rustc_llvm/llvm-wrapper/SuppressLLVMWarnings.h
index 56964e4eaa7..09ecfd54cd8 100644
--- a/compiler/rustc_llvm/llvm-wrapper/SuppressLLVMWarnings.h
+++ b/compiler/rustc_llvm/llvm-wrapper/SuppressLLVMWarnings.h
@@ -1,13 +1,17 @@
 #ifndef _rustc_llvm_SuppressLLVMWarnings_h
 #define _rustc_llvm_SuppressLLVMWarnings_h
 
-// LLVM currently generates many warnings when compiled using MSVC. These warnings make it difficult
-// to diagnose real problems when working on C++ code, so we suppress them.
+// LLVM currently generates many warnings when compiled using MSVC. These
+// warnings make it difficult to diagnose real problems when working on C++
+// code, so we suppress them.
 
 #ifdef _MSC_VER
-#pragma warning(disable:4530) // C++ exception handler used, but unwind semantics are not enabled.
-#pragma warning(disable:4624) // 'xxx': destructor was implicitly defined as deleted
-#pragma warning(disable:4244) // conversion from 'xxx' to 'yyy', possible loss of data
+#pragma warning(disable : 4530) // C++ exception handler used, but unwind
+                                // semantics are not enabled.
+#pragma warning(                                                               \
+    disable : 4624) // 'xxx': destructor was implicitly defined as deleted
+#pragma warning(                                                               \
+    disable : 4244) // conversion from 'xxx' to 'yyy', possible loss of data
 #endif
 
 #endif // _rustc_llvm_SuppressLLVMWarnings_h
diff --git a/compiler/rustc_llvm/llvm-wrapper/SymbolWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/SymbolWrapper.cpp
index ee8239ef8e7..a9d1362a338 100644
--- a/compiler/rustc_llvm/llvm-wrapper/SymbolWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/SymbolWrapper.cpp
@@ -34,14 +34,15 @@ static bool isArchiveSymbol(const object::BasicSymbolRef &S) {
 typedef void *(*LLVMRustGetSymbolsCallback)(void *, const char *);
 typedef void *(*LLVMRustGetSymbolsErrorCallback)(const char *);
 
-// Note: This is implemented in C++ instead of using the C api from Rust as IRObjectFile doesn't
-// implement getSymbolName, only printSymbolName, which is inaccessible from the C api.
-extern "C" void *LLVMRustGetSymbols(
-  char *BufPtr, size_t BufLen, void *State, LLVMRustGetSymbolsCallback Callback,
-  LLVMRustGetSymbolsErrorCallback ErrorCallback) {
-  std::unique_ptr<MemoryBuffer> Buf =
-    MemoryBuffer::getMemBuffer(StringRef(BufPtr, BufLen), StringRef("LLVMRustGetSymbolsObject"),
-                               false);
+// Note: This is implemented in C++ instead of using the C api from Rust as
+// IRObjectFile doesn't implement getSymbolName, only printSymbolName, which is
+// inaccessible from the C api.
+extern "C" void *
+LLVMRustGetSymbols(char *BufPtr, size_t BufLen, void *State,
+                   LLVMRustGetSymbolsCallback Callback,
+                   LLVMRustGetSymbolsErrorCallback ErrorCallback) {
+  std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(
+      StringRef(BufPtr, BufLen), StringRef("LLVMRustGetSymbolsObject"), false);
   SmallString<0> SymNameBuf;
   auto SymName = raw_svector_ostream(SymNameBuf);
 
@@ -57,7 +58,7 @@ extern "C" void *LLVMRustGetSymbols(
 
   if (Type == file_magic::bitcode) {
     auto ObjOrErr = object::SymbolicFile::createSymbolicFile(
-      Buf->getMemBufferRef(), file_magic::bitcode, &Context);
+        Buf->getMemBufferRef(), file_magic::bitcode, &Context);
     if (!ObjOrErr) {
       Error E = ObjOrErr.takeError();
       SmallString<0> ErrorBuf;
@@ -67,7 +68,8 @@ extern "C" void *LLVMRustGetSymbols(
     }
     Obj = std::move(*ObjOrErr);
   } else {
-    auto ObjOrErr = object::SymbolicFile::createSymbolicFile(Buf->getMemBufferRef());
+    auto ObjOrErr =
+        object::SymbolicFile::createSymbolicFile(Buf->getMemBufferRef());
     if (!ObjOrErr) {
       Error E = ObjOrErr.takeError();
       SmallString<0> ErrorBuf;
@@ -78,7 +80,6 @@ extern "C" void *LLVMRustGetSymbols(
     Obj = std::move(*ObjOrErr);
   }
 
-
   for (const object::BasicSymbolRef &S : Obj->symbols()) {
     if (!isArchiveSymbol(S))
       continue;