Move Kotlin static data to read-only section

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

@@ -955,7 +955,7 @@ internal class CodeGeneratorVisitor(val context: Context, val lifetimes: Map<IrE
         // Note: even if all elements are const, they aren't guaranteed to be statically initialized.
         // E.g. an element may be a pointer to lazy-initialized object (aka singleton).
         // However it is guaranteed that all elements are already initialized at this point.
-        return codegen.staticData.createKotlinArray(arrayClass, elements)
+        return codegen.staticData.createConstKotlinArray(arrayClass, elements)
     }
 
     //-------------------------------------------------------------------------//
@@ -2330,11 +2330,11 @@ internal class CodeGeneratorVisitor(val context: Context, val lifetimes: Map<IrE
                 // TODO: store length in `vararg` itself when more abstract types will be used for values.
 
                 val array = constPointer(vararg)
-                // Note: dirty hack here: `vararg` has type `Array<out E>`, but `createArrayList` expects `Array<E>`;
+                // Note: dirty hack here: `vararg` has type `Array<out E>`, but `createConstArrayList` expects `Array<E>`;
                 // however `vararg` is immutable, and in current implementation it has type `Array<E>`,
                 // so let's ignore this mismatch currently for simplicity.
 
-                return context.llvm.staticData.createArrayList(array, length).llvm
+                return context.llvm.staticData.createConstArrayList(array, length).llvm
             }
 
             else -> TODO(callee.descriptor.original.toString())

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

@@ -304,6 +304,7 @@ internal class RTTIGenerator(override val context: Context) : ContextUtils {
             Struct(runtime.extendedTypeInfoType, Int32(fields.size), offsetsPtr, typesPtr, namesPtr)
         }
         val result = staticData.placeGlobal("", value)
+        result.setConstant(true)
         return result.pointer
     }
 

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

@@ -174,5 +174,5 @@ internal class StaticData(override val context: Context): ContextUtils {
  */
 internal fun StaticData.createImmutableBlob(value: IrConst<String>): LLVMValueRef {
     val args = value.value.map { Int8(it.toByte()).llvm }
-    return createKotlinArray(context.ir.symbols.immutableBlob.owner, args)
+    return createConstKotlinArray(context.ir.symbols.immutableBlob.owner, args)
 }

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

@@ -38,7 +38,7 @@ internal fun StaticData.createKotlinStringLiteral(value: String): ConstPointer {
     val name = "kstr:" + value.globalHashBase64
     val elements = value.toCharArray().map(::Char16)
 
-    val objRef = createKotlinArray(context.ir.symbols.string.owner, elements)
+    val objRef = createConstKotlinArray(context.ir.symbols.string.owner, elements)
 
     val res = createAlias(name, objRef)
     LLVMSetLinkage(res.llvm, LLVMLinkage.LLVMWeakAnyLinkage)
@@ -48,10 +48,10 @@ internal fun StaticData.createKotlinStringLiteral(value: String): ConstPointer {
 
 private fun StaticData.createRef(objHeaderPtr: ConstPointer) = objHeaderPtr.bitcast(kObjHeaderPtr)
 
-internal fun StaticData.createKotlinArray(arrayClass: IrClass, elements: List<LLVMValueRef>) =
+internal fun StaticData.createConstKotlinArray(arrayClass: IrClass, elements: List<LLVMValueRef>) =
-        createKotlinArray(arrayClass, elements.map { constValue(it) }).llvm
+        createConstKotlinArray(arrayClass, elements.map { constValue(it) }).llvm
 
-internal fun StaticData.createKotlinArray(arrayClass: IrClass, elements: List<ConstValue>): ConstPointer {
+internal fun StaticData.createConstKotlinArray(arrayClass: IrClass, elements: List<ConstValue>): ConstPointer {
     val typeInfo = arrayClass.typeInfoPtr
 
     val bodyElementType: LLVMTypeRef = elements.firstOrNull()?.llvmType ?: int8Type
@@ -66,11 +66,12 @@ internal fun StaticData.createKotlinArray(arrayClass: IrClass, elements: List<Co
     val arrayHeader = arrayHeader(typeInfo, elements.size)
 
     global.setInitializer(Struct(compositeType, arrayHeader, arrayBody))
+    global.setConstant(true)
 
     return createRef(objHeaderPtr)
 }
 
-internal fun StaticData.createKotlinObject(type: IrClass, body: ConstValue): ConstPointer {
+internal fun StaticData.createConstKotlinObject(type: IrClass, body: ConstValue): ConstPointer {
     val typeInfo = type.typeInfoPtr
 
     val compositeType = structType(runtime.objHeaderType, body.llvmType)
@@ -81,6 +82,7 @@ internal fun StaticData.createKotlinObject(type: IrClass, body: ConstValue): Con
     val objHeader = objHeader(typeInfo)
 
     global.setInitializer(Struct(compositeType, objHeader, body))
+    global.setConstant(true)
 
     return createRef(objHeaderPtr)
 }
@@ -103,7 +105,7 @@ private fun StaticData.getArrayListClass(): ClassDescriptor {
  * @param array value for `array: Array<E>` field.
  * @param length value for `length: Int` field.
  */
-internal fun StaticData.createArrayList(array: ConstPointer, length: Int): ConstPointer {
+internal fun StaticData.createConstArrayList(array: ConstPointer, length: Int): ConstPointer {
     val arrayListClass = context.ir.symbols.arrayList.owner
 
     val arrayListFqName = arrayListClass.fqNameSafe
@@ -123,7 +125,7 @@ internal fun StaticData.createArrayList(array: ConstPointer, length: Int): Const
         
     val body = Struct(*(sorted.values.toTypedArray()))
 
-    return createKotlinObject(arrayListClass, body)
+    return createConstKotlinObject(arrayListClass, body)
 }
 
 internal fun StaticData.createUniqueInstance(
@@ -134,6 +136,7 @@ internal fun StaticData.createUniqueInstance(
         UniqueKind.EMPTY_ARRAY -> arrayHeader(typeInfo, 0)
     }
     val global = this.placeGlobal(kind.llvmName, objHeader, isExported = true)
+    global.setConstant(true)
     return global.pointer
 }