From e6be5e4266d802a17cf57f262033c3df9ed31708 Mon Sep 17 00:00:00 2001
From: Igor Chevdar <igor.chevdar@jetbrains.com>
Date: Thu, 26 Aug 2021 19:35:52 +0500
Subject: [PATCH] [K/N][codegen][runtime] Removed remnants of main thread init
 logic

---
 .../kotlin/backend/konan/llvm/IrToBitcode.kt      |  5 ++---
 .../konan/lower/FileInitializersLowering.kt       |  3 +--
 kotlin-native/runtime/src/main/cpp/Runtime.cpp    | 15 ++++++---------
 kotlin-native/runtime/src/main/cpp/Runtime.h      |  4 ++--
 4 files changed, 11 insertions(+), 16 deletions(-)

diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt
index d19173b2002..9c76fefc44d 100644
--- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt
+++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt
@@ -387,7 +387,6 @@ internal class CodeGeneratorVisitor(val context: Context, val lifetimes: Map<IrE
                     val parameterScope = ParameterScope(fileInitFunction, functionGenerationContext)
                     using(parameterScope) usingParameterScope@{
                         using(VariableScope()) usingVariableScope@{
-                            // TODO: remove unused parameter.
                             context.llvm.initializersGenerationState.topLevelFields
                                     .filter { it.storageKind == FieldStorageKind.THREAD_LOCAL }
                                     .filterNot { it.shouldBeInitializedEagerly }
@@ -789,7 +788,7 @@ internal class CodeGeneratorVisitor(val context: Context, val lifetimes: Map<IrE
         if (declaration.origin == DECLARATION_ORIGIN_FILE_GLOBAL_INITIALIZER) {
             require(context.llvm.initializersGenerationState.globalInitFunction == null) { "There can only be at most one global file initializer" }
             require(body == null) { "The body of file initializer should be null" }
-            require(declaration.valueParameters.singleOrNull()?.type == context.irBuiltIns.booleanType) { "File initializer must take a single boolean parameter" }
+            require(declaration.valueParameters.isEmpty()) { "File initializer must be parameterless" }
             require(declaration.returnsUnit()) { "File initializer must return Unit" }
             context.llvm.initializersGenerationState.globalInitFunction = declaration
             context.llvm.initializersGenerationState.globalInitState = getGlobalInitStateFor(declaration.parent as IrFile)
@@ -798,7 +797,7 @@ internal class CodeGeneratorVisitor(val context: Context, val lifetimes: Map<IrE
                 || declaration.origin == DECLARATION_ORIGIN_FILE_STANDALONE_THREAD_LOCAL_INITIALIZER) {
             require(context.llvm.initializersGenerationState.threadLocalInitFunction == null) { "There can only be at most one thread local file initializer" }
             require(body == null) { "The body of file initializer should be null" }
-            require(declaration.valueParameters.singleOrNull()?.type == context.irBuiltIns.booleanType) { "File initializer must take a single boolean parameter" }
+            require(declaration.valueParameters.isEmpty()) { "File initializer must be parameterless" }
             require(declaration.returnsUnit()) { "File initializer must return Unit" }
             context.llvm.initializersGenerationState.threadLocalInitFunction = declaration
             context.llvm.initializersGenerationState.threadLocalInitState = getThreadLocalInitStateFor(declaration.parent as IrFile)
diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/FileInitializersLowering.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/FileInitializersLowering.kt
index 7aef70911c4..055ec120bf2 100644
--- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/FileInitializersLowering.kt
+++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/FileInitializersLowering.kt
@@ -41,7 +41,7 @@ internal val IrFunction.isFileInitializer: Boolean
             || origin == DECLARATION_ORIGIN_FILE_STANDALONE_THREAD_LOCAL_INITIALIZER
 
 internal fun IrBuilderWithScope.irCallFileInitializer(initializer: IrFunctionSymbol) =
-        irCall(initializer).apply { putValueArgument(0, irFalse()) }
+        irCall(initializer)
 
 internal val IrField.shouldBeInitializedEagerly: Boolean
     get() {
@@ -106,7 +106,6 @@ internal class FileInitializersLowering(val context: Context) : FileLoweringPass
         returnType = context.irBuiltIns.unitType
     }.apply {
         parent = irFile
-        addValueParameter("isMainThread", context.irBuiltIns.booleanType)
         irFile.declarations.add(0, this)
     }
 
diff --git a/kotlin-native/runtime/src/main/cpp/Runtime.cpp b/kotlin-native/runtime/src/main/cpp/Runtime.cpp
index e06bc442d29..365fac3d966 100644
--- a/kotlin-native/runtime/src/main/cpp/Runtime.cpp
+++ b/kotlin-native/runtime/src/main/cpp/Runtime.cpp
@@ -73,8 +73,6 @@ constexpr RuntimeState* kInvalidRuntime = nullptr;
 
 THREAD_LOCAL_VARIABLE RuntimeState* runtimeState = kInvalidRuntime;
 
-volatile int mainThreadId = 0;
-
 inline bool isValidRuntime() {
   return ::runtimeState != kInvalidRuntime;
 }
@@ -137,7 +135,6 @@ RuntimeState* initRuntime() {
   CommitTLSStorage(result->memoryState);
   // Keep global variables in state as well.
   if (firstRuntime) {
-    mainThreadId = konan::currentThreadId();
     konan::consoleInit();
 #if KONAN_OBJC_INTEROP
     Kotlin_ObjCExport_initialize();
@@ -418,7 +415,7 @@ static constexpr int FILE_BEING_INITIALIZED = 1;
 static constexpr int FILE_INITIALIZED = 2;
 static constexpr int FILE_FAILED_TO_INITIALIZE = 3;
 
-void CallInitGlobalPossiblyLock(int volatile* state, void (*init)(bool)) {
+void CallInitGlobalPossiblyLock(int volatile* state, void (*init)()) {
     int localState = *state;
     if (localState == FILE_INITIALIZED) return;
     if (localState == FILE_FAILED_TO_INITIALIZE)
@@ -437,10 +434,10 @@ void CallInitGlobalPossiblyLock(int volatile* state, void (*init)(bool)) {
     if (compareAndSwap(state, FILE_NOT_INITIALIZED, FILE_BEING_INITIALIZED | (threadId << 2)) == FILE_NOT_INITIALIZED) {
         // actual initialization
 #if KONAN_NO_EXCEPTIONS
-        init(threadId == mainThreadId);
+        init();
 #else
         try {
-            init(threadId == mainThreadId);
+            init();
         } catch (...) {
             *state = FILE_FAILED_TO_INITIALIZE;
             throw;
@@ -456,15 +453,15 @@ void CallInitGlobalPossiblyLock(int volatile* state, void (*init)(bool)) {
     }
 }
 
-void CallInitThreadLocal(int volatile* globalState, int* localState, void (*init)(bool)) {
+void CallInitThreadLocal(int volatile* globalState, int* localState, void (*init)()) {
     if (*localState == FILE_FAILED_TO_INITIALIZE || (globalState != nullptr && *globalState == FILE_FAILED_TO_INITIALIZE))
         ThrowFileFailedToInitializeException();
     *localState = FILE_INITIALIZED;
 #if KONAN_NO_EXCEPTIONS
-    init(konan::currentThreadId() == mainThreadId);
+    init();
 #else
     try {
-        init(konan::currentThreadId() == mainThreadId);
+        init();
     } catch(...) {
         *localState = FILE_FAILED_TO_INITIALIZE;
         throw;
diff --git a/kotlin-native/runtime/src/main/cpp/Runtime.h b/kotlin-native/runtime/src/main/cpp/Runtime.h
index f14a7eded01..835bf24b16c 100644
--- a/kotlin-native/runtime/src/main/cpp/Runtime.h
+++ b/kotlin-native/runtime/src/main/cpp/Runtime.h
@@ -38,8 +38,8 @@ void Kotlin_shutdownRuntime();
 // Appends given node to an initializer list.
 void AppendToInitializersTail(struct InitNode*);
 
-void CallInitGlobalPossiblyLock(int volatile* state, void (*init)(bool));
-void CallInitThreadLocal(int volatile* globalState, int* localState, void (*init)(bool));
+void CallInitGlobalPossiblyLock(int volatile* state, void (*init)());
+void CallInitThreadLocal(int volatile* globalState, int* localState, void (*init)());
 
 bool Kotlin_memoryLeakCheckerEnabled();