From 0c946de3ca2c08b775074b7535ac80503013fe72 Mon Sep 17 00:00:00 2001 From: Brian Fiete Date: Thu, 2 Jul 2020 11:05:17 -0700 Subject: [PATCH] Added RefType, changed how CRepr types are represented --- BeefLibs/corlib/src/String.bf | 2 +- BeefLibs/corlib/src/Type.bf | 50 ++++++++-- IDE/mintest/minlib/src/System/Type.bf | 113 ++++++++++++++++++++--- IDEHelper/Backend/BeIRCodeGen.cpp | 45 ++++++++- IDEHelper/Backend/BeIRCodeGen.h | 9 +- IDEHelper/Compiler/BfCompiler.cpp | 2 + IDEHelper/Compiler/BfCompiler.h | 1 + IDEHelper/Compiler/BfIRBuilder.cpp | 37 +++++++- IDEHelper/Compiler/BfIRBuilder.h | 12 +++ IDEHelper/Compiler/BfIRCodeGen.cpp | 28 +++++- IDEHelper/Compiler/BfIRCodeGen.h | 1 + IDEHelper/Compiler/BfModule.cpp | 38 ++++++-- IDEHelper/Compiler/BfModuleTypeUtils.cpp | 13 ++- 13 files changed, 311 insertions(+), 40 deletions(-) diff --git a/BeefLibs/corlib/src/String.bf b/BeefLibs/corlib/src/String.bf index a3ca6957..9060aec1 100644 --- a/BeefLibs/corlib/src/String.bf +++ b/BeefLibs/corlib/src/String.bf @@ -36,7 +36,7 @@ namespace System NFKC = Stable | Compose | Compat, } - [CRepr] + [Ordered] class String : IHashable, IFormattable, IPrintable, IOpComparable { enum CreateFlags diff --git a/BeefLibs/corlib/src/Type.bf b/BeefLibs/corlib/src/Type.bf index b77d8ab3..8df7f21d 100644 --- a/BeefLibs/corlib/src/Type.bf +++ b/BeefLibs/corlib/src/Type.bf @@ -12,7 +12,7 @@ namespace System // including the vtable and interface slots } - [CRepr, AlwaysInclude(AssumeInstantiated=true)] + [Ordered, AlwaysInclude(AssumeInstantiated=true)] public class Type { extern const Type* sTypes; @@ -558,7 +558,7 @@ namespace System.Reflection } } - [CRepr, AlwaysInclude(AssumeInstantiated=true)] + [Ordered, AlwaysInclude(AssumeInstantiated=true)] public class TypeInstance : Type { [CRepr, AlwaysInclude] @@ -770,7 +770,7 @@ namespace System.Reflection } } - [CRepr, AlwaysInclude(AssumeInstantiated=true)] + [Ordered, AlwaysInclude(AssumeInstantiated=true)] class PointerType : Type { TypeId mElementType; @@ -790,7 +790,43 @@ namespace System.Reflection } } - [CRepr, AlwaysInclude(AssumeInstantiated=true)] + [Ordered, AlwaysInclude(AssumeInstantiated=true)] + class RefType : Type + { + public enum RefKind + { + Ref, + Out, + Mut + } + + TypeId mElementType; + RefKind mRefKind; + + public RefKind RefKind => mRefKind; + + public override Type UnderlyingType + { + get + { + return Type.[Friend]GetType(mElementType); + } + } + + public override void GetFullName(String strBuffer) + { + switch (mRefKind) + { + case .Ref: strBuffer.Append("ref "); + case .Out: strBuffer.Append("out "); + case .Mut: strBuffer.Append("mut "); + } + + UnderlyingType.GetFullName(strBuffer); + } + } + + [Ordered, AlwaysInclude(AssumeInstantiated=true)] class SizedArrayType : Type { TypeId mElementType; @@ -821,7 +857,7 @@ namespace System.Reflection } } - [CRepr, AlwaysInclude(AssumeInstantiated=true)] + [Ordered, AlwaysInclude(AssumeInstantiated=true)] class UnspecializedGenericType : TypeInstance { [CRepr, AlwaysInclude] @@ -834,7 +870,7 @@ namespace System.Reflection } // Only for resolved types - [CRepr, AlwaysInclude(AssumeInstantiated=true)] + [Ordered, AlwaysInclude(AssumeInstantiated=true)] class SpecializedGenericType : TypeInstance { TypeId mUnspecializedType; @@ -880,7 +916,7 @@ namespace System.Reflection } } - [CRepr, AlwaysInclude(AssumeInstantiated=true)] + [Ordered, AlwaysInclude(AssumeInstantiated=true)] class ArrayType : SpecializedGenericType { int32 mElementSize; diff --git a/IDE/mintest/minlib/src/System/Type.bf b/IDE/mintest/minlib/src/System/Type.bf index b4dd702e..8df7f21d 100644 --- a/IDE/mintest/minlib/src/System/Type.bf +++ b/IDE/mintest/minlib/src/System/Type.bf @@ -12,7 +12,7 @@ namespace System // including the vtable and interface slots } - [CRepr, AlwaysInclude(AssumeInstantiated=true)] + [Ordered, AlwaysInclude(AssumeInstantiated=true)] public class Type { extern const Type* sTypes; @@ -35,6 +35,14 @@ namespace System } } + public static Enumerator Types + { + get + { + return .(); + } + } + public int32 Size { get @@ -461,6 +469,35 @@ namespace System { return FieldInfo.Enumerator(null, bindingFlags); } + + public Result GetCustomAttribute() where T : Attribute + { + if (var typeInstance = this as TypeInstance) + return typeInstance.[Friend]GetCustomAttribute(typeInstance.[Friend]mCustomAttributesIdx); + return .Err; + } + + public override void ToString(String strBuffer) + { + GetFullName(strBuffer); + } + + public struct Enumerator : IEnumerator + { + int32 mCurId; + + public Result GetNext() mut + { + while (true) + { + if (mCurId >= sTypeCount) + return .Err; + let type = sTypes[mCurId++]; + if (type != null) + return .Ok(type); + } + } + } } enum TypeCode : uint8 @@ -521,7 +558,7 @@ namespace System.Reflection } } - [CRepr, AlwaysInclude(AssumeInstantiated=true)] + [Ordered, AlwaysInclude(AssumeInstantiated=true)] public class TypeInstance : Type { [CRepr, AlwaysInclude] @@ -588,15 +625,14 @@ namespace System.Reflection uint8 mInterfaceCount; int16 mMethodDataCount; int16 mPropertyDataCount; - int16 mFieldDataCount; + int16 mFieldDataCount; void* mInterfaceDataPtr; MethodData* mMethodDataPtr; void* mPropertyDataPtr; - FieldData* mFieldDataPtr; + FieldData* mFieldDataPtr; void** mCustomAttrDataPtr; - public override int32 InstanceSize { get @@ -716,9 +752,25 @@ namespace System.Reflection { return FieldInfo.Enumerator(this, bindingFlags); } + + Result GetCustomAttribute(int customAttributeIdx) where T : Attribute + { + if (customAttributeIdx == -1) + return .Err; + + void* data = mCustomAttrDataPtr[customAttributeIdx]; + + T attrInst = ?; + switch (AttributeInfo.GetCustomAttribute(data, typeof(T), &attrInst)) + { + case .Ok: return .Ok(attrInst); + default: + return .Err; + } + } } - [CRepr, AlwaysInclude(AssumeInstantiated=true)] + [Ordered, AlwaysInclude(AssumeInstantiated=true)] class PointerType : Type { TypeId mElementType; @@ -738,7 +790,43 @@ namespace System.Reflection } } - [CRepr, AlwaysInclude(AssumeInstantiated=true)] + [Ordered, AlwaysInclude(AssumeInstantiated=true)] + class RefType : Type + { + public enum RefKind + { + Ref, + Out, + Mut + } + + TypeId mElementType; + RefKind mRefKind; + + public RefKind RefKind => mRefKind; + + public override Type UnderlyingType + { + get + { + return Type.[Friend]GetType(mElementType); + } + } + + public override void GetFullName(String strBuffer) + { + switch (mRefKind) + { + case .Ref: strBuffer.Append("ref "); + case .Out: strBuffer.Append("out "); + case .Mut: strBuffer.Append("mut "); + } + + UnderlyingType.GetFullName(strBuffer); + } + } + + [Ordered, AlwaysInclude(AssumeInstantiated=true)] class SizedArrayType : Type { TypeId mElementType; @@ -769,7 +857,7 @@ namespace System.Reflection } } - [CRepr, AlwaysInclude(AssumeInstantiated=true)] + [Ordered, AlwaysInclude(AssumeInstantiated=true)] class UnspecializedGenericType : TypeInstance { [CRepr, AlwaysInclude] @@ -782,7 +870,7 @@ namespace System.Reflection } // Only for resolved types - [CRepr, AlwaysInclude(AssumeInstantiated=true)] + [Ordered, AlwaysInclude(AssumeInstantiated=true)] class SpecializedGenericType : TypeInstance { TypeId mUnspecializedType; @@ -828,7 +916,7 @@ namespace System.Reflection } } - [CRepr, AlwaysInclude(AssumeInstantiated=true)] + [Ordered, AlwaysInclude(AssumeInstantiated=true)] class ArrayType : SpecializedGenericType { int32 mElementSize; @@ -890,7 +978,7 @@ namespace System.Reflection EnumDiscriminator = 0x0200 } - public enum MethodFlags : int16 + public enum MethodFlags : uint16 { MethodAccessMask = 0x0007, PrivateScope = 0x0000, // Member not referenceable. @@ -923,6 +1011,7 @@ namespace System.Reflection StdCall = 0x1000, FastCall = 0x2000, ThisCall = 0x3000, // Purposely resuing StdCall|FastCall - Mutating = 0x4000 + Mutating = 0x4000, + Constructor = 0x8000, } } diff --git a/IDEHelper/Backend/BeIRCodeGen.cpp b/IDEHelper/Backend/BeIRCodeGen.cpp index bc087013..5a87cb69 100644 --- a/IDEHelper/Backend/BeIRCodeGen.cpp +++ b/IDEHelper/Backend/BeIRCodeGen.cpp @@ -216,10 +216,6 @@ BF_STATIC_ASSERT(BF_ARRAY_COUNT(gIRCmdNames) == BfIRCmd_COUNT); #define CMD_PARAM(ty, name) ty name; Read(name); -template -class CmdParamVec : public SizedArray -{}; - BeIRCodeGen::BeIRCodeGen() { mBfIRBuilder = NULL; @@ -390,6 +386,33 @@ BeIRTypeEntry& BeIRCodeGen::GetTypeEntry(int typeId) return typeEntry; } +void BeIRCodeGen::FixValues(BeStructType* structType, CmdParamVec& values) +{ + if (values.size() >= structType->mMembers.size()) + return; + + int readIdx = values.size() - 1; + values.resize(structType->mMembers.size()); + for (int i = (int)values.size() - 1; i >= 0; i--) + { + if (mBeContext->AreTypesEqual(values[readIdx]->GetType(), structType->mMembers[i].mType)) + { + values[i] = values[readIdx]; + readIdx--; + } + else if (structType->mMembers[i].mType->IsSizedArray()) + { + auto beConst = mBeModule->mAlloc.Alloc(); + beConst->mType = structType->mMembers[i].mType; + values[i] = beConst; + } + else + { + FatalError("Malformed structure values"); + } + } +} + void BeIRCodeGen::Init(const BfSizedArray& buffer) { BP_ZONE("BeIRCodeGen::Init"); @@ -754,6 +777,15 @@ void BeIRCodeGen::Read(BeValue*& beValue) BE_MEM_END("ParamType_Const_Array"); return; } + else if (constType == BfConstType_ArrayZero8) + { + CMD_PARAM(int, count); + auto beType = mBeContext->CreateSizedArrayType(mBeContext->GetPrimitiveType(BeTypeCode_Int8), count); + auto beConst = mBeModule->mAlloc.Alloc(); + beConst->mType = beType; + beValue = beConst; + return; + } bool isSigned = false; BeType* llvmConstType = GetBeType(typeCode, isSigned); @@ -1054,11 +1086,14 @@ void BeIRCodeGen::HandleNextCmd() auto constStruct = mBeModule->mOwnedValues.Alloc(); constStruct->mType = type; BF_ASSERT(type->IsStruct()); + + FixValues((BeStructType*)type, values); + BF_ASSERT(((BeStructType*)type)->mMembers.size() == values.size()); for (int i = 0; i < (int)values.size(); i++) { auto val = values[i]; - BF_ASSERT(((BeStructType*)type)->mMembers[i].mType == val->GetType()); + BF_ASSERT(mBeContext->AreTypesEqual(((BeStructType*)type)->mMembers[i].mType, val->GetType())); constStruct->mMemberValues.push_back(BeValueDynCast(val)); } SetResult(curId, constStruct); diff --git a/IDEHelper/Backend/BeIRCodeGen.h b/IDEHelper/Backend/BeIRCodeGen.h index 72702086..0f3beee8 100644 --- a/IDEHelper/Backend/BeIRCodeGen.h +++ b/IDEHelper/Backend/BeIRCodeGen.h @@ -53,6 +53,11 @@ public: } }; + +template +class CmdParamVec : public SizedArray +{}; + class BeIRCodeGen : public BfIRCodeGenBase { public: @@ -83,7 +88,9 @@ public: void SetResult(int id, BeMDNode* md); BeType* GetBeType(BfTypeCode typeCode, bool& isSigned); - BeIRTypeEntry& GetTypeEntry(int typeId); + BeIRTypeEntry& GetTypeEntry(int typeId); + + void FixValues(BeStructType* structType, CmdParamVec& values); public: BeIRCodeGen(); diff --git a/IDEHelper/Compiler/BfCompiler.cpp b/IDEHelper/Compiler/BfCompiler.cpp index 6f28681c..c0e75761 100644 --- a/IDEHelper/Compiler/BfCompiler.cpp +++ b/IDEHelper/Compiler/BfCompiler.cpp @@ -418,6 +418,7 @@ BfCompiler::BfCompiler(BfSystem* bfSystem, bool isResolveOnly) mReflectMethodDataDef = NULL; mReflectParamDataDef = NULL; mReflectPointerType = NULL; + mReflectRefType = NULL; mReflectSizedArrayType = NULL; mReflectSpecializedGenericType = NULL; mReflectTypeInstanceTypeDef = NULL; @@ -6218,6 +6219,7 @@ bool BfCompiler::DoCompile(const StringImpl& outputDirectory) mReflectMethodDataDef = _GetRequiredType("System.Reflection.TypeInstance.MethodData"); mReflectParamDataDef = _GetRequiredType("System.Reflection.TypeInstance.ParamData"); mReflectPointerType = _GetRequiredType("System.Reflection.PointerType"); + mReflectRefType = _GetRequiredType("System.Reflection.RefType"); mReflectSizedArrayType = _GetRequiredType("System.Reflection.SizedArrayType"); mReflectSpecializedGenericType = _GetRequiredType("System.Reflection.SpecializedGenericType"); mReflectTypeInstanceTypeDef = _GetRequiredType("System.Reflection.TypeInstance"); diff --git a/IDEHelper/Compiler/BfCompiler.h b/IDEHelper/Compiler/BfCompiler.h index 0ec7a44c..010ccbf3 100644 --- a/IDEHelper/Compiler/BfCompiler.h +++ b/IDEHelper/Compiler/BfCompiler.h @@ -369,6 +369,7 @@ public: BfTypeDef* mReflectMethodDataDef; BfTypeDef* mReflectParamDataDef; BfTypeDef* mReflectPointerType; + BfTypeDef* mReflectRefType; BfTypeDef* mReflectSizedArrayType; BfTypeDef* mReflectSpecializedGenericType; BfTypeDef* mReflectTypeInstanceTypeDef; diff --git a/IDEHelper/Compiler/BfIRBuilder.cpp b/IDEHelper/Compiler/BfIRBuilder.cpp index 93acd878..b8448a8a 100644 --- a/IDEHelper/Compiler/BfIRBuilder.cpp +++ b/IDEHelper/Compiler/BfIRBuilder.cpp @@ -655,6 +655,33 @@ BfIRValue BfIRConstHolder::CreateConstArray(BfIRType type, const BfSizedArray(); + constant->mConstType = BfConstType_ArrayZero; + constant->mType = type = type; + constant->mCount = count; + auto irValue = BfIRValue(BfIRValueFlags_Const, mTempAlloc.GetChunkedId(constant)); + +#ifdef CHECK_CONSTHOLDER + irValue.mHolder = this; +#endif + return irValue; +} + +BfIRValue BfIRConstHolder::CreateConstArrayZero(int count) +{ + BfConstant* constant = mTempAlloc.Alloc(); + constant->mConstType = BfConstType_ArrayZero8; + constant->mInt64 = count; + auto irValue = BfIRValue(BfIRValueFlags_Const, mTempAlloc.GetChunkedId(constant)); + +#ifdef CHECK_CONSTHOLDER + irValue.mHolder = this; +#endif + return irValue; +} + BfIRValue BfIRConstHolder::CreateTypeOf(BfType* type) { BfTypeOf_Const* typeOf = mTempAlloc.Alloc(); @@ -1779,6 +1806,11 @@ void BfIRBuilder::Write(const BfIRValue& irValue) Write(arrayConst->mValues); } break; + case (int)BfConstType_ArrayZero8: + { + Write(constant->mInt64); + } + break; default: { BF_FATAL("Unhandled"); @@ -3026,7 +3058,8 @@ void BfIRBuilder::CreateTypeDefinition(BfType* type, bool forceDbgDefine) BfIRType resolvedFieldIRType = MapType(resolvedFieldType); - bool needsExplicitAlignment = !isCRepr || resolvedFieldType->NeedsExplicitAlignment(); + //bool needsExplicitAlignment = !isCRepr || resolvedFieldType->NeedsExplicitAlignment(); + bool needsExplicitAlignment = true; if (!needsExplicitAlignment) { int alignSize = resolvedFieldType->mAlign; @@ -3075,7 +3108,7 @@ void BfIRBuilder::CreateTypeDefinition(BfType* type, bool forceDbgDefine) } if (!typeInstance->IsTypedPrimitive()) - StructSetBody(MapTypeInst(typeInstance), irFieldTypes, isPacked || !isCRepr); + StructSetBody(MapTypeInst(typeInstance), irFieldTypes, /*isPacked || !isCRepr*/true); if (typeInstance->IsNullable()) { diff --git a/IDEHelper/Compiler/BfIRBuilder.h b/IDEHelper/Compiler/BfIRBuilder.h index 7e1b7039..32efe462 100644 --- a/IDEHelper/Compiler/BfIRBuilder.h +++ b/IDEHelper/Compiler/BfIRBuilder.h @@ -137,6 +137,8 @@ enum BfConstType BfConstType_TypeOf, BfConstType_AggZero, BfConstType_Array, + BfConstType_ArrayZero, + BfConstType_ArrayZero8, BfConstType_Undef, BfConstType_SizedArrayType }; @@ -176,6 +178,7 @@ enum BfIRCmd : uint8 BfIRCmd_CreateConstStruct, BfIRCmd_CreateConstStructZero, BfIRCmd_CreateConstArray, + BfIRCmd_CreateConstArrayZero, BfIRCmd_CreateConstString, BfIRCmd_ConfigConst, @@ -828,6 +831,13 @@ struct BfConstantArray BfSizedArray mValues; }; +struct BfConstantArrayZero +{ + BfConstType mConstType; + BfIRType mType; + int mCount; +}; + class BfIRConstHolder { public: @@ -859,6 +869,8 @@ public: BfIRValue CreateConstNull(BfIRType nullType); BfIRValue CreateConstStructZero(BfIRType aggType); BfIRValue CreateConstArray(BfIRType type, const BfSizedArray& values); + BfIRValue CreateConstArrayZero(BfIRType type, int count); + BfIRValue CreateConstArrayZero(int count); BfIRValue CreateTypeOf(BfType* type); BfIRValue GetUndefConstValue(BfTypeCode typeCode); }; diff --git a/IDEHelper/Compiler/BfIRCodeGen.cpp b/IDEHelper/Compiler/BfIRCodeGen.cpp index 28ea6c5a..0187ea38 100644 --- a/IDEHelper/Compiler/BfIRCodeGen.cpp +++ b/IDEHelper/Compiler/BfIRCodeGen.cpp @@ -377,6 +377,31 @@ void BfIRCodeGen::PrintFunction() os.flush(); } +void BfIRCodeGen::FixValues(llvm::StructType* structType, llvm::SmallVector& values) +{ + if (values.size() >= structType->getNumElements()) + return; + + int readIdx = (int)values.size() - 1; + values.resize(structType->getNumElements()); + for (int i = (int)values.size() - 1; i >= 0; i--) + { + if (values[readIdx]->getType() == structType->getElementType(i)) + { + values[i] = values[readIdx]; + readIdx--; + } + else if (structType->getElementType(i)->isArrayTy()) + { + values[i] = llvm::ConstantAggregateZero::get(structType->getElementType(i)); + } + else + { + BF_FATAL("Malformed structure values"); + } + } +} + BfTypeCode BfIRCodeGen::GetTypeCode(llvm::Type* type, bool isSigned) { if (type->isIntegerTy()) @@ -1267,8 +1292,9 @@ void BfIRCodeGen::HandleNextCmd() CMD_PARAM(llvm::Type*, type); CMD_PARAM(CmdParamVec, values) llvm::SmallVector copyValues; + FixValues((llvm::StructType*)type, values); for (auto val : values) - copyValues.push_back(llvm::dyn_cast(val)); + copyValues.push_back(llvm::dyn_cast(val)); SetResult(curId, llvm::ConstantStruct::get((llvm::StructType*)type, copyValues)); } break; diff --git a/IDEHelper/Compiler/BfIRCodeGen.h b/IDEHelper/Compiler/BfIRCodeGen.h index b131e7f8..4fe69e87 100644 --- a/IDEHelper/Compiler/BfIRCodeGen.h +++ b/IDEHelper/Compiler/BfIRCodeGen.h @@ -88,6 +88,7 @@ public: Array mConfigConsts64; public: + void FixValues(llvm::StructType* structType, llvm::SmallVector& values); BfTypeCode GetTypeCode(llvm::Type* type, bool isSigned); llvm::Type* GetLLVMType(BfTypeCode typeCode, bool& isSigned); BfIRTypeEntry& GetTypeEntry(int typeId); diff --git a/IDEHelper/Compiler/BfModule.cpp b/IDEHelper/Compiler/BfModule.cpp index 56727f49..d4b03ade 100644 --- a/IDEHelper/Compiler/BfModule.cpp +++ b/IDEHelper/Compiler/BfModule.cpp @@ -4335,11 +4335,9 @@ void BfModule::CreateValueTypeEqualsMethod(bool strictEquals) auto baseTypeInst = compareTypeInst->mBaseType; if ((baseTypeInst != NULL) && (baseTypeInst->mTypeDef != mCompiler->mValueTypeTypeDef)) - { - BfTypedValue leftOrigValue(mCurMethodState->mLocals[0]->mValue, compareTypeInst, true); - BfTypedValue rightOrigValue(mCurMethodState->mLocals[1]->mValue, compareTypeInst, true); - BfTypedValue leftValue = Cast(NULL, leftOrigValue, baseTypeInst); - BfTypedValue rightValue = Cast(NULL, rightOrigValue, baseTypeInst); + { + BfTypedValue leftValue = Cast(NULL, leftTypedVal, baseTypeInst); + BfTypedValue rightValue = Cast(NULL, rightTypedVal, baseTypeInst); EmitEquals(leftValue, rightValue, exitBB, strictEquals); } } @@ -4639,6 +4637,8 @@ BfIRValue BfModule::CreateTypeData(BfType* type, Dictionary& usedStrin } else if (type->IsPointer()) typeDataSource = ResolveTypeDef(mCompiler->mReflectPointerType)->ToTypeInstance(); + else if (type->IsRef()) + typeDataSource = ResolveTypeDef(mCompiler->mReflectRefType)->ToTypeInstance(); else if (type->IsSizedArray()) typeDataSource = ResolveTypeDef(mCompiler->mReflectSizedArrayType)->ToTypeInstance(); else @@ -4700,6 +4700,11 @@ BfIRValue BfModule::CreateTypeData(BfType* type, Dictionary& usedStrin typeCode = BfTypeCode_Pointer; typeFlags |= BfTypeFlags_Pointer; } + else if (type->IsRef()) + { + typeCode = BfTypeCode_Pointer; + typeFlags |= BfTypeFlags_Pointer; + } if (type->IsObject()) { @@ -4781,6 +4786,23 @@ BfIRValue BfModule::CreateTypeData(BfType* type, Dictionary& usedStrin mBfIRBuilder->GlobalVar_SetAlignment(typeDataVar, mSystem->mPtrSize); typeDataVar = mBfIRBuilder->CreateBitCast(typeDataVar, mBfIRBuilder->MapType(mContext->mBfTypeType)); } + else if (type->IsRef()) + { + auto refType = (BfRefType*)type; + SizedArray refTypeDataParms = + { + typeData, + GetConstValue(refType->mElementType->mTypeId, typeIdType), + GetConstValue((int8)refType->mRefKind, byteType), + }; + + auto reflectRefType = ResolveTypeDef(mCompiler->mReflectRefType)->ToTypeInstance(); + auto refTypeData = mBfIRBuilder->CreateConstStruct(mBfIRBuilder->MapTypeInst(reflectRefType, BfIRPopulateType_Full), refTypeDataParms); + typeDataVar = mBfIRBuilder->CreateGlobalVariable(mBfIRBuilder->MapTypeInst(reflectRefType), true, + BfIRLinkageType_External, refTypeData, typeDataName); + mBfIRBuilder->GlobalVar_SetAlignment(typeDataVar, mSystem->mPtrSize); + typeDataVar = mBfIRBuilder->CreateBitCast(typeDataVar, mBfIRBuilder->MapType(mContext->mBfTypeType)); + } else if (type->IsSizedArray()) { auto sizedArrayType = (BfSizedArrayType*)type; @@ -6190,6 +6212,7 @@ BfIRValue BfModule::CreateTypeData(BfType* type, Dictionary& usedStrin SizedArray typeDataVals = { typeData, + castedClassVData, // mTypeClassVData typeNameConst, // mName namespaceConst, // mNamespace @@ -12823,9 +12846,10 @@ void BfModule::DoLocalVariableDebugInfo(BfLocalVariable* localVarDef, bool doAli BfLocalVariable* BfModule::AddLocalVariableDef(BfLocalVariable* localVarDef, bool addDebugInfo, bool doAliasValue, BfIRValue declareBefore, BfIRInitType initType) { - if ((localVarDef->mValue) && (!localVarDef->mAddr) && (IsTargetingBeefBackend())) + if ((localVarDef->mValue) && (!localVarDef->mAddr) && (IsTargetingBeefBackend()) && (!localVarDef->mResolvedType->IsValuelessType())) { - if ((!localVarDef->mValue.IsConst()) && (!localVarDef->mValue.IsArg()) && (!localVarDef->mValue.IsFake())) + if ((!localVarDef->mValue.IsConst()) && + (!localVarDef->mValue.IsArg()) && (!localVarDef->mValue.IsFake())) { mBfIRBuilder->CreateValueScopeRetain(localVarDef->mValue); mCurMethodState->mCurScope->mHadScopeValueRetain = true; diff --git a/IDEHelper/Compiler/BfModuleTypeUtils.cpp b/IDEHelper/Compiler/BfModuleTypeUtils.cpp index d87c27b9..caeb5ee2 100644 --- a/IDEHelper/Compiler/BfModuleTypeUtils.cpp +++ b/IDEHelper/Compiler/BfModuleTypeUtils.cpp @@ -2916,8 +2916,13 @@ bool BfModule::DoPopulateType(BfType* resolvedTypeRef, BfPopulateType populateTy } } - for (auto fieldInstance : dataFieldVec) + //bool needsExplicitAlignment = !isCRepr || ((typeInstance->mBaseType != NULL) && (!typeInstance->mBaseType->mIsCRepr)); + + bool needsExplicitAlignment = true; + + for (int fieldIdx = 0; fieldIdx < (int)dataFieldVec.size(); fieldIdx++) { + auto fieldInstance = dataFieldVec[fieldIdx]; auto resolvedFieldType = fieldInstance->GetResolvedType(); BF_ASSERT(resolvedFieldType->mSize >= 0); @@ -2925,14 +2930,14 @@ bool BfModule::DoPopulateType(BfType* resolvedTypeRef, BfPopulateType populateTy int alignSize = resolvedFieldType->mAlign; fieldInstance->mDataSize = dataSize; - bool needsExplicitAlignment = !isCRepr || resolvedFieldType->NeedsExplicitAlignment(); + //bool needsExplicitAlignment = !isCRepr || resolvedFieldType->NeedsExplicitAlignment(); int nextDataPos = dataPos; if (!isPacked) nextDataPos = (dataPos + (alignSize - 1)) & ~(alignSize - 1); int padding = nextDataPos - dataPos; if ((alignSize > 1) && (needsExplicitAlignment) && (padding > 0)) - { + { curFieldDataIdx++; } dataPos = nextDataPos; @@ -2941,7 +2946,7 @@ bool BfModule::DoPopulateType(BfType* resolvedTypeRef, BfPopulateType populateTy if (!isPacked) typeInstance->mInstAlign = std::max(typeInstance->mInstAlign, alignSize); - dataPos += dataSize; + dataPos += dataSize; } if (unionInnerType != NULL)