[K/N] Use custom LLVMKotlinRunPasses instead of LLVMRunPasses

In order to instrument the passes being run, llvm PassBuilder
needs to be configured manually, the existing C API of LLVMRunPasses
is not enough.

This commit:
- creates LLVMKotlinRunPasses that does the same thing as
  LLVMRunPasses
- modifies libllvmext compiler flags to use what llvm uses for release
  builds

^KT-79381

Author: projedi

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/OptimizationPipeline.kt

@@ -212,43 +212,37 @@ abstract class LlvmOptimizationPipeline(
     private val targetMachine: LLVMTargetMachineRef by targetMachineDelegate
 
     fun execute(llvmModule: LLVMModuleRef) {
-        val options: LLVMPassBuilderOptionsRef = LLVMCreatePassBuilderOptions()!!
-        try {
-            initLLVMOnce()
-            config.inlineThreshold?.let { threshold ->
-                if (threshold >= 0) {
-                    LLVMPassBuilderOptionsSetInlinerThreshold(options, threshold)
-                }
-            }
-            LLVMPassBuilderOptionsSetMaxDevirtIterations(options, 0)
-            if (config.timePasses) {
-                LLVMSetTimePasses(1)
-            }
-            executeCustomPreprocessing(config, llvmModule)
-            val passDescription = passes.joinToString(",")
-            logger?.log {
-                """
-                    Running ${pipelineName} with the following parameters:
-                    target_triple: ${config.targetTriple}
-                    cpu_model: ${config.cpuModel}
-                    cpu_features: ${config.cpuFeatures}
-                    optimization_level: ${config.optimizationLevel.value}
-                    size_level: ${config.sizeLevel.value}
-                    inline_threshold: ${config.inlineThreshold ?: "default"}
-                    passes: ${passDescription}
-                """.trimIndent()
-            }
-            if (passDescription.isEmpty()) return
-            val errorCode = LLVMRunPasses(llvmModule, passDescription, targetMachine, options)
-            require(errorCode == null) {
-                LLVMGetErrorMessage(errorCode)!!.toKString()
-            }
-            if (config.timePasses) {
-                LLVMPrintAllTimersToStdOut()
-                LLVMClearAllTimers()
-            }
-        } finally {
-            LLVMDisposePassBuilderOptions(options)
+        initLLVMOnce()
+        if (config.timePasses) {
+            LLVMSetTimePasses(1)
+        }
+        executeCustomPreprocessing(config, llvmModule)
+        val passDescription = passes.joinToString(",")
+        logger?.log {
+            """
+                Running ${pipelineName} with the following parameters:
+                target_triple: ${config.targetTriple}
+                cpu_model: ${config.cpuModel}
+                cpu_features: ${config.cpuFeatures}
+                optimization_level: ${config.optimizationLevel.value}
+                size_level: ${config.sizeLevel.value}
+                inline_threshold: ${config.inlineThreshold ?: "default"}
+                passes: ${passDescription}
+            """.trimIndent()
+        }
+        if (passDescription.isEmpty()) return
+        val errorCode = LLVMKotlinRunPasses(
+                llvmModule,
+                passDescription,
+                targetMachine,
+                InlinerThreshold = config.inlineThreshold ?: -1,
+        )
+        require(errorCode == null) {
+            LLVMGetErrorMessage(errorCode)!!.toKString()
+        }
+        if (config.timePasses) {
+            LLVMPrintAllTimersToStdOut()
+            LLVMClearAllTimers()
         }
     }
 

kotlin-native/libllvmext/build.gradle.kts

@@ -34,7 +34,16 @@ val library = lib("llvmext")
 native {
     val obj = if (HostManager.hostIsMingw) "obj" else "o"
     val cxxflags = mutableListOf(
-        "--std=c++17",
+        // Using the same flags as the release llvm build.
+        // But only keep -Wall diagnostics.
+        "-Wall",
+        "-O3",
+        "-DNDEBUG",
+        "-std=c++17",
+        "-fno-exceptions",
+        "-funwind-tables",
+        "-fno-rtti",
+        "-Werror", // fail on any warning, or we won't ever catch them
         "-I${llvmDir}/include",
         "-Isrc/main/include"
     )
@@ -43,7 +52,10 @@ native {
             cxxflags.addAll(listOf("-DKONAN_LINUX=1"))
         }
         MINGW -> {
-            cxxflags += "-DKONAN_WINDOWS=1"
+            cxxflags += listOf(
+                "-DKONAN_WINDOWS=1",
+                "-Wno-unused-command-line-argument",
+            )
         }
         OSX -> {
             cxxflags += "-DKONAN_MACOS=1"

kotlin-native/libllvmext/src/main/cpp/CAPIExtensions.cpp

@@ -3,18 +3,22 @@
 //
 
 #include <CAPIExtensions.h>
-#include <llvm/ProfileData/Coverage/CoverageMapping.h>
-#include <llvm/Analysis/TargetLibraryInfo.h>
-#include <llvm/IR/Constants.h>
-#include <llvm/IR/Instructions.h>
-#include <llvm/IR/LegacyPassManager.h>
-#include <llvm/Transforms/ObjCARC.h>
-#include <llvm/Transforms/Utils/Cloning.h>
-#include <llvm/Transforms/Instrumentation/ThreadSanitizer.h>
+#include <llvm/IR/Module.h>
+#include <llvm/Passes/PassBuilder.h>
+#include <llvm/Passes/StandardInstrumentations.h>
 #include <llvm/Support/Timer.h>
+#include <llvm/Transforms/Utils/Cloning.h>
 
 using namespace llvm;
 
+namespace {
+
+TargetMachine *unwrap(LLVMTargetMachineRef P) {
+    return reinterpret_cast<TargetMachine *>(P);
+}
+
+}
+
 void LLVMKotlinInitializeTargets() {
 #define INIT_LLVM_TARGET(TargetName) \
     LLVMInitialize##TargetName##TargetInfo();\
@@ -47,4 +51,40 @@ void LLVMPrintAllTimersToStdOut() {
 
 void LLVMClearAllTimers() {
     llvm::TimerGroup::clearAll();
+}
+
+extern "C" LLVMErrorRef LLVMKotlinRunPasses(
+        LLVMModuleRef M,
+        const char *Passes,
+        LLVMTargetMachineRef TM,
+        int InlinerThreshold
+) {
+    TargetMachine *Machine = unwrap(TM);
+    Module *Mod = unwrap(M);
+
+    PipelineTuningOptions PTO;
+    PTO.InlinerThreshold = InlinerThreshold;
+    PTO.MaxDevirtIterations = 0;
+    PassInstrumentationCallbacks PIC;
+    PassBuilder PB(Machine, PTO, std::nullopt, &PIC);
+
+    LoopAnalysisManager LAM;
+    FunctionAnalysisManager FAM;
+    CGSCCAnalysisManager CGAM;
+    ModuleAnalysisManager MAM;
+    PB.registerLoopAnalyses(LAM);
+    PB.registerFunctionAnalyses(FAM);
+    PB.registerCGSCCAnalyses(CGAM);
+    PB.registerModuleAnalyses(MAM);
+    PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+
+    StandardInstrumentations SI(Mod->getContext(), false, false);
+    SI.registerCallbacks(PIC, &MAM);
+
+    ModulePassManager MPM;
+    if (auto Err = PB.parsePassPipeline(MPM, Passes))
+        return wrap(std::move(Err));
+    MPM.run(*Mod, MAM);
+
+    return LLVMErrorSuccess;
 }

kotlin-native/libllvmext/src/main/include/CAPIExtensions.h

@@ -6,8 +6,10 @@
 #define LIBLLVMEXT_EXTENSIONS_H
 
 #include <llvm-c/Core.h>
+#include <llvm-c/Error.h>
 #include <llvm-c/Target.h>
-
+#include <llvm-c/TargetMachine.h>
+#include <llvm-c/Transforms/PassBuilder.h>
 
 # ifdef __cplusplus
 extern "C" {
@@ -28,6 +30,14 @@ void LLVMPrintAllTimersToStdOut(void);
 /// Clear all LLVM timers. Allows avoiding automatic printing on shutdown
 void LLVMClearAllTimers(void);
 
+/// Run `Passes` on module `M`.
+LLVMErrorRef LLVMKotlinRunPasses(
+        LLVMModuleRef M,
+        const char *Passes,
+        LLVMTargetMachineRef TM,
+        int InlinerThreshold
+);
+
 # ifdef __cplusplus
 }
 # endif