azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add City64 as local hash, and update RTTI accordingly.

Browse Source
This commit is contained in:
Nikolay Igotti
2016-10-11 18:04:08 +03:00
parent fb61896825
commit ecb5a67db7
10 changed files with 432 additions and 186 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/native/llvm/IrToBitcode.kt
+43 -43
View File
@@ -19,7 +19,7 @@ fun emitLLVM(module: IrModuleFragment, runtimeFile: String, outFile: String) {
val context = Context(module, runtime, llvmModule) // TODO: dispose val context = Context(module, runtime, llvmModule) // TODO: dispose
module.accept(RTTIGeneratorVisitor(context), null) module.accept(RTTIGeneratorVisitor(context), null)
module.accept(CodeGeneratorVisitor(context), null) // module.accept(CodeGeneratorVisitor(context), null)
LLVMWriteBitcodeToFile(llvmModule, outFile) LLVMWriteBitcodeToFile(llvmModule, outFile)
} }
@@ -27,12 +27,12 @@ internal class RTTIGeneratorVisitor(context: Context) : IrElementVisitorVoid {
val generator = RTTIGenerator(context) val generator = RTTIGenerator(context)
override fun visitElement(element: IrElement) { override fun visitElement(element: IrElement) {
element.acceptChildrenVoid(this) element.acceptChildrenVoid(this)
} }
override fun visitClass(declaration: IrClass) { override fun visitClass(declaration: IrClass) {
super.visitClass(declaration) super.visitClass(declaration)
generator.generate(declaration.descriptor) generator.generate(declaration.descriptor)
} }
} }
@@ -43,63 +43,63 @@ internal class RTTIGeneratorVisitor(context: Context) : IrElementVisitorVoid {
internal class CodeGeneratorVisitor(val context: Context) : IrElementVisitorVoid { internal class CodeGeneratorVisitor(val context: Context) : IrElementVisitorVoid {
val generator = CodeGenerator(context) val generator = CodeGenerator(context)
override fun visitFunction(declaration: IrFunction) { override fun visitFunction(declaration: IrFunction) {
generator.function(declaration) generator.function(declaration)
declaration.acceptChildrenVoid(this) declaration.acceptChildrenVoid(this)
} }
override fun visitElement(element: IrElement) { override fun visitElement(element: IrElement) {
element.acceptChildrenVoid(this) element.acceptChildrenVoid(this)
} }
override fun visitSetVariable(expression: IrSetVariable) { override fun visitSetVariable(expression: IrSetVariable) {
val value = evaluateExpression(generator.tmpVariable(), expression.value) val value = evaluateExpression(generator.tmpVariable(), expression.value)
generator.store(value!!, generator.variable(expression.descriptor.name.asString())!!) generator.store(value!!, generator.variable(expression.descriptor.name.asString())!!)
} }
private fun evaluateExpression(tmpVariableName: String, value: IrExpression?): LLVMOpaqueValue? { private fun evaluateExpression(tmpVariableName: String, value: IrExpression?): LLVMOpaqueValue? {
when (value) { when (value) {
is IrCall -> return evaluateCall(tmpVariableName, value) is IrCall -> return evaluateCall(tmpVariableName, value)
is IrGetValue -> return generator.load(generator.variable(value.descriptor.name.asString())!!, tmpVariableName) is IrGetValue -> return generator.load(generator.variable(value.descriptor.name.asString())!!, tmpVariableName)
null -> return null null -> return null
else -> { else -> {
TODO() TODO()
} }
} }
} }
private fun evaluateCall(tmpVariableName: String, value: IrCall?): LLVMOpaqueValue? { private fun evaluateCall(tmpVariableName: String, value: IrCall?): LLVMOpaqueValue? {
/* TODO: should we count on receiver? /* TODO: should we count on receiver?
* val tmp = tmpVar() * val tmp = tmpVar()
* val lhs = evaluateExpression(tmp, value.dispatchReceiver!!) * val lhs = evaluateExpression(tmp, value.dispatchReceiver!!)
*/ */
val args = mutableListOf<LLVMOpaqueValue?>() val args = mutableListOf<LLVMOpaqueValue?>()
value!!.acceptChildrenVoid(object:IrElementVisitorVoid{ value!!.acceptChildrenVoid(object:IrElementVisitorVoid{
override fun visitElement(element: IrElement) { override fun visitElement(element: IrElement) {
val tmp = generator.tmpVariable() val tmp = generator.tmpVariable()
args.add(evaluateExpression(tmp, element as IrExpression)) args.add(evaluateExpression(tmp, element as IrExpression))
} }
}) })
when (value!!.origin) { when (value!!.origin) {
IrStatementOrigin.PLUS -> return generator.plus(args[0]!!, args[1]!!, tmpVariableName) IrStatementOrigin.PLUS -> return generator.plus(args[0]!!, args[1]!!, tmpVariableName)
else -> { else -> {
TODO() TODO()
} }
} }
TODO() TODO()
} }
override fun visitVariable(declaration: IrVariable) { override fun visitVariable(declaration: IrVariable) {
val variableName = declaration.descriptor.name.asString() val variableName = declaration.descriptor.name.asString()
val variableType = declaration.descriptor.type val variableType = declaration.descriptor.type
generator.registerVariable(variableName, generator.alloca(variableType, variableName)) generator.registerVariable(variableName, generator.alloca(variableType, variableName))
evaluateExpression(variableName, declaration.initializer) evaluateExpression(variableName, declaration.initializer)
} }
override fun visitReturn(expression: IrReturn) { override fun visitReturn(expression: IrReturn) {
val tmpVarName = generator.tmpVariable() val tmpVarName = generator.tmpVariable()
val value:LLVMOpaqueValue? val value:LLVMOpaqueValue?
value = evaluateExpression(tmpVarName, expression.value) value = evaluateExpression(tmpVarName, expression.value)
LLVMBuildRet(context.llvmBuilder, value) LLVMBuildRet(context.llvmBuilder, value)
} }
} }
backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/native/llvm/LlvmUtils.kt
+14 -10
View File
@@ -13,7 +13,7 @@ internal abstract class CompileTimeValue {
abstract fun getLlvmValue(): LLVMOpaqueValue? abstract fun getLlvmValue(): LLVMOpaqueValue?
fun getLlvmType(): LLVMOpaqueType? { fun getLlvmType(): LLVMOpaqueType? {
return LLVMTypeOf(getLlvmValue()) return LLVMTypeOf(getLlvmValue())
} }
} }
@@ -21,10 +21,10 @@ internal abstract class CompileTimeValue {
internal class ConstArray(val elemType: LLVMOpaqueType?, val elements: List<CompileTimeValue>) : CompileTimeValue() { internal class ConstArray(val elemType: LLVMOpaqueType?, val elements: List<CompileTimeValue>) : CompileTimeValue() {
override fun getLlvmValue(): LLVMOpaqueValue? { override fun getLlvmValue(): LLVMOpaqueValue? {
val values = elements.map { it.getLlvmValue() }.toTypedArray() val values = elements.map { it.getLlvmValue() }.toTypedArray()
val valuesNativeArrayPtr = mallocNativeArrayOf(LLVMOpaqueValue, *values)[0] // FIXME: dispose val valuesNativeArrayPtr = mallocNativeArrayOf(LLVMOpaqueValue, *values)[0] // FIXME: dispose
return LLVMConstArray(elemType, valuesNativeArrayPtr, values.size) return LLVMConstArray(elemType, valuesNativeArrayPtr, values.size)
} }
} }
@@ -33,12 +33,16 @@ internal open class Struct(val type: LLVMOpaqueType?, val elements: List<Compile
constructor(type: LLVMOpaqueType?, vararg elements: CompileTimeValue) : this(type, elements.toList()) constructor(type: LLVMOpaqueType?, vararg elements: CompileTimeValue) : this(type, elements.toList())
override fun getLlvmValue(): LLVMOpaqueValue? { override fun getLlvmValue(): LLVMOpaqueValue? {
val values = elements.map { it.getLlvmValue() }.toTypedArray() val values = elements.map { it.getLlvmValue() }.toTypedArray()
val valuesNativeArrayPtr = mallocNativeArrayOf(LLVMOpaqueValue, *values)[0] // FIXME: dispose val valuesNativeArrayPtr = mallocNativeArrayOf(LLVMOpaqueValue, *values)[0] // FIXME: dispose
return LLVMConstNamedStruct(type, valuesNativeArrayPtr, values.size) return LLVMConstNamedStruct(type, valuesNativeArrayPtr, values.size)
} }
} }
internal class Int8(val value: Byte) : CompileTimeValue() {
override fun getLlvmValue() = LLVMConstInt(LLVMInt8Type(), value.toLong(), 1)
}
internal class Int32(val value: Int) : CompileTimeValue() { internal class Int32(val value: Int) : CompileTimeValue() {
override fun getLlvmValue() = LLVMConstInt(LLVMInt32Type(), value.toLong(), 1) override fun getLlvmValue() = LLVMConstInt(LLVMInt32Type(), value.toLong(), 1)
} }
@@ -63,11 +67,11 @@ internal fun pointerType(pointeeType: LLVMOpaqueType?) = LLVMPointerType(pointee
internal fun getLlvmFunctionType(function: FunctionDescriptor): LLVMOpaqueType? { internal fun getLlvmFunctionType(function: FunctionDescriptor): LLVMOpaqueType? {
val returnType = getLLVMType(function.returnType!!) val returnType = getLLVMType(function.returnType!!)
val params = function.dispatchReceiverParameter.singletonOrEmptyList() + val params = function.dispatchReceiverParameter.singletonOrEmptyList() +
function.extensionReceiverParameter.singletonOrEmptyList() + function.extensionReceiverParameter.singletonOrEmptyList() +
function.valueParameters function.valueParameters
val paramTypes = params.map { getLLVMType(it.type) }.toTypedArray() val paramTypes = params.map { getLLVMType(it.type) }.toTypedArray()
val paramTypesPtr = mallocNativeArrayOf(LLVMOpaqueType, *paramTypes)[0] // TODO: dispose val paramTypesPtr = mallocNativeArrayOf(LLVMOpaqueType, *paramTypes)[0] // TODO: dispose
return LLVMFunctionType(returnType, paramTypesPtr, paramTypes.size, 0) return LLVMFunctionType(returnType, paramTypesPtr, paramTypes.size, 0)
} }
backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/native/llvm/RTTIGenerator.kt
+111 -111
View File
@@ -16,166 +16,166 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassOrAny
internal class RTTIGenerator(override val context: Context) : ContextUtils { internal class RTTIGenerator(override val context: Context) : ContextUtils {
val runtime: Runtime val runtime: Runtime
get() = context.runtime get() = context.runtime
private inner class FieldTableRecord(val nameSignature: Long, val fieldOffset: Int) : private inner class FieldTableRecord(val nameSignature: Long, val fieldOffset: Int) :
Struct(runtime.fieldTableRecordType, Int64(nameSignature), Int32(fieldOffset)) Struct(runtime.fieldTableRecordType, Int64(nameSignature), Int32(fieldOffset))
private inner class MethodTableRecord(val nameSignature: Long, val methodEntryPoint: CompileTimeValue) : private inner class MethodTableRecord(val nameSignature: Long, val methodEntryPoint: CompileTimeValue) :
Struct(runtime.methodTableRecordType, Int64(nameSignature), methodEntryPoint) Struct(runtime.methodTableRecordType, Int64(nameSignature), methodEntryPoint)
private inner class TypeInfo(val name: Long, val size: Int, private inner class TypeInfo(val name: Long, val size: Int,
val superType: CompileTimeValue, val superType: CompileTimeValue,
val objOffsets: CompileTimeValue, val objOffsets: CompileTimeValue,
val objOffsetsCount: Int, val objOffsetsCount: Int,
val interfaces: CompileTimeValue, val interfaces: CompileTimeValue,
val interfacesCount: Int, val interfacesCount: Int,
val vtable: CompileTimeValue, val vtable: CompileTimeValue,
val methods: CompileTimeValue, val methods: CompileTimeValue,
val methodsCount: Int, val methodsCount: Int,
val fields: CompileTimeValue, val fields: CompileTimeValue,
val fieldsCount: Int) : val fieldsCount: Int) :
Struct( Struct(
runtime.typeInfoType, runtime.typeInfoType,
Int64(name), Struct(runtime.globalhHashType, ConstArray(LLVMInt8Type(), Array(20, {i -> Int8(1)}).toList())),
Int32(size), Int32(size),
superType, superType,
objOffsets, objOffsets,
Int32(objOffsetsCount), Int32(objOffsetsCount),
interfaces, interfaces,
Int32(interfacesCount), Int32(interfacesCount),
vtable, vtable,
methods, methods,
Int32(methodsCount), Int32(methodsCount),
fields, fields,
Int32(fieldsCount) Int32(fieldsCount)
) )
// TODO: probably it should be moved out of this class and shared. // TODO: probably it should be moved out of this class and shared.
private fun createStructFor(className: FqName, fields: List<PropertyDescriptor>): LLVMOpaqueType? { private fun createStructFor(className: FqName, fields: List<PropertyDescriptor>): LLVMOpaqueType? {
val classType = LLVMStructCreateNamed(LLVMGetModuleContext(context.llvmModule), "kclass:" + className) val classType = LLVMStructCreateNamed(LLVMGetModuleContext(context.llvmModule), "kclass:" + className)
val fieldTypes = fields.map { getLLVMType(it.returnType!!) }.toTypedArray() val fieldTypes = fields.map { getLLVMType(it.returnType!!) }.toTypedArray()
val fieldTypesNativeArrayPtr = if (fieldTypes.size > 0) { val fieldTypesNativeArrayPtr = if (fieldTypes.size > 0) {
mallocNativeArrayOf(LLVMOpaqueType, *fieldTypes)[0] // TODO: dispose mallocNativeArrayOf(LLVMOpaqueType, *fieldTypes)[0] // TODO: dispose
} else { } else {
null null
} }
LLVMStructSetBody(classType, fieldTypesNativeArrayPtr, fieldTypes.size, 0) LLVMStructSetBody(classType, fieldTypesNativeArrayPtr, fieldTypes.size, 0)
return classType return classType
} }
// TODO: optimize // TODO: optimize
private fun getVtableEntries(classDesc: ClassDescriptor): List<FunctionDescriptor> { private fun getVtableEntries(classDesc: ClassDescriptor): List<FunctionDescriptor> {
val superVtableEntries = if (KotlinBuiltIns.isAny(classDesc)) { val superVtableEntries = if (KotlinBuiltIns.isAny(classDesc)) {
emptyList() emptyList()
} else { } else {
getVtableEntries(classDesc.getSuperClassOrAny()) getVtableEntries(classDesc.getSuperClassOrAny())
} }
val inheritedVtableSlots = Array<FunctionDescriptor?>(superVtableEntries.size, { null }) val inheritedVtableSlots = Array<FunctionDescriptor?>(superVtableEntries.size, { null })
val methods = getMethodTableEntries(classDesc) // TODO: ensure order is well-defined val methods = getMethodTableEntries(classDesc) // TODO: ensure order is well-defined
val entriesForNewVtableSlots = methods.toMutableSet() val entriesForNewVtableSlots = methods.toMutableSet()
methods.forEach { method -> methods.forEach { method ->
superVtableEntries.forEachIndexed { i, superMethod -> superVtableEntries.forEachIndexed { i, superMethod ->
if (OverridingUtil.overrides(method, superMethod)) { if (OverridingUtil.overrides(method, superMethod)) {
assert (inheritedVtableSlots[i] == null) assert (inheritedVtableSlots[i] == null)
inheritedVtableSlots[i] = method inheritedVtableSlots[i] = method
assert (method in entriesForNewVtableSlots) assert (method in entriesForNewVtableSlots)
entriesForNewVtableSlots.remove(method) entriesForNewVtableSlots.remove(method)
} }
} }
} }
return inheritedVtableSlots.map { it!! } + methods.filter { it in entriesForNewVtableSlots } return inheritedVtableSlots.map { it!! } + methods.filter { it in entriesForNewVtableSlots }
} }
private fun getMethodTableEntries(classDesc: ClassDescriptor): List<FunctionDescriptor> { private fun getMethodTableEntries(classDesc: ClassDescriptor): List<FunctionDescriptor> {
val contributedDescriptors = classDesc.unsubstitutedMemberScope.getContributedDescriptors() val contributedDescriptors = classDesc.unsubstitutedMemberScope.getContributedDescriptors()
// (includes declarations from supers) // (includes declarations from supers)
val functions = contributedDescriptors.filterIsInstance<FunctionDescriptor>() val functions = contributedDescriptors.filterIsInstance<FunctionDescriptor>()
val properties = contributedDescriptors.filterIsInstance<PropertyDescriptor>() val properties = contributedDescriptors.filterIsInstance<PropertyDescriptor>()
val getters = properties.mapNotNull { it.getter } val getters = properties.mapNotNull { it.getter }
val setters = properties.mapNotNull { it.setter } val setters = properties.mapNotNull { it.setter }
val allMethods = functions + getters + setters val allMethods = functions + getters + setters
// TODO: adding or removing 'open' modifier will break the binary compatibility // TODO: adding or removing 'open' modifier will break the binary compatibility
return allMethods.filter { it.modality != Modality.FINAL } return allMethods.filter { it.modality != Modality.FINAL }
} }
fun generate(classDesc: ClassDescriptor) { fun generate(classDesc: ClassDescriptor) {
val className = classDesc.fqNameSafe val className = classDesc.fqNameSafe
val classType = createStructFor(className, classDesc.fields) val classType = createStructFor(className, classDesc.fields)
val name = className.nameHash val name = className.nameHash
val size = LLVMStoreSizeOfType(runtime.targetData, classType).toInt() val size = LLVMStoreSizeOfType(runtime.targetData, classType).toInt()
val superType = classDesc.getSuperClassOrAny().llvmTypeInfoPtr val superType = classDesc.getSuperClassOrAny().llvmTypeInfoPtr
val interfaces = classDesc.implementedInterfaces.map { it.llvmTypeInfoPtr } val interfaces = classDesc.implementedInterfaces.map { it.llvmTypeInfoPtr }
val interfacesPtr = addGlobalConstArray("kintf:$className", pointerType(runtime.typeInfoType), interfaces) val interfacesPtr = addGlobalConstArray("kintf:$className", pointerType(runtime.typeInfoType), interfaces)
val refFieldIndices = classDesc.fields.mapIndexedNotNull { index, field -> val refFieldIndices = classDesc.fields.mapIndexedNotNull { index, field ->
val type = field.returnType!! val type = field.returnType!!
if (!KotlinBuiltIns.isPrimitiveType(type)) { if (!KotlinBuiltIns.isPrimitiveType(type)) {
index index
} else { } else {
null null
} }
} }
// TODO: reuse offsets obtained for 'fields' below // TODO: reuse offsets obtained for 'fields' below
val objOffsets = refFieldIndices.map { LLVMOffsetOfElement(runtime.targetData, classType, it) } val objOffsets = refFieldIndices.map { LLVMOffsetOfElement(runtime.targetData, classType, it) }
val objOffsetsPtr = addGlobalConstArray("krefs:$className", int32Type, objOffsets.map { Int32(it.toInt()) }) val objOffsetsPtr = addGlobalConstArray("krefs:$className", int32Type, objOffsets.map { Int32(it.toInt()) })
val fields = classDesc.fields.mapIndexed { index, field -> val fields = classDesc.fields.mapIndexed { index, field ->
// Note: using FQ name because a class may have multiple fields with the same name due to property overriding // Note: using FQ name because a class may have multiple fields with the same name due to property overriding
val nameSignature = field.fqNameSafe.nameHash // FIXME: add signature val nameSignature = field.fqNameSafe.nameHash // FIXME: add signature
val fieldOffset = LLVMOffsetOfElement(runtime.targetData, classType, index) val fieldOffset = LLVMOffsetOfElement(runtime.targetData, classType, index)
FieldTableRecord(nameSignature, fieldOffset.toInt()) FieldTableRecord(nameSignature, fieldOffset.toInt())
}.sortedBy { it.nameSignature } }.sortedBy { it.nameSignature }
val fieldsPtr = addGlobalConstArray("kfields:$className", runtime.fieldTableRecordType, fields) val fieldsPtr = addGlobalConstArray("kfields:$className", runtime.fieldTableRecordType, fields)
// TODO: compile-time resolution limits binary compatibility // TODO: compile-time resolution limits binary compatibility
val vtable = getVtableEntries(classDesc).map { it.implementation.entryPointAddress } val vtable = getVtableEntries(classDesc).map { it.implementation.entryPointAddress }
val vtablePtr = addGlobalConstArray("kvtable:$className", pointerType(int8Type), vtable) val vtablePtr = addGlobalConstArray("kvtable:$className", pointerType(int8Type), vtable)
val methods = getMethodTableEntries(classDesc).map { val methods = getMethodTableEntries(classDesc).map {
val nameSignature = it.name.nameHash // FIXME: add signature val nameSignature = it.name.nameHash // FIXME: add signature
// TODO: compile-time resolution limits binary compatibility // TODO: compile-time resolution limits binary compatibility
val methodEntryPoint = it.implementation.entryPointAddress val methodEntryPoint = it.implementation.entryPointAddress
MethodTableRecord(nameSignature, methodEntryPoint) MethodTableRecord(nameSignature, methodEntryPoint)
}.sortedBy { it.nameSignature } }.sortedBy { it.nameSignature }
val methodsPtr = addGlobalConstArray("kmethods:$className", runtime.methodTableRecordType, methods) val methodsPtr = addGlobalConstArray("kmethods:$className", runtime.methodTableRecordType, methods)
val typeInfo = TypeInfo(name, size, val typeInfo = TypeInfo(name, size,
superType, superType,
objOffsetsPtr, objOffsets.size, objOffsetsPtr, objOffsets.size,
interfacesPtr, interfaces.size, interfacesPtr, interfaces.size,
vtablePtr, vtablePtr,
methodsPtr, methods.size, methodsPtr, methods.size,
fieldsPtr, fields.size) fieldsPtr, fields.size)
val typeInfoGlobal = classDesc.llvmTypeInfoPtr.getLlvmValue() // TODO: it is a hack val typeInfoGlobal = classDesc.llvmTypeInfoPtr.getLlvmValue() // TODO: it is a hack
LLVMSetInitializer(typeInfoGlobal, typeInfo.getLlvmValue()) LLVMSetInitializer(typeInfoGlobal, typeInfo.getLlvmValue())
LLVMSetGlobalConstant(typeInfoGlobal, 1) LLVMSetGlobalConstant(typeInfoGlobal, 1)
} }
} }
backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/native/llvm/Runtime.kt
+19 -18
View File
@@ -7,32 +7,33 @@ class Runtime(private val bitcodeFile: String) {
val llvmModule: LLVMOpaqueModule val llvmModule: LLVMOpaqueModule
init { init {
val arena = Arena() val arena = Arena()
try { try {
val bufRef = arena.alloc(LLVMOpaqueMemoryBuffer.ref) val bufRef = arena.alloc(LLVMOpaqueMemoryBuffer.ref)
val errorRef = arena.alloc(Int8Box.ref) val errorRef = arena.alloc(Int8Box.ref)
val res = LLVMCreateMemoryBufferWithContentsOfFile(bitcodeFile, bufRef, errorRef) val res = LLVMCreateMemoryBufferWithContentsOfFile(bitcodeFile, bufRef, errorRef)
if (res != 0) { if (res != 0) {
throw Error(errorRef.value?.asCString()?.toString()) throw Error(errorRef.value?.asCString()?.toString())
} }
val moduleRef = arena.alloc(LLVMOpaqueModule.ref) val moduleRef = arena.alloc(LLVMOpaqueModule.ref)
val parseRes = LLVMParseBitcode2(bufRef.value, moduleRef) val parseRes = LLVMParseBitcode2(bufRef.value, moduleRef)
if (parseRes != 0) { if (parseRes != 0) {
throw Error(parseRes.toString()) throw Error(parseRes.toString())
} }
llvmModule = moduleRef.value!! llvmModule = moduleRef.value!!
} finally { } finally {
arena.clear() arena.clear()
} }
} }
val typeInfoType = LLVMGetTypeByName(llvmModule, "struct.TypeInfo") val typeInfoType = LLVMGetTypeByName(llvmModule, "struct.TypeInfo")
val fieldTableRecordType = LLVMGetTypeByName(llvmModule, "struct.FieldTableRecord") val fieldTableRecordType = LLVMGetTypeByName(llvmModule, "struct.FieldTableRecord")
val methodTableRecordType = LLVMGetTypeByName(llvmModule, "struct.MethodTableRecord") val methodTableRecordType = LLVMGetTypeByName(llvmModule, "struct.MethodTableRecord")
val globalhHashType = LLVMGetTypeByName(llvmModule, "struct.GlobalHash")
val target = LLVMGetTarget(llvmModule)!!.asCString().toString() val target = LLVMGetTarget(llvmModule)!!.asCString().toString()
@@ -40,4 +41,4 @@ class Runtime(private val bitcodeFile: String) {
val targetData = LLVMCreateTargetData(dataLayout) val targetData = LLVMCreateTargetData(dataLayout)
} }
backend.native/tests/codegen/klass/basic.kt
+3
View File
@@ -0,0 +1,3 @@
class Foo {
var x : Int = 3
}
runtime/src/main/cpp/City.cpp
+218
View File
@@ -0,0 +1,218 @@
#include "City.h"
#include <string.h>
#include <algorithm>
namespace {
// Some primes between 2^63 and 2^64 for various uses.
static const uint64_t k0 = 0xc3a5c85c97cb3127ULL;
static const uint64_t k1 = 0xb492b66fbe98f273ULL;
static const uint64_t k2 = 0x9ae16a3b2f90404fULL;
// Magic numbers for 32-bit hashing. Copied from Murmur3.
static const uint32_t c1 = 0xcc9e2d51;
static const uint32_t c2 = 0x1b873593;
uint64_t UNALIGNED_LOAD64(const char *p) {
uint64_t result;
memcpy(&result, p, sizeof(result));
return result;
}
uint32_t UNALIGNED_LOAD32(const char *p) {
uint32_t result;
memcpy(&result, p, sizeof(result));
return result;
}
#define bswap32(x) __builtin_bswap32(x)
#define bswap64(x) __builtin_bswap64(x)
#ifdef WORDS_BIGENDIAN
#define uint32_in_expected_order(x) (bswap32(x))
#define uint64_in_expected_order(x) (bswap64(x))
#else
#define uint32_in_expected_order(x) (x)
#define uint64_in_expected_order(x) (x)
#endif
uint64_t Fetch64(const char *p) {
return uint64_in_expected_order(UNALIGNED_LOAD64(p));
}
uint32_t Fetch32(const char *p) {
return uint32_in_expected_order(UNALIGNED_LOAD32(p));
}
uint32_t Rotate32(uint32_t val, int shift) {
// Avoid shifting by 32: doing so yields an undefined result.
return shift == 0 ? val : ((val >> shift) | (val << (32 - shift)));
}
// Bitwise right rotate. Normally this will compile to a single
// instruction, especially if the shift is a manifest constant.
uint64_t Rotate(uint64_t val, int shift) {
// Avoid shifting by 64: doing so yields an undefined result.
return shift == 0 ? val : ((val >> shift) | (val << (64 - shift)));
}
uint64_t ShiftMix(uint64_t val) {
return val ^ (val >> 47);
}
uint64_t HashLen16(uint64_t u, uint64_t v, uint64_t mul) {
// Murmur-inspired hashing.
uint64_t a = (u ^ v) * mul;
a ^= (a >> 47);
uint64_t b = (v ^ a) * mul;
b ^= (b >> 47);
b *= mul;
return b;
}
typedef std::pair<uint64_t, uint64_t> uint128_t;
uint64_t Hash128to64(const uint128_t& x) {
// Murmur-inspired hashing.
const uint64_t kMul = 0x9ddfea08eb382d69ULL;
uint64_t a = (x.first ^ x.second) * kMul;
a ^= (a >> 47);
uint64_t b = (x.second ^ a) * kMul;
b ^= (b >> 47);
b *= kMul;
return b;
}
uint64_t HashLen16(uint64_t u, uint64_t v) {
return Hash128to64(uint128_t(u, v));
}
uint64_t HashLen0to16(const char *s, size_t len) {
if (len >= 8) {
uint64_t mul = k2 + len * 2;
uint64_t a = Fetch64(s) + k2;
uint64_t b = Fetch64(s + len - 8);
uint64_t c = Rotate(b, 37) * mul + a;
uint64_t d = (Rotate(a, 25) + b) * mul;
return HashLen16(c, d, mul);
}
if (len >= 4) {
uint64_t mul = k2 + len * 2;
uint64_t a = Fetch32(s);
return HashLen16(len + (a << 3), Fetch32(s + len - 4), mul);
}
if (len > 0) {
uint8_t a = s[0];
uint8_t b = s[len >> 1];
uint8_t c = s[len - 1];
uint32_t y = static_cast<uint32_t>(a) + (static_cast<uint32_t>(b) << 8);
uint32_t z = len + (static_cast<uint32_t>(c) << 2);
return ShiftMix(y * k2 ^ z * k0) * k2;
}
return k2;
}
// This probably works well for 16-byte strings as well, but it may be overkill
// in that case.
static uint64_t HashLen17to32(const char *s, size_t len) {
uint64_t mul = k2 + len * 2;
uint64_t a = Fetch64(s) * k1;
uint64_t b = Fetch64(s + 8);
uint64_t c = Fetch64(s + len - 8) * mul;
uint64_t d = Fetch64(s + len - 16) * k2;
return HashLen16(Rotate(a + b, 43) + Rotate(c, 30) + d,
a + Rotate(b + k2, 18) + c, mul);
}
// Return a 16-byte hash for 48 bytes. Quick and dirty.
// Callers do best to use "random-looking" values for a and b.
std::pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
uint64_t w, uint64_t x, uint64_t y, uint64_t z, uint64_t a, uint64_t b) {
a += w;
b = Rotate(b + a + z, 21);
uint64_t c = a;
a += x;
a += y;
b += Rotate(a, 44);
return std::make_pair(a + z, b + c);
}
// Return a 16-byte hash for s[0] ... s[31], a, and b. Quick and dirty.
std::pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
const char* s, uint64_t a, uint64_t b) {
return WeakHashLen32WithSeeds(Fetch64(s),
Fetch64(s + 8),
Fetch64(s + 16),
Fetch64(s + 24),
a,
b);
}
// Return an 8-byte hash for 33 to 64 bytes.
uint64_t HashLen33to64(const char *s, size_t len) {
uint64_t mul = k2 + len * 2;
uint64_t a = Fetch64(s) * k2;
uint64_t b = Fetch64(s + 8);
uint64_t c = Fetch64(s + len - 24);
uint64_t d = Fetch64(s + len - 32);
uint64_t e = Fetch64(s + 16) * k2;
uint64_t f = Fetch64(s + 24) * 9;
uint64_t g = Fetch64(s + len - 8);
uint64_t h = Fetch64(s + len - 16) * mul;
uint64_t u = Rotate(a + g, 43) + (Rotate(b, 30) + c) * 9;
uint64_t v = ((a + g) ^ d) + f + 1;
uint64_t w = bswap64((u + v) * mul) + h;
uint64_t x = Rotate(e + f, 42) + c;
uint64_t y = (bswap64((v + w) * mul) + g) * mul;
uint64_t z = e + f + c;
a = bswap64((x + z) * mul + y) + b;
b = ShiftMix((z + a) * mul + d + h) * mul;
return b + x;
}
} // namespace
extern "C" {
uint64_t CityHash64(const void* data, size_t len) {
const char* s = reinterpret_cast<const char*>(data);
if (len <= 32) {
if (len <= 16) {
return HashLen0to16(s, len);
} else {
return HashLen17to32(s, len);
}
} else if (len <= 64) {
return HashLen33to64(s, len);
}
// For strings over 64 bytes we hash the end first, and then as we
// loop we keep 56 bytes of state: v, w, x, y, and z.
uint64_t x = Fetch64(s + len - 40);
uint64_t y = Fetch64(s + len - 16) + Fetch64(s + len - 56);
uint64_t z = HashLen16(Fetch64(s + len - 48) + len, Fetch64(s + len - 24));
std::pair<uint64_t, uint64_t> v = WeakHashLen32WithSeeds(s + len - 64, len, z);
std::pair<uint64_t, uint64_t> w = WeakHashLen32WithSeeds(s + len - 32, y + k1, x);
x = x * k1 + Fetch64(s);
// Decrease len to the nearest multiple of 64, and operate on 64-byte chunks.
len = (len - 1) & ~static_cast<size_t>(63);
do {
x = Rotate(x + y + v.first + Fetch64(s + 8), 37) * k1;
y = Rotate(y + v.second + Fetch64(s + 48), 42) * k1;
x ^= w.second;
y += v.first + Fetch64(s + 40);
z = Rotate(z + w.first, 33) * k1;
v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first);
w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16));
std::swap(z, x);
s += 64;
len -= 64;
} while (len != 0);
return HashLen16(HashLen16(v.first, w.first) + ShiftMix(y) * k1 + z,
HashLen16(v.second, w.second) + x);
}
} // extern "C"
runtime/src/main/cpp/City.h
+20
View File
@@ -0,0 +1,20 @@
#ifndef RUNTIME_CITY_H
#define RUNTIME_CITY_H
// CityHash, by Geoff Pike and Jyrki Alakuijala.
#include <stddef.h>
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
// Hash function for a byte array.
uint64_t CityHash64(const void* buf, size_t len);
#ifdef __cplusplus
}
#endif
#endif // RUNTIME_CITY_H
runtime/src/main/cpp/Names.cpp
+2 -1
View File
@@ -2,6 +2,7 @@
#include "Names.h" #include "Names.h"
#include "City.h"
#include "Sha1.h" #include "Sha1.h"
namespace { namespace {
@@ -21,7 +22,7 @@ extern "C" {
// Make local hash out of arbitrary data. // Make local hash out of arbitrary data.
void MakeLocalHash(const void* data, uint32_t size, LocalHash* hash) { void MakeLocalHash(const void* data, uint32_t size, LocalHash* hash) {
assert(false); // not implemented yet *hash = CityHash64(data, size);
} }
// Make global hash out of arbitrary data. // Make global hash out of arbitrary data.
runtime/src/main/cpp/Names.h
+2 -2
View File
@@ -6,12 +6,12 @@
// All names in system are stored as hashes (or maybe, for debug builds, // All names in system are stored as hashes (or maybe, for debug builds,
// as pointers to uniqued C strings containing names?). // as pointers to uniqued C strings containing names?).
// There are two types of hashes: // There are two types of hashes:
// - local hash, must be unique per class (CitiHash64 is being used) // - local hash, must be unique per class (CityHash64 is being used)
// - global hash, must be unique globally (SHA1 is being used) // - global hash, must be unique globally (SHA1 is being used)
// Generic guideline is that global hash is being used in global persistent context, while local // Generic guideline is that global hash is being used in global persistent context, while local
// hashes are more local in scope. // hashes are more local in scope.
// Local hash. // Local hash.
typedef int64_t LocalHash; typedef uint64_t LocalHash;
// Hash of field name. // Hash of field name.
typedef LocalHash FieldNameHash; typedef LocalHash FieldNameHash;
// Hash of open method name. // Hash of open method name.
runtime/src/main/cpp/Sha1.h
-1
View File
@@ -1,6 +1,5 @@
#ifndef RUNTIME_SHA1_H #ifndef RUNTIME_SHA1_H
#define RUNTIME_SHA1_H #define RUNTIME_SHA1_H
/* ================ sha1.h ================ */
/* /*
SHA-1 in C SHA-1 in C
By Steve Reid <steve@edmweb.com> By Steve Reid <steve@edmweb.com>