[stage][link][debug] always produce code with debug info.

backend.native/build.gradle

@@ -152,23 +152,27 @@ task start(dependsOn: "${host}Start")
 // -runtime, -properties, -library and -Djava.library.path
 
 targetList.each { target ->
+    def konanJvmArgs = ["-ea",
+    "-Dkonan.home=${project.parent.file('dist')}",
+    "-Djava.library.path=${project.buildDir}/nativelibs",
+    "-Dfile.encoding=UTF-8"]
+
+    def konanArgs = ['-nopack', '-nostdlib','-ea', '-g',
+                     '-target', target,
+                     '-runtime', project(':runtime').file("build/${target}/runtime.bc"),
+                     '-properties', rootProject.konanPropertiesFile.canonicalPath,
+                     *project.globalBuildArgs]
+
     task("${target}Stdlib", type: JavaExec) {
         main = 'org.jetbrains.kotlin.cli.bc.K2NativeKt'
         classpath = project.configurations.cli_bc
-        jvmArgs "-ea", 
+        jvmArgs.addAll(konanJvmArgs)
-            "-Dkonan.home=${project.parent.file('dist')}",
+        args = [*konanArgs,
-            "-Djava.library.path=${project.buildDir}/nativelibs",
+                '-output', project(':runtime').file("build/${target}Stdlib"),
-            "-Dfile.encoding=UTF-8"
+                '-produce', 'library',
-        args('-output', project(':runtime').file("build/${target}Stdlib"),
+                project(':Interop:Runtime').file('src/main/kotlin'),
-            '-nopack', '-nostdlib','-ea',
+                project(':Interop:Runtime').file('src/native/kotlin'),
-            '-produce', 'library', '-target', target,
+                project(':runtime').file('src/main/kotlin')]
-            '-runtime', project(':runtime').file("build/${target}/runtime.bc"),
-            '-properties', project(':backend.native').file('konan.properties'),
-        project(':runtime').file('src/main/kotlin'), 
-        project(':Interop:Runtime').file('src/main/kotlin'),
-        project(':Interop:Runtime').file('src/native/kotlin'),
-        *project.globalBuildArgs)
-
         inputs.dir(project(':runtime').file('src/main/kotlin'))
         inputs.dir(project(':Interop:Runtime').file('src/main/kotlin'))
         inputs.dir(project(':Interop:Runtime').file('src/native/kotlin'))
@@ -176,23 +180,15 @@ targetList.each { target ->
 
         dependsOn ":runtime:${target}Runtime"
     }
-}
 
-targetList.each { target ->
     task("${target}Start", type: JavaExec) {
         main = 'org.jetbrains.kotlin.cli.bc.K2NativeKt'
         classpath = project.configurations.cli_bc
-        jvmArgs "-ea", 
+        jvmArgs(*jvmArgs)
-            "-Dkonan.home=${project.parent.file('dist')}",
+        args = [*konanArgs, '-produce', 'bitcode',
-            "-Djava.library.path=${project.buildDir}/nativelibs"
+                '-output', project(':runtime').file("build/${target}Start"),
-        args('-output', project(':runtime').file("build/${target}Start"), 
+                '-library', project(':runtime').file("build/${target}Stdlib"),
-            '-nopack', '-nostdlib', '-ea',
+                project(':runtime').file('src/launcher/kotlin')]
-            '-produce', 'bitcode', '-target', target,
-            '-library', project(':runtime').file("build/${target}Stdlib"),
-            '-runtime', project(':runtime').file("build/${target}/runtime.bc"),
-            '-properties', rootProject.konanPropertiesFile.canonicalPath,
-        project(':runtime').file('src/launcher/kotlin'), 
-        *project.globalBuildArgs)
 
         inputs.dir(project(':runtime').file('src/launcher/kotlin'))
         outputs.file(project(':runtime').file("build/${target}Start"))

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

@@ -44,11 +44,13 @@ internal abstract class PlatformFlags(val distribution: Distribution) {
         = propertyTargetList("linkerOptimizationFlags")
     open val linkerKonanFlags 
         = propertyTargetList("linkerKonanFlags")
+    open val linkerDebugFlags
+            = propertyTargetList("linkerDebugFlags")
 
     open val useCompilerDriverAsLinker: Boolean get() = false // TODO: refactor.
 
    abstract fun linkCommand(objectFiles: List<ObjectFile>,
-        executable: ExecutableFile, optimize: Boolean): List<String>
+        executable: ExecutableFile, optimize: Boolean, debug: Boolean): List<String>
 
     open fun linkCommandSuffix(): List<String> = emptyList()
 
@@ -71,11 +73,17 @@ internal open class AndroidPlatform(distribution: Distribution)
 
     override val useCompilerDriverAsLinker: Boolean get() = true
 
-    override fun linkCommand(objectFiles: List<String>, executable: String, optimize: Boolean): List<String> {
+    override fun linkCommand(objectFiles: List<ObjectFile>, executable: ExecutableFile, optimize: Boolean, debug: Boolean): List<String> {
-        return mutableListOf<String>(clang, "-o", executable, "-fPIC", "-shared") +
+        return mutableListOf(clang).apply{
-                    objectFiles +
+            add("-o")
-                    (if (optimize) linkerOptimizationFlags else emptyList()) +
+            add(executable)
-                linkerKonanFlags
+            add("-fPIC")
+            add("-shared")
+            addAll(objectFiles)
+            if (optimize) addAll(linkerOptimizationFlags)
+            if (!debug) addAll(linkerDebugFlags)
+            addAll(linkerKonanFlags)
+        }
     }
 }
 
@@ -92,15 +100,19 @@ internal open class MacOSBasedPlatform(distribution: Distribution)
                 propertyTargetString("osVersionMin") + ".0")
     }
 
-    override fun linkCommand(objectFiles: List<String>, executable: String, optimize: Boolean): List<String> {
+    override fun linkCommand(objectFiles: List<ObjectFile>, executable: ExecutableFile, optimize: Boolean, debug: Boolean): List<String> {
-        return mutableListOf(linker, "-demangle") +
+        return mutableListOf(linker).apply {
-                    listOf("-object_path_lto", "temporary.o", "-lto_library", distribution.libLTO) +
+            add("-demangle")
-                    listOf("-dynamic", "-arch", propertyTargetString("arch")) +
+            addAll(listOf("-object_path_lto", "temporary.o", "-lto_library", distribution.libLTO))
-                    osVersionMin +
+            addAll(listOf("-dynamic", "-arch", propertyTargetString("arch")))
-                    listOf("-syslibroot", distribution.targetSysRoot, "-o", executable) +
+            addAll(osVersionMin)
-                    objectFiles +
+            addAll(listOf("-syslibroot", distribution.targetSysRoot, "-o", executable))
-                    (if (optimize) linkerOptimizationFlags else emptyList()) +
+            addAll(objectFiles)
-                    linkerKonanFlags + listOf("-lSystem")
+            if (optimize) addAll(linkerOptimizationFlags)
+            if (!debug) addAll(linkerDebugFlags)
+            addAll(linkerKonanFlags)
+            add("-lSystem")
+        }
     }
 
     open fun dsymutilCommand(executable: ExecutableFile): List<String> {
@@ -123,26 +135,29 @@ internal open class LinuxBasedPlatform(distribution: Distribution)
     val specificLibs
         = propertyTargetList("abiSpecificLibraries").map{it -> "-L${targetSysRoot}/$it"}
 
-    override fun linkCommand(objectFiles: List<String>, executable: String, optimize: Boolean): List<String> {
+    override fun linkCommand(objectFiles: List<ObjectFile>, executable: ExecutableFile, optimize: Boolean, debug: Boolean): List<String> {
         // TODO: Can we extract more to the konan.properties?
-        return mutableListOf(linker,
+        return mutableListOf(linker).apply {
-            "--sysroot=${targetSysRoot}",
+            addAll(listOf("--sysroot=${targetSysRoot}",
-            "-export-dynamic", "-z", "relro", "--hash-style=gnu", 
+                    "-export-dynamic", "-z", "relro", "--hash-style=gnu",
-            "--build-id", "--eh-frame-hdr", // "-m", "elf_x86_64",
+                    "--build-id", "--eh-frame-hdr", // "-m", "elf_x86_64",
-            "-dynamic-linker", propertyTargetString("dynamicLinker"),
+                    "-dynamic-linker", propertyTargetString("dynamicLinker"),
-            "-o", executable,
+                    "-o", executable,
-            "${targetSysRoot}/usr/lib64/crt1.o", "${targetSysRoot}/usr/lib64/crti.o", "${libGcc}/crtbegin.o",
+                    "${targetSysRoot}/usr/lib64/crt1.o",
-            "-L${llvmLib}", "-L${libGcc}") +
+                    "${targetSysRoot}/usr/lib64/crti.o", "${libGcc}/crtbegin.o",
-            specificLibs +
+                    "-L${llvmLib}", "-L${libGcc}"))
-            listOf("-L${targetSysRoot}/../lib", "-L${targetSysRoot}/lib", "-L${targetSysRoot}/usr/lib") + 
+            addAll(specificLibs)
-            (if (optimize) listOf("-plugin", "$llvmLib/LLVMgold.so") + pluginOptimizationFlags else emptyList<String>()) +
+            addAll(listOf("-L${targetSysRoot}/../lib", "-L${targetSysRoot}/lib", "-L${targetSysRoot}/usr/lib"))
-            objectFiles +
+            if (optimize) addAll(listOf("-plugin", "$llvmLib/LLVMgold.so") + pluginOptimizationFlags)
-            (if (optimize) linkerOptimizationFlags else emptyList<String>()) +
+            addAll(objectFiles)
-            linkerKonanFlags +
+            if (optimize) addAll(linkerOptimizationFlags)
-            listOf("-lgcc", "--as-needed", "-lgcc_s", "--no-as-needed", 
+            if (!debug) addAll(linkerDebugFlags)
-            "-lc", "-lgcc", "--as-needed", "-lgcc_s", "--no-as-needed",
+            addAll(linkerKonanFlags)
-            "${libGcc}/crtend.o",
+            addAll(listOf("-lgcc", "--as-needed", "-lgcc_s", "--no-as-needed",
-            "${targetSysRoot}/usr/lib64/crtn.o")
+                    "-lc", "-lgcc", "--as-needed", "-lgcc_s", "--no-as-needed",
+                    "${libGcc}/crtend.o",
+                    "${targetSysRoot}/usr/lib64/crtn.o"))
+        }
     }
 }
 
@@ -153,10 +168,13 @@ internal open class MingwPlatform(distribution: Distribution)
 
     override val useCompilerDriverAsLinker: Boolean get() = true
 
-    override fun linkCommand(objectFiles: List<String>, executable: String, optimize: Boolean): List<String> {
+    override fun linkCommand(objectFiles: List<ObjectFile>, executable: ExecutableFile, optimize: Boolean, debug: Boolean): List<String> {
-        return listOf(linker, "-o", executable) +
+        return mutableListOf(linker).apply {
-                objectFiles +
+            addAll(listOf("-o", executable))
-                (if (optimize) linkerOptimizationFlags else emptyList())
+            addAll(objectFiles)
+            if (optimize) addAll(linkerOptimizationFlags)
+            if (!debug) addAll(linkerDebugFlags)
+        }
     }
 
     override fun linkCommandSuffix() = linkerKonanFlags
@@ -234,7 +252,7 @@ internal class LinkStage(val context: Context) {
 
     fun link(objectFiles: List<ObjectFile>): ExecutableFile {
         val executable = config.get(KonanConfigKeys.OUTPUT_FILE)!!
-        val linkCommand = platform.linkCommand(objectFiles, executable, optimize) +
+        val linkCommand = platform.linkCommand(objectFiles, executable, optimize, config.getBoolean(KonanConfigKeys.DEBUG)) +
                 distribution.libffi +
                 asLinkerArgs(config.getNotNull(KonanConfigKeys.LINKER_ARGS)) +
                 entryPointSelector +

backend.native/konan.properties

@@ -30,6 +30,7 @@ llvmLtoOptFlags.osx = -O3 -function-sections
 llvmLtoNooptFlags.osx = -O1
 linkerKonanFlags.osx = -lc++
 linkerOptimizationFlags.osx = -dead_strip
+linkerDebugFlags.osx = -S
 osVersionMinFlagLd.osx = -macosx_version_min
 osVersionMinFlagClang.osx = -mmacosx-version-min
 osVersionMin.osx = 10.11
@@ -51,6 +52,7 @@ targetSysRoot.ios = target-sysroot-2-darwin-ios
 libffiDir.ios = libffi-3.2.1-2-darwin-ios
 llvmLtoFlags.ios = -exported-symbol=_Konan_main
 llvmLtoOptFlags.ios = -O3 -function-sections
+linkerDebugFlags.ios = -S
 llvmLtoNooptFlags.ios = -O1
 linkerKonanFlags.ios = -lc++
 linkerOptimizationFlags.ios = -dead_strip
@@ -74,6 +76,7 @@ llvmLtoOptFlags.ios_sim = -O3 -function-sections
 llvmLtoNooptFlags.ios_sim = -O1
 linkerKonanFlags.ios_sim = -lc++
 linkerOptimizationFlags.ios_sim = -dead_strip
+linkerDebugFlags.ios_sim = -S
 osVersionMinFlagLd.ios_sim = -ios_simulator_version_min
 osVersionMinFlagClang.ios_sim = -mios-simulator-version-min
 osVersionMin.ios_sim = 8.0
@@ -94,6 +97,7 @@ llvmLtoNooptFlags.linux = -O1
 llvmLlcFlags.linux = -march=x86-64
 linkerKonanFlags.linux = -Bstatic -lstdc++ -Bdynamic -ldl -lm -lpthread
 linkerOptimizationFlags.linux = --gc-sections
+linkerDebugFlags.linux = -S
 pluginOptimizationFlags.linux = -plugin-opt=mcpu=x86-64 -plugin-opt=O3
 dynamicLinker.linux = /lib64/ld-linux-x86-64.so.2
 entrySelector.linux = --defsym main=Konan_main
@@ -151,6 +155,7 @@ quadruple.android_arm32 = arm-linux-androideabi
 entrySelector.android_arm32 =  -Wl,--defsym -Wl,main=Konan_main
 llvmLtoFlags.android_arm32 = -exported-symbol=Konan_main -emulated-tls -relocation-model=pic
 llvmLtoOptFlags.android_arm32 = -O3 -function-sections
+linkerDebugFlags.android_arm32 = -S
 llvmLtoNooptFlags.android_arm32 = -O1
 targetSysRoot.android_arm32 = target-sysroot-21-android_arm32
 libffiDir.android_arm32 = libffi-3.2.1-2-android_arm32
@@ -177,6 +182,7 @@ llvmLtoFlags.android_arm64 = -exported-symbol=Konan_main -emulated-tls -relocati
 targetSysRoot.android_arm64 = target-sysroot-21-android_arm64
 libffiDir.android_arm64 = libffi-3.2.1-2-android_arm64
 linkerKonanFlags.android_arm64 = -lm -latomic -lstdc++ -landroid
+linkerDebugFlags.android_arm64 = -S
 
 # Windows x86-64, based on mingw-w64.
 llvmVersion.mingw = 3.9.1
@@ -189,6 +195,7 @@ libffiDir.mingw = libffi-3.2.1-mingw-w64-x86-64
 llvmLtoFlags.mingw = -exported-symbol=Konan_main
 llvmLtoOptFlags.mingw = -O3 -function-sections
 llvmLtoNooptFlags.mingw = -O1
+linkerDebugFlags.mingw = -Wl,-S
 linkerKonanFlags.mingw = -static-libgcc -static-libstdc++ \
   -Wl,-Bstatic,--whole-archive -lwinpthread -Wl,--no-whole-archive,-Bdynamic
 linkerOptimizationFlags.mingw = -Wl,--gc-sections