[llvm-c] Remove PassRegistry and initialization APIs

[nikic]

Summary

Remove C APIs for interacting with PassRegistry and pass initialization. As pointed out in D144970, these are legacy PM concepts that are no longer relevant for the new pass manager. Remaining uses of the legacy passes in the codegen pipeline will be initialized automatically.

Depends on D144970.

[nikic]

Add release notes.

[MaskRay]

It'd be great if you can wait a bit on landing this.

LLVMGetGlobalPassRegistry is called by some projects such as

• https://github.com/bytecodealliance/wasm-micro-runtime/blob/main/core/iwasm/compilation/aot_llvm.c#L1514
• https://github.com/numba/llvmlite/blob/main/ffi/initfini.cpp#L15

and we want to determine whether simply commenting out the functions locally can work.

[nikic]

@MaskRay Sure, I'm also waiting on https://github.com/rust-lang/rust/pull/108599 to land first.

Just to put it out there, an alternative to this patch is to retain all these functions and just make them no-ops. Maybe that's the better option in terms of reducing C API breakage?

[MaskRay]

In D145043#4165528, @nikic wrote:

@MaskRay Sure, I'm also waiting on https://github.com/rust-lang/rust/pull/108599 to land first.

Thank you! Also, we managed to integrate D144970 but it may be useful to wait for the change to stabilize...

Just to put it out there, an alternative to this patch is to retain all these functions and just make them no-ops. Maybe that's the better option in terms of reducing C API breakage?

Sounds good!

[aeubanks]

IMO it's better to delete API surfaces (not deleting one off functions since that does cause unnecessary churn, but e.g. everything that revolves around LLVMPassRegistryRef) that don't do anything, else it can be confusing for people to figure out how to use the C API when a good portion of them are no-ops

but yeah short term delaying this patch is fine

[nikic]

Just wanted to check back here whether we're ready to land this patch now or should wait longer?

[aeubanks]

I think we should be ok to go forward with this. can you put in the description that users can just delete calls to these functions

clang/docs/tools/clang-formatted-files.txt

 llvm/include/llvm/XRay/Trace.h
 llvm/include/llvm/XRay/YAMLXRayRecord.h
 llvm/include/llvm-c/BitReader.h
 llvm/include/llvm-c/BitWriter.h
 llvm/include/llvm-c/Comdat.h
 llvm/include/llvm-c/Error.h
 llvm/include/llvm-c/ErrorHandling.h
 llvm/include/llvm-c/ExternC.h
-llvm/include/llvm-c/Initialization.h
 llvm/include/llvm-c/IRReader.h
 llvm/include/llvm-c/LLJIT.h
 llvm/include/llvm-c/OrcEE.h
 llvm/include/llvm-c/Remarks.h
 llvm/include/llvm-c/Types.h
 llvm/include/llvm-c/Transforms/PassBuilder.h
 llvm/lib/Analysis/CodeMetrics.cpp
 llvm/lib/Analysis/CycleAnalysis.cpp

llvm/bindings/python/llvm/core.py

__all__ = [
     "OpCode",
     "MemoryBuffer",
     "Module",
     "Value",
     "Function",
     "BasicBlock",
     "Instruction",
     "Context",
-    "PassRegistry"
 ]
 
 lib = get_library()
 Enums = []
 
 class LLVMEnumeration(object):
     """Represents an individual LLVM enumeration."""
 
def __init__(self, context=None):
             LLVMObject.__init__(self, context, disposer=lib.LLVMContextDispose)
         else:
             LLVMObject.__init__(self, context)
 
     @classmethod
     def GetGlobalContext(cls):
         return Context(lib.LLVMGetGlobalContext())
 
-class PassRegistry(LLVMObject):
-    """Represents an opaque pass registry object."""
-
-    def __init__(self):
-        LLVMObject.__init__(self,
-                            lib.LLVMGetGlobalPassRegistry())
-
 def register_library(library):
     # Initialization/Shutdown declarations.
-    library.LLVMInitializeCore.argtypes = [PassRegistry]
-    library.LLVMInitializeCore.restype = None
-
-    library.LLVMInitializeTransformUtils.argtypes = [PassRegistry]
-    library.LLVMInitializeTransformUtils.restype = None
-
-    library.LLVMInitializeScalarOpts.argtypes = [PassRegistry]
-    library.LLVMInitializeScalarOpts.restype = None
-
-    library.LLVMInitializeVectorization.argtypes = [PassRegistry]
-    library.LLVMInitializeVectorization.restype = None
-
-    library.LLVMInitializeInstCombine.argtypes = [PassRegistry]
-    library.LLVMInitializeInstCombine.restype = None
-
-    library.LLVMInitializeIPO.argtypes = [PassRegistry]
-    library.LLVMInitializeIPO.restype = None
-
-    library.LLVMInitializeAnalysis.argtypes = [PassRegistry]
-    library.LLVMInitializeAnalysis.restype = None
-
-    library.LLVMInitializeCodeGen.argtypes = [PassRegistry]
-    library.LLVMInitializeCodeGen.restype = None
-
-    library.LLVMInitializeTarget.argtypes = [PassRegistry]
-    library.LLVMInitializeTarget.restype = None
-
     library.LLVMShutdown.argtypes = []
     library.LLVMShutdown.restype = None
 
-    # Pass Registry declarations.
-    library.LLVMGetGlobalPassRegistry.argtypes = []
-    library.LLVMGetGlobalPassRegistry.restype = c_object_p
-
     # Context declarations.
     library.LLVMContextCreate.argtypes = []
     library.LLVMContextCreate.restype = c_object_p
 
     library.LLVMContextDispose.argtypes = [Context]
     library.LLVMContextDispose.restype = None
 
     library.LLVMGetGlobalContext.argtypes = []
def register_enumerations():
     for enum_class, enum_spec in enums:
         for name, value in enum_spec:
             print(name, value)
             enum_class.register(name, value)
     return enums
 
 def initialize_llvm():
     Context.GetGlobalContext()
-    p = PassRegistry()
-    lib.LLVMInitializeCore(p)
-    lib.LLVMInitializeTransformUtils(p)
-    lib.LLVMInitializeScalarOpts(p)
-    lib.LLVMInitializeVectorization(p)
-    lib.LLVMInitializeInstCombine(p)
-    lib.LLVMInitializeIPO(p)
-    lib.LLVMInitializeAnalysis(p)
-    lib.LLVMInitializeCodeGen(p)
-    lib.LLVMInitializeTarget(p)
 
 register_library(lib)
 Enums = register_enumerations()
 initialize_llvm()

llvm/docs/ReleaseNotes.rst

 --------------------
 
 * ``LLVMContextSetOpaquePointers``, a temporary API to pin to legacy typed
   pointer, has been removed.
 * Functions for adding legacy passes like ``LLVMAddInstructionCombiningPass``
   have been removed.
 * Removed ``LLVMPassManagerBuilderRef`` and functions interacting with it.
   These belonged to the no longer supported legacy pass manager.
+* Functions for initializing legacy passes like ``LLVMInitializeInstCombine``
+  have been removed. Calls to such functions can simply be dropped, as they are
+  no longer necessary.
+* ``LLVMPassRegistryRef`` and ``LLVMGetGlobalPassRegistry``, which were only
+  useful in conjunction with initialization functions, have been removed.
 * As part of the opaque pointer transition, ``LLVMGetElementType`` no longer
   gives the pointee type of a pointer type.
 * The following functions for creating constant expressions have been removed,
   because the underlying constant expressions are no longer supported. Instead,
   an instruction should be created using the ``LLVMBuildXYZ`` APIs, which will
   constant fold the operands if possible and create an instruction otherwise:
 
   * ``LLVMConstSelect``

llvm/include/llvm-c/Core.h

 };
 
 typedef unsigned LLVMAttributeIndex;
 
 /**
  * @}
  */
 
-void LLVMInitializeCore(LLVMPassRegistryRef R);
-
 /** Deallocate and destroy all ManagedStatic variables.
     @see llvm::llvm_shutdown
     @see ManagedStatic */
 void LLVMShutdown(void);
 
 /*===-- Version query -----------------------------------------------------===*/
 
 /**

 size_t LLVMGetBufferSize(LLVMMemoryBufferRef MemBuf);
 void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf);
 
 /**
  * @}
  */
 
 /**
- * @defgroup LLVMCCorePassRegistry Pass Registry
- * @ingroup LLVMCCore
- *
- * @{
- */
-
-/** Return the global pass registry, for use with initialization functions.
-    @see llvm::PassRegistry::getPassRegistry */
-LLVMPassRegistryRef LLVMGetGlobalPassRegistry(void);
-
-/**
- * @}
- */
-
-/**
  * @defgroup LLVMCCorePassManagers Pass Managers
  * @ingroup LLVMCCore
  *
  * @{
  */
 
 /** Constructs a new whole-module pass pipeline. This type of pipeline is
     suitable for link-time optimization and whole-module transformations.

llvm/include/llvm-c/Initialization.h

-/*===-- llvm-c/Initialization.h - Initialization C Interface ------*- C -*-===*\
-|*                                                                            *|
-|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
-|* Exceptions.                                                                *|
-|* See https://llvm.org/LICENSE.txt for license information.                  *|
-|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
-|*                                                                            *|
-|*===----------------------------------------------------------------------===*|
-|*                                                                            *|
-|* This header declares the C interface to LLVM initialization routines,      *|
-|* which must be called before you can use the functionality provided by      *|
-|* the corresponding LLVM library.                                            *|
-|*                                                                            *|
-\*===----------------------------------------------------------------------===*/
-
-#ifndef LLVM_C_INITIALIZATION_H
-#define LLVM_C_INITIALIZATION_H
-
-#include "llvm-c/ExternC.h"
-#include "llvm-c/Types.h"
-
-LLVM_C_EXTERN_C_BEGIN
-
-/**
- * @defgroup LLVMCInitialization Initialization Routines
- * @ingroup LLVMC
- *
- * This module contains routines used to initialize the LLVM system.
- *
- * @{
- */
-
-void LLVMInitializeCore(LLVMPassRegistryRef R);
-void LLVMInitializeTransformUtils(LLVMPassRegistryRef R);
-void LLVMInitializeScalarOpts(LLVMPassRegistryRef R);
-void LLVMInitializeVectorization(LLVMPassRegistryRef R);
-void LLVMInitializeInstCombine(LLVMPassRegistryRef R);
-void LLVMInitializeIPO(LLVMPassRegistryRef R);
-void LLVMInitializeAnalysis(LLVMPassRegistryRef R);
-void LLVMInitializeIPA(LLVMPassRegistryRef R);
-void LLVMInitializeCodeGen(LLVMPassRegistryRef R);
-void LLVMInitializeTarget(LLVMPassRegistryRef R);
-
-/**
- * @}
- */
-
-LLVM_C_EXTERN_C_END
-
-#endif

llvm/include/llvm-c/Types.h

  * This is now just a synonym for llvm::Module, but we have to keep using the
  * different type to keep binary compatibility.
  */
 typedef struct LLVMOpaqueModuleProvider *LLVMModuleProviderRef;
 
 /** @see llvm::PassManagerBase */
 typedef struct LLVMOpaquePassManager *LLVMPassManagerRef;
 
-/** @see llvm::PassRegistry */
-typedef struct LLVMOpaquePassRegistry *LLVMPassRegistryRef;
-
 /**
  * Used to get the users and usees of a Value.
  *
  * @see llvm::Use */
 typedef struct LLVMOpaqueUse *LLVMUseRef;
 
 /**
  * Used to represent an attributes.

llvm/include/llvm/PassRegistry.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_PASSREGISTRY_H
 #define LLVM_PASSREGISTRY_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/Support/CBindingWrapping.h"
 #include "llvm/Support/RWMutex.h"
 #include <memory>
 #include <vector>
 
 namespace llvm {
 
 class PassInfo;
 struct PassRegistrationListener;
public:
   /// to receive passRegistered() callbacks whenever a new pass is registered.
   void addRegistrationListener(PassRegistrationListener *L);
 
   /// removeRegistrationListener - Unregister a PassRegistrationListener so that
   /// it no longer receives passRegistered() callbacks.
   void removeRegistrationListener(PassRegistrationListener *L);
 };
 
-// Create wrappers for C Binding types (see CBindingWrapping.h).
-DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassRegistry, LLVMPassRegistryRef)
-
 } // end namespace llvm
 
 #endif // LLVM_PASSREGISTRY_H

llvm/lib/Analysis/Analysis.cpp

 //===-- Analysis.cpp ------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm-c/Analysis.h"
-#include "llvm-c/Initialization.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/PassRegistry.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstring>
 
 using namespace llvm;
void llvm::initializeAnalysis(PassRegistry &Registry) {
   initializeTargetTransformInfoWrapperPassPass(Registry);
   initializeTypeBasedAAWrapperPassPass(Registry);
   initializeScopedNoAliasAAWrapperPassPass(Registry);
   initializeLCSSAVerificationPassPass(Registry);
   initializeMemorySSAWrapperPassPass(Registry);
   initializeMemorySSAPrinterLegacyPassPass(Registry);
 }
 
-void LLVMInitializeAnalysis(LLVMPassRegistryRef R) {
-  initializeAnalysis(*unwrap(R));
-}
-
-void LLVMInitializeIPA(LLVMPassRegistryRef R) {
-  initializeAnalysis(*unwrap(R));
-}
-
 LLVMBool LLVMVerifyModule(LLVMModuleRef M, LLVMVerifierFailureAction Action,
                           char **OutMessages) {
   raw_ostream *DebugOS = Action != LLVMReturnStatusAction ? &errs() : nullptr;
   std::string Messages;
   raw_string_ostream MsgsOS(Messages);
 
   LLVMBool Result = verifyModule(*unwrap(M), OutMessages ? &MsgsOS : DebugOS);
 

llvm/lib/CodeGen/CodeGen.cpp

 //===-- CodeGen.cpp -------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the common initialization routines for the
 // CodeGen library.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm-c/Initialization.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/PassRegistry.h"
 
 using namespace llvm;
 
 /// initializeCodeGen - Initialize all passes linked into the CodeGen library.
 void llvm::initializeCodeGen(PassRegistry &Registry) {
   initializeAssignmentTrackingAnalysisPass(Registry);
void llvm::initializeCodeGen(PassRegistry &Registry) {
   initializeUnreachableBlockElimLegacyPassPass(Registry);
   initializeUnreachableMachineBlockElimPass(Registry);
   initializeVirtRegMapPass(Registry);
   initializeVirtRegRewriterPass(Registry);
   initializeWasmEHPreparePass(Registry);
   initializeWinEHPreparePass(Registry);
   initializeXRayInstrumentationPass(Registry);
 }
-
-void LLVMInitializeCodeGen(LLVMPassRegistryRef R) {
-  initializeCodeGen(*unwrap(R));
-}

llvm/lib/IR/Core.cpp

 void llvm::initializeCore(PassRegistry &Registry) {
   initializeDominatorTreeWrapperPassPass(Registry);
   initializePrintModulePassWrapperPass(Registry);
   initializePrintFunctionPassWrapperPass(Registry);
   initializeSafepointIRVerifierPass(Registry);
   initializeVerifierLegacyPassPass(Registry);
 }
 
-void LLVMInitializeCore(LLVMPassRegistryRef R) {
-  initializeCore(*unwrap(R));
-}
-
 void LLVMShutdown() {
   llvm_shutdown();
 }
 
 /*===-- Version query -----------------------------------------------------===*/
 
 void LLVMGetVersion(unsigned *Major, unsigned *Minor, unsigned *Patch) {
     if (Major)

 size_t LLVMGetBufferSize(LLVMMemoryBufferRef MemBuf) {
   return unwrap(MemBuf)->getBufferSize();
 }
 
 void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf) {
   delete unwrap(MemBuf);
 }
 
-/*===-- Pass Registry -----------------------------------------------------===*/
-
-LLVMPassRegistryRef LLVMGetGlobalPassRegistry(void) {
-  return wrap(PassRegistry::getPassRegistry());
-}
-
 /*===-- Pass Manager ------------------------------------------------------===*/
 
 LLVMPassManagerRef LLVMCreatePassManager() {
   return wrap(new legacy::PassManager());
 }
 
 LLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M) {
   return wrap(new legacy::FunctionPassManager(unwrap(M)));

llvm/lib/Target/Target.cpp

 //===-- Target.cpp --------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the common infrastructure (including C bindings) for
 // libLLVMTarget.a, which implements target information.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm-c/Target.h"
-#include "llvm-c/Initialization.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Value.h"
 #include "llvm/InitializePasses.h"
 #include <cstring>
 
inline LLVMTargetLibraryInfoRef wrap(const TargetLibraryInfoImpl *P) {
   return reinterpret_cast<LLVMTargetLibraryInfoRef>(X);
 }
 
 void llvm::initializeTarget(PassRegistry &Registry) {
   initializeTargetLibraryInfoWrapperPassPass(Registry);
   initializeTargetTransformInfoWrapperPassPass(Registry);
 }
 
-void LLVMInitializeTarget(LLVMPassRegistryRef R) {
-  initializeTarget(*unwrap(R));
-}
-
 LLVMTargetDataRef LLVMGetModuleDataLayout(LLVMModuleRef M) {
   return wrap(&unwrap(M)->getDataLayout());
 }
 
 void LLVMSetModuleDataLayout(LLVMModuleRef M, LLVMTargetDataRef DL) {
   unwrap(M)->setDataLayout(*unwrap(DL));
 }
 

llvm/lib/Transforms/IPO/IPO.cpp

 //===-- IPO.cpp -----------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the common infrastructure (including C bindings) for
 // libLLVMIPO.a, which implements several transformations over the LLVM
 // intermediate representation.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm-c/Initialization.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/IPO/AlwaysInliner.h"
 #include "llvm/Transforms/IPO/FunctionAttrs.h"
 
 using namespace llvm;
 
 void llvm::initializeIPO(PassRegistry &Registry) {
   initializeDAEPass(Registry);
   initializeDAHPass(Registry);
   initializeAlwaysInlinerLegacyPassPass(Registry);
   initializeLoopExtractorLegacyPassPass(Registry);
   initializeSingleLoopExtractorPass(Registry);
   initializeBarrierNoopPass(Registry);
 }
-
-void LLVMInitializeIPO(LLVMPassRegistryRef R) {
-  initializeIPO(*unwrap(R));
-}

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

 //    5. add X, X is represented as (X*2) => (X << 1)
 //    6. Multiplies with a power-of-two constant argument are transformed into
 //       shifts.
 //   ... etc.
 //
 //===----------------------------------------------------------------------===//
 
 #include "InstCombineInternal.h"
-#include "llvm-c/Initialization.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/AssumptionCache.h"

 INITIALIZE_PASS_END(InstructionCombiningPass, "instcombine",
                     "Combine redundant instructions", false, false)
 
 // Initialization Routines
 void llvm::initializeInstCombine(PassRegistry &Registry) {
   initializeInstructionCombiningPassPass(Registry);
 }
 
-void LLVMInitializeInstCombine(LLVMPassRegistryRef R) {
-  initializeInstructionCombiningPassPass(*unwrap(R));
-}
-
 FunctionPass *llvm::createInstructionCombiningPass() {
   return new InstructionCombiningPass();
 }
 
 FunctionPass *llvm::createInstructionCombiningPass(unsigned MaxIterations) {
   return new InstructionCombiningPass(MaxIterations);
 }

llvm/lib/Transforms/Instrumentation/Instrumentation.cpp

 //===-- Instrumentation.cpp - TransformUtils Infrastructure ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the common initialization infrastructure for the
 // Instrumentation library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/Instrumentation.h"
-#include "llvm-c/Initialization.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
-#include "llvm/InitializePasses.h"
-#include "llvm/PassRegistry.h"
 #include "llvm/TargetParser/Triple.h"
 
 using namespace llvm;
 
 /// Moves I before IP. Returns new insert point.
 static BasicBlock::iterator moveBeforeInsertPoint(BasicBlock::iterator I, BasicBlock::iterator IP) {
   // If I is IP, move the insert point down.
   if (I == IP) {

llvm/lib/Transforms/Scalar/Scalar.cpp

 //===-- Scalar.cpp --------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements common infrastructure for libLLVMScalarOpts.a, which
 // implements several scalar transformations over the LLVM intermediate
 // representation, including the C bindings for that library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/Scalar.h"
-#include "llvm-c/Initialization.h"
 #include "llvm/Analysis/BasicAliasAnalysis.h"
 #include "llvm/Analysis/ScopedNoAliasAA.h"
 #include "llvm/Analysis/TypeBasedAliasAnalysis.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Transforms/Scalar/GVN.h"
 #include "llvm/Transforms/Scalar/Scalarizer.h"
 #include "llvm/Transforms/Utils/UnifyFunctionExitNodes.h"
void llvm::initializeScalarOpts(PassRegistry &Registry) {
   initializeTLSVariableHoistLegacyPassPass(Registry);
   initializeSeparateConstOffsetFromGEPLegacyPassPass(Registry);
   initializeSpeculativeExecutionLegacyPassPass(Registry);
   initializeStraightLineStrengthReduceLegacyPassPass(Registry);
   initializePlaceBackedgeSafepointsLegacyPassPass(Registry);
   initializePlaceSafepointsLegacyPassPass(Registry);
   initializeLoopSimplifyCFGLegacyPassPass(Registry);
 }
-
-void LLVMInitializeScalarOpts(LLVMPassRegistryRef R) {
-  initializeScalarOpts(*unwrap(R));
-}

llvm/lib/Transforms/Utils/Utils.cpp

 //===-- Utils.cpp - TransformUtils Infrastructure -------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the common initialization infrastructure for the
 // TransformUtils library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/Utils.h"
-#include "llvm-c/Initialization.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
 #include "llvm/PassRegistry.h"
 
 using namespace llvm;
 
 /// initializeTransformUtils - Initialize all passes in the TransformUtils
 /// library.
void llvm::initializeTransformUtils(PassRegistry &Registry) {
   initializeUnifyFunctionExitNodesLegacyPassPass(Registry);
   initializeMetaRenamerPass(Registry);
   initializeStripGCRelocatesLegacyPass(Registry);
   initializePredicateInfoPrinterLegacyPassPass(Registry);
   initializeInjectTLIMappingsLegacyPass(Registry);
   initializeFixIrreduciblePass(Registry);
   initializeUnifyLoopExitsLegacyPassPass(Registry);
 }
-
-/// LLVMInitializeTransformUtils - C binding for initializeTransformUtilsPasses.
-void LLVMInitializeTransformUtils(LLVMPassRegistryRef R) {
-  initializeTransformUtils(*unwrap(R));
-}

llvm/lib/Transforms/Vectorize/Vectorize.cpp

 //===-- Vectorize.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements common infrastructure for libLLVMVectorizeOpts.a, which
 // implements several vectorization transformations over the LLVM intermediate
 // representation, including the C bindings for that library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/Vectorize.h"
-#include "llvm-c/Initialization.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/PassRegistry.h"
 
 using namespace llvm;
 
 /// Initialize all passes linked into the Vectorization library.
 void llvm::initializeVectorization(PassRegistry &Registry) {
   initializeLoadStoreVectorizerLegacyPassPass(Registry);
 }
-
-void LLVMInitializeVectorization(LLVMPassRegistryRef R) {
-  initializeVectorization(*unwrap(R));
-}

llvm/tools/llvm-c-test/include-all.c

 #include "llvm-c/Core.h"
 #include "llvm-c/DataTypes.h"
 #include "llvm-c/DebugInfo.h"
 #include "llvm-c/Disassembler.h"
 #include "llvm-c/DisassemblerTypes.h"
 #include "llvm-c/Error.h"
 #include "llvm-c/ErrorHandling.h"
 #include "llvm-c/ExecutionEngine.h"
-#include "llvm-c/Initialization.h"
 #include "llvm-c/IRReader.h"
 #include "llvm-c/Linker.h"
 #include "llvm-c/Object.h"
 #include "llvm-c/Orc.h"
 #include "llvm-c/Remarks.h"
 #include "llvm-c/Support.h"
 #include "llvm-c/Target.h"
 #include "llvm-c/TargetMachine.h"
 #include "llvm-c/Transforms/PassBuilder.h"
 #include "llvm-c/Types.h"
 #include "llvm-c/lto.h"

llvm/tools/llvm-c-test/main.c

static void print_usage(void) {
   fprintf(stderr,
           "    Read bitcode file from stdin with a diagnostic handler set\n\n");
   fprintf(stderr, "  * --test-dibuilder\n");
   fprintf(stderr,
           "    Run tests for the DIBuilder C API - print generated module\n\n");
 }
 
 int main(int argc, char **argv) {
-  LLVMPassRegistryRef pr = LLVMGetGlobalPassRegistry();
-
-  LLVMInitializeCore(pr);
-
   if (argc == 2 && !strcmp(argv[1], "--lazy-new-module-dump")) {
     return llvm_module_dump(true, true);
   } else if (argc == 2 && !strcmp(argv[1], "--new-module-dump")) {
     return llvm_module_dump(false, true);
   } else if (argc == 2 && !strcmp(argv[1], "--lazy-module-dump")) {
     return llvm_module_dump(true, false);
   } else if (argc == 2 && !strcmp(argv[1], "--module-dump")) {
     return llvm_module_dump(false, false);