[K/N] Expose program name in runtime

kotlin-native/runtime/src/launcher/cpp/launcher.cpp

@@ -30,8 +30,12 @@ using namespace kotlin;
 //--- Setup args --------------------------------------------------------------//
 
 OBJ_GETTER(setupArgs, int argc, const char** argv) {
+ if (argc > 0) {
+ kotlin::programName = argv[0];
+ }
+
  // The count is one less, because we skip argv[0] which is the binary name.
- ObjHeader* result = AllocArrayInstance(theArrayTypeInfo, argc - 1, OBJ_RESULT);
+ ObjHeader* result = AllocArrayInstance(theArrayTypeInfo, std::max(0, argc - 1), OBJ_RESULT);
  ArrayHeader* array = result->array();
  for (int index = 1; index < argc; index++) {
  ObjHolder result;
@@ -58,6 +62,8 @@ extern "C" RUNTIME_USED int Init_and_run_start(int argc, const char** argv, int
  Kotlin_shutdownRuntime();
  }
 
+ kotlin::programName = nullptr; // argv[0] might not be valid after this point
+
  return exitStatus;
 }
 

kotlin-native/runtime/src/main/cpp/Runtime.cpp

@@ -176,6 +176,8 @@ bool kotlin::initializeGlobalRuntimeIfNeeded() noexcept {
  return true;
 }
 
+const char* kotlin::programName = nullptr;
+
 extern "C" {
 
 RUNTIME_NOTHROW void AppendToInitializersTail(InitNode *next) {
@@ -335,6 +337,15 @@ KBoolean Konan_Platform_isFreezingEnabled() {
  return kotlin::compiler::freezingChecksEnabled();
 }
 
+OBJ_GETTER0(Konan_Platform_getProgramName) {
+ if (kotlin::programName == nullptr) {
+ // null in case Platform.getProgramName is called from within a library and the main function of the binary is not built with Kotlin
+ RETURN_OBJ(nullptr)
+ } else {
+ RETURN_RESULT_OF(CreateStringFromCString, kotlin::programName)
+ }
+}
+
 bool Kotlin_memoryLeakCheckerEnabled() {
  return g_checkLeaks;
 }

kotlin-native/runtime/src/main/cpp/Runtime.h

@@ -8,6 +8,7 @@
 
 #include "Porting.h"
 #include "Memory.h"
+#include "KString.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -50,6 +51,8 @@ namespace kotlin {
 // Returns `true` if initialized.
 bool initializeGlobalRuntimeIfNeeded() noexcept;
 
+extern const char* programName;
+
 }
 
 #endif // RUNTIME_RUNTIME_H

kotlin-native/runtime/src/main/kotlin/kotlin/native/Platform.kt

@@ -101,6 +101,13 @@ public object Platform {
  public val isFreezingEnabled: Boolean
  get() = Platform_isFreezingEnabled()
 
+ /**
+ * Representation of the name used to invoke the program executable.
+ * [null] if the Kotlin code was compiled to a native library and the executable is not a Kotlin program.
+ */
+ public val programName: String?
+ get() = Platform_getProgramName()
+
  /**
  * If the memory leak checker is activated, by default `true` in debug mode, `false` in release.
  * When memory leak checker is activated, and leak is detected during last Kotlin context
@@ -161,6 +168,9 @@ private external fun Platform_isDebugBinary(): Boolean
 @GCUnsafeCall("Konan_Platform_isFreezingEnabled")
 private external fun Platform_isFreezingEnabled(): Boolean
 
+@GCUnsafeCall("Konan_Platform_getProgramName")
+private external fun Platform_getProgramName(): String?
+
 @GCUnsafeCall("Konan_Platform_getMemoryLeakChecker")
 private external fun Platform_getMemoryLeakChecker(): Boolean
 

native/native.tests/build.gradle.kts

@@ -51,6 +51,7 @@ val stdlibK2Test = nativeTest("stdlibK2Test", "stdlib & frontend-fir")
 val kotlinTestLibraryTest = nativeTest("kotlinTestLibraryTest", "kotlin-test & !frontend-fir")
 val kotlinTestLibraryK2Test = nativeTest("kotlinTestLibraryK2Test", "kotlin-test & frontend-fir")
 val partialLinkageTest = nativeTest("partialLinkageTest", "partial-linkage")
+val programNameTest = nativeTest("programNameTest", "program-name")
 val cinteropTest = nativeTest("cinteropTest", "cinterop")
 val debuggerTest = nativeTest("debuggerTest", "debugger")
 val cachesTest = nativeTest("cachesTest", "caches")

native/native.tests/testData/CExport/InterfaceV1/programName/main.c

@@ -0,0 +1,7 @@
+#include <stdio.h>
+#include "programName_api.h"
+
+int main() {
+ programName();
+ fflush(NULL);
+}

native/native.tests/testData/CExport/InterfaceV1/programName/programNameLib-main.out

@@ -0,0 +1 @@
+Platform.programName is null within library

native/native.tests/testData/CExport/InterfaceV1/programName/programNameLib.kt

@@ -0,0 +1,6 @@
+@file:OptIn(kotlin.experimental.ExperimentalNativeApi::class)
+
+@CName("programName")
+fun programName() {
+ println("Platform.programName is " + Platform.programName + " within library")
+}

native/native.tests/testData/programName/kotlinPrintEntryPoint.kt

@@ -0,0 +1,11 @@
+@file:OptIn(kotlin.experimental.ExperimentalNativeApi::class)
+
+import kotlin.native.Platform
+
+fun main(args: Array<String>) {
+ // Remove path and extension (.kexe or .exe)
+ val programFileName = Platform.programName?.substringAfterLast("/")?.substringBeforeLast(".")
+
+ println("programName: $programFileName")
+ println("args: ${args.joinToString()}")
+}

native/native.tests/testData/programName/main.c

@@ -0,0 +1,14 @@
+#include <stdio.h>
+#include <unistd.h>
+
+int main(int argc, char *argv[]) {
+ printf("calling exec...\n");
+ fflush(NULL);
+
+ // Kotlin executable name is in argv[1]
+ // Forward argv[2..n] to kotlin executable as arguments (the first one should be the programName according to posix)
+ execv(argv[1], &(argv[2]));
+
+ printf("exec failed\n");
+ return 0;
+}

native/native.tests/testData/standalone/entryPoint/programName.kt

@@ -0,0 +1,11 @@
+@file:OptIn(kotlin.experimental.ExperimentalNativeApi::class)
+
+import kotlin.native.Platform
+import kotlin.test.*
+
+fun main(args: Array<String>) {
+ // Remove path and extension (.kexe or .exe)
+ val programFileName = Platform.programName!!.substringAfterLast("/").substringBeforeLast(".")
+
+ assertEquals("standalone_entryPoint_programName", programFileName)
+}

native/native.tests/tests/org/jetbrains/kotlin/konan/test/blackbox/ProgramNameTest.kt

@@ -0,0 +1,66 @@
+package org.jetbrains.kotlin.konan.test.blackbox
+
+import org.jetbrains.kotlin.konan.test.blackbox.support.*
+import org.jetbrains.kotlin.konan.test.blackbox.support.compilation.TestCompilationResult.Companion.assertSuccess
+import org.jetbrains.kotlin.konan.test.blackbox.support.util.ClangDistribution
+import org.jetbrains.kotlin.konan.test.blackbox.support.util.compileWithClang
+import org.jetbrains.kotlin.native.executors.runProcess
+import org.junit.jupiter.api.Tag
+import org.junit.jupiter.api.Test
+import java.io.File
+import kotlin.test.assertEquals
+import kotlin.time.Duration.Companion.seconds
+
+@Tag("program-name")
+class ProgramNameTest : AbstractNativeSimpleTest() {
+
+ @Test
+ fun programNameTest() {
+ // 1. Compile main.c to main.cexe
+
+ val cExecutable = buildDir.resolve("main.cexe")
+ compileWithClang(
+ clangDistribution = ClangDistribution.Llvm,
+ sourceFiles = listOf(sourceDir.resolve("main.c")),
+ outputFile = cExecutable,
+ additionalClangFlags = listOf("-Wall", "-Werror"),
+ ).assertSuccess()
+
+ // 2. Compile kotlinPrintEntryPoint.kt to kotlinPrintEntryPoint.kexe
+
+ val kotlinCompilation = compileToExecutableInOneStage(
+ generateTestCaseWithSingleFile(
+ sourceFile = sourceDir.resolve("kotlinPrintEntryPoint.kt"),
+ testKind = TestKind.STANDALONE_NO_TR,
+ extras = TestCase.NoTestRunnerExtras("main")
+ )
+ ).assertSuccess()
+
+ // 3. run main.cexe (with different parameters) to call kotlin executable
+
+ fun validate(expected: String, vararg args: String) {
+ val binaryName = kotlinCompilation.resultingArtifact.executableFile.path
+ val result = runProcess(cExecutable.absolutePath, binaryName, *args) {
+ timeout = 60.seconds
+ }
+ assertEquals("calling exec...\n$expected", result.stdout)
+ assertEquals("", result.stderr)
+ }
+
+ // kotlinPrintEntryPoint removes .kexe
+ validate("programName: app\nargs:", "app.kexe")
+
+ // Simulate a custom program name, see e.g. https://busybox.net/downloads/BusyBox.html#usage
+ validate("programName: customProgramName\nargs:", "customProgramName")
+ validate("programName: customProgramName\nargs: firstArg, secondArg", "customProgramName", "firstArg", "secondArg")
+
+ // No program name - this would not be POSIX compliant, see https://pubs.opengroup.org/onlinepubs/9699919799/functions/exec.html:
+ // "[...] requires a Strictly Conforming POSIX Application to pass at least one argument to the exec function"
+ // However, we should not crash the Kotlin runtime because of this.
+ validate("programName: null\nargs:")
+ }
+
+ companion object {
+ private val sourceDir = File("native/native.tests/testData/programName")
+ }
+}