diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DFGSerializer.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DFGSerializer.kt
index d62c6a0e074..46dcca1ddfe 100644
--- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DFGSerializer.kt
+++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DFGSerializer.kt
@@ -260,33 +260,36 @@ internal object DFGSerializer {
         }
     }
 
-    class ExternalFunctionSymbol(val hash: Long, val name: String?) {
-
-        constructor(data: ArraySlice) : this(data.readLong(), data.readNullableString())
-
-        fun write(result: ArraySlice) {
-            result.writeLong(hash)
-            result.writeNullableString(name)
-        }
-    }
-
-    class PublicFunctionSymbol(val hash: Long, val index: Int, val name: String?) {
+    class ExternalFunctionSymbol(val hash: Long, val numberOfParameters: Int, val name: String?) {
 
         constructor(data: ArraySlice) : this(data.readLong(), data.readInt(), data.readNullableString())
 
         fun write(result: ArraySlice) {
             result.writeLong(hash)
+            result.writeInt(numberOfParameters)
+            result.writeNullableString(name)
+        }
+    }
+
+    class PublicFunctionSymbol(val hash: Long, val numberOfParameters: Int, val index: Int, val name: String?) {
+
+        constructor(data: ArraySlice) : this(data.readLong(), data.readInt(), data.readInt(), data.readNullableString())
+
+        fun write(result: ArraySlice) {
+            result.writeLong(hash)
+            result.writeInt(numberOfParameters)
             result.writeInt(index)
             result.writeNullableString(name)
         }
     }
 
-    class PrivateFunctionSymbol(val index: Int, val name: String?) {
+    class PrivateFunctionSymbol(val index: Int, val numberOfParameters: Int, val name: String?) {
 
-        constructor(data: ArraySlice) : this(data.readInt(), data.readNullableString())
+        constructor(data: ArraySlice) : this(data.readInt(), data.readInt(), data.readNullableString())
 
         fun write(result: ArraySlice) {
             result.writeInt(index)
+            result.writeInt(numberOfParameters)
             result.writeNullableString(name)
         }
     }
@@ -308,11 +311,14 @@ internal object DFGSerializer {
         }
 
         companion object {
-            fun external(hash: Long, name: String?) = FunctionSymbol(ExternalFunctionSymbol(hash, name), null, null)
+            fun external(hash: Long, numberOfParameters: Int, name: String?) =
+                    FunctionSymbol(ExternalFunctionSymbol(hash, numberOfParameters, name), null, null)
 
-            fun public(hash: Long, index: Int, name: String?) = FunctionSymbol(null, PublicFunctionSymbol(hash, index, name), null)
+            fun public(hash: Long, numberOfParameters: Int, index: Int, name: String?) =
+                    FunctionSymbol(null, PublicFunctionSymbol(hash, numberOfParameters, index, name), null)
 
-            fun private(index: Int, name: String?) = FunctionSymbol(null, null, PrivateFunctionSymbol(index, name))
+            fun private(index: Int, numberOfParameters: Int, name: String?) =
+                    FunctionSymbol(null, null, PrivateFunctionSymbol(index, numberOfParameters, name))
 
             fun read(data: ArraySlice): FunctionSymbol {
                 val tag = data.readByte().toInt()
@@ -663,15 +669,17 @@ internal object DFGSerializer {
                 .sortedBy { it.value }
                 .map {
                     val functionSymbol = it.key
+                    val numberOfParameters = functionSymbol.numberOfParameters
+                    val name = functionSymbol.name
                     when (functionSymbol) {
                         is DataFlowIR.FunctionSymbol.External ->
-                            FunctionSymbol.external(functionSymbol.hash, functionSymbol.name)
+                            FunctionSymbol.external(functionSymbol.hash, numberOfParameters, name)
 
                         is DataFlowIR.FunctionSymbol.Public ->
-                            FunctionSymbol.public(functionSymbol.hash, functionSymbol.symbolTableIndex, functionSymbol.name)
+                            FunctionSymbol.public(functionSymbol.hash, numberOfParameters, functionSymbol.symbolTableIndex, name)
 
                         is DataFlowIR.FunctionSymbol.Private ->
-                            FunctionSymbol.private(functionSymbol.symbolTableIndex, functionSymbol.name)
+                            FunctionSymbol.private(functionSymbol.symbolTableIndex, numberOfParameters, name)
 
                         else -> error("Unknown function symbol $functionSymbol")
                     }
@@ -806,13 +814,14 @@ internal object DFGSerializer {
                     val public = it.public
                     val private = it.private
                     when {
-                        external != null -> DataFlowIR.FunctionSymbol.External(external.hash, external.name)
+                        external != null ->
+                            DataFlowIR.FunctionSymbol.External(external.hash, external.numberOfParameters, external.name)
 
                         public != null -> {
                             val symbolTableIndex = public.index
                             if (symbolTableIndex >= 0)
                                 ++module.numberOfFunctions
-                            DataFlowIR.FunctionSymbol.Public(public.hash, module, symbolTableIndex, public.name).also {
+                            DataFlowIR.FunctionSymbol.Public(public.hash, public.numberOfParameters, module, symbolTableIndex, public.name).also {
                                 publicFunctionsMap.put(it.hash, it)
                             }
                         }
@@ -821,7 +830,7 @@ internal object DFGSerializer {
                             val symbolTableIndex = private!!.index
                             if (symbolTableIndex >= 0)
                                 ++module.numberOfFunctions
-                            DataFlowIR.FunctionSymbol.Private(privateFunIndex++, module, symbolTableIndex, private.name)
+                            DataFlowIR.FunctionSymbol.Private(privateFunIndex++, private.numberOfParameters, module, symbolTableIndex, private.name)
                         }
                     }
                 }
diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DataFlowIR.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DataFlowIR.kt
index 4aabedf7796..0ddc4cd706e 100644
--- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DataFlowIR.kt
+++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DataFlowIR.kt
@@ -1,5 +1,6 @@
 package org.jetbrains.kotlin.backend.konan.optimizations
 
+import org.jetbrains.kotlin.backend.common.descriptors.allParameters
 import org.jetbrains.kotlin.backend.konan.Context
 import org.jetbrains.kotlin.backend.konan.descriptors.externalOrIntrinsic
 import org.jetbrains.kotlin.backend.konan.descriptors.isAbstract
@@ -93,8 +94,9 @@ internal object DataFlowIR {
         var numberOfFunctions = 0
     }
 
-    abstract class FunctionSymbol {
-        class External(val hash: Long, val name: String? = null) : FunctionSymbol() {
+    abstract class FunctionSymbol(val numberOfParameters: Int, val name: String?) {
+        class External(val hash: Long, numberOfParameters: Int, name: String? = null)
+            : FunctionSymbol(numberOfParameters, name) {
             override fun equals(other: Any?): Boolean {
                 if (this === other) return true
                 if (other !is External) return false
@@ -111,9 +113,11 @@ internal object DataFlowIR {
             }
         }
 
-        abstract class Declared(val module: Module, val symbolTableIndex: Int) : FunctionSymbol()
+        abstract class Declared(numberOfParameters: Int, val module: Module, val symbolTableIndex: Int, name: String?)
+            : FunctionSymbol(numberOfParameters, name)
 
-        class Public(val hash: Long, module: Module, symbolTableIndex: Int, val name: String? = null) : Declared(module, symbolTableIndex) {
+        class Public(val hash: Long, numberOfParameters: Int, module: Module, symbolTableIndex: Int, name: String? = null)
+            : Declared(numberOfParameters, module, symbolTableIndex, name) {
             override fun equals(other: Any?): Boolean {
                 if (this === other) return true
                 if (other !is Public) return false
@@ -130,7 +134,8 @@ internal object DataFlowIR {
             }
         }
 
-        class Private(val index: Int, module: Module, symbolTableIndex: Int, val name: String? = null) : Declared(module, symbolTableIndex) {
+        class Private(val index: Int, numberOfParameters: Int, module: Module, symbolTableIndex: Int, name: String? = null)
+            : Declared(numberOfParameters, module, symbolTableIndex, name) {
             override fun equals(other: Any?): Boolean {
                 if (this === other) return true
                 if (other !is Private) return false
@@ -412,12 +417,13 @@ internal object DataFlowIR {
             functionMap.getOrPut(it) {
                 when (it) {
                     is PropertyDescriptor ->
-                        FunctionSymbol.Private(privateFunIndex++, module, -1, takeName { "${it.symbolName}_init" })
+                        FunctionSymbol.Private(privateFunIndex++, 0, module, -1, takeName { "${it.symbolName}_init" })
 
                     is FunctionDescriptor -> {
                         val name = if (it.isExported()) it.symbolName else it.internalName
+                        val numberOfParameters = it.allParameters.size + if (it.isSuspend) 1 else 0
                         if (it.module != irModule.descriptor || it.externalOrIntrinsic())
-                            FunctionSymbol.External(name.localHash.value, takeName { name })
+                            FunctionSymbol.External(name.localHash.value, numberOfParameters, takeName { name })
                         else {
                             val isAbstract = it.modality == Modality.ABSTRACT
                             val classDescriptor = it.containingDeclaration as? ClassDescriptor
@@ -428,9 +434,9 @@ internal object DataFlowIR {
                                 ++module.numberOfFunctions
                             val symbolTableIndex = if (!placeToFunctionsTable) -1 else couldBeCalledVirtuallyIndex++
                             if (it.isExported())
-                                FunctionSymbol.Public(name.localHash.value, module, symbolTableIndex, takeName { name })
+                                FunctionSymbol.Public(name.localHash.value, numberOfParameters, module, symbolTableIndex, takeName { name })
                             else
-                                FunctionSymbol.Private(privateFunIndex++, module, symbolTableIndex, takeName { name })
+                                FunctionSymbol.Private(privateFunIndex++, numberOfParameters, module, symbolTableIndex, takeName { name })
                         }
                     }