diff --git a/IDEHelper/Compiler/BfCompiler.cpp b/IDEHelper/Compiler/BfCompiler.cpp index b5e5e702..6c25707a 100644 --- a/IDEHelper/Compiler/BfCompiler.cpp +++ b/IDEHelper/Compiler/BfCompiler.cpp @@ -2009,7 +2009,7 @@ void BfCompiler::CreateVData(BfVDataModule* bfModule) int dataSize = 16*1024; auto irArrType = bfModule->mBfIRBuilder->GetSizedArrayType(bfModule->mBfIRBuilder->MapType(int8Type), dataSize); String name = "__BFTLS_EXTRA"; - auto irVal = bfModule->mBfIRBuilder->CreateGlobalVariable(irArrType, false, BfIRLinkageType_External, bfModule->mBfIRBuilder->CreateConstStructZero(irArrType), name, true); + auto irVal = bfModule->mBfIRBuilder->CreateGlobalVariable(irArrType, false, BfIRLinkageType_External, bfModule->mBfIRBuilder->CreateConstAggZero(irArrType), name, true); BfIRMDNode dbgArrayType = bfModule->mBfIRBuilder->DbgCreateArrayType(dataSize * 8, 8, bfModule->mBfIRBuilder->DbgGetType(int8Type), dataSize); bfModule->mBfIRBuilder->DbgCreateGlobalVariable(bfModule->mDICompileUnit, name, name, BfIRMDNode(), 0, dbgArrayType, false, irVal); } diff --git a/IDEHelper/Compiler/BfExprEvaluator.cpp b/IDEHelper/Compiler/BfExprEvaluator.cpp index 69c6d1d2..3cd4ae09 100644 --- a/IDEHelper/Compiler/BfExprEvaluator.cpp +++ b/IDEHelper/Compiler/BfExprEvaluator.cpp @@ -4492,31 +4492,29 @@ BfTypedValue BfExprEvaluator::LookupField(BfAstNode* targetSrc, BfTypedValue tar mModule->mBfIRBuilder->PopulateType(curCheckType); int tagIdx = -fieldInstance->mDataIdx - 1; if ((mBfEvalExprFlags & BfEvalExprFlags_AllowEnumId) != 0) - { + { return BfTypedValue(mModule->mBfIRBuilder->CreateConst(dscrType->mTypeDef->mTypeCode, tagIdx), fieldInstance->mOwner); } - mModule->PopulateType(fieldInstance->mOwner, BfPopulateType_Data); -// auto agg = mModule->mBfIRBuilder->CreateUndefValue(mModule->mBfIRBuilder->MapType(fieldInstance->mOwner)); -// agg = mModule->mBfIRBuilder->CreateInsertValue(agg, mModule->mBfIRBuilder->CreateConst(dscrType->mTypeDef->mTypeCode, tagIdx), 2); + + // OLD: +// auto agg = mModule->CreateAlloca(fieldInstance->mOwner); +// auto gep = mModule->mBfIRBuilder->CreateInBoundsGEP(agg, 0, 2); +// mModule->mBfIRBuilder->CreateStore(mModule->mBfIRBuilder->CreateConst(dscrType->mTypeDef->mTypeCode, tagIdx), gep); // // if (fieldInstance->mResolvedType->mSize != 0) // { // mModule->FailAfter("Enum case parameters expected", targetSrc); // } // -// return BfTypedValue(agg, fieldInstance->mOwner); +// return BfTypedValue(agg, fieldInstance->mOwner, true); - auto agg = mModule->CreateAlloca(fieldInstance->mOwner); - auto gep = mModule->mBfIRBuilder->CreateInBoundsGEP(agg, 0, 2); - mModule->mBfIRBuilder->CreateStore(mModule->mBfIRBuilder->CreateConst(dscrType->mTypeDef->mTypeCode, tagIdx), gep); - - if (fieldInstance->mResolvedType->mSize != 0) - { - mModule->FailAfter("Enum case parameters expected", targetSrc); - } - - return BfTypedValue(agg, fieldInstance->mOwner, true); + //NEW + SizedArray values; + values.Add(mModule->mBfIRBuilder->CreateConstAggZero(mModule->mBfIRBuilder->MapType(curCheckType->mBaseType))); + values.Add(mModule->mBfIRBuilder->CreateConstAggZero(mModule->mBfIRBuilder->MapType(curCheckType->GetUnionInnerType()))); + values.Add(mModule->mBfIRBuilder->CreateConst(dscrType->mTypeDef->mTypeCode, tagIdx)); + return BfTypedValue(mModule->mBfIRBuilder->CreateConstAgg(mModule->mBfIRBuilder->MapType(curCheckType), values), curCheckType); } if (fieldInstance->mConstIdx == -1) @@ -7640,7 +7638,13 @@ BfTypedValue BfExprEvaluator::CheckEnumCreation(BfAstNode* targetSrc, BfTypeInst BfIRValue enumValue; BfTypedValue result; - if ((mReceivingValue != NULL) && (mReceivingValue->mType == enumType) && (mReceivingValue->IsAddr())) + bool wantConst = IsComptimeEntry(); + + if (wantConst) + { + NOP; + } + else if ((mReceivingValue != NULL) && (mReceivingValue->mType == enumType) && (mReceivingValue->IsAddr())) { result = *mReceivingValue; mReceivingValue = NULL; @@ -7651,16 +7655,22 @@ BfTypedValue BfExprEvaluator::CheckEnumCreation(BfAstNode* targetSrc, BfTypeInst mResultIsTempComposite = true; enumValue = mModule->CreateAlloca(enumType); result = BfTypedValue(enumValue, fieldInstance->mOwner, BfTypedValueKind_TempAddr); - } + } BF_ASSERT(fieldInstance->mResolvedType->IsTuple()); auto tupleType = (BfTypeInstance*)fieldInstance->mResolvedType; mModule->mBfIRBuilder->PopulateType(tupleType); + bool constFailed = false; + SizedArray constTupleMembers; BfIRValue fieldPtr; BfIRValue tuplePtr; - if (!tupleType->IsValuelessType()) + if (wantConst) + { + constTupleMembers.Add(mModule->mBfIRBuilder->CreateConstAggZero(mModule->mBfIRBuilder->MapType(tupleType->mBaseType))); + } + else if (!tupleType->IsValuelessType()) { fieldPtr = mModule->mBfIRBuilder->CreateInBoundsGEP(enumValue, 0, 1); auto tuplePtrType = mModule->CreatePointerType(tupleType); @@ -7688,6 +7698,8 @@ BfTypedValue BfExprEvaluator::CheckEnumCreation(BfAstNode* targetSrc, BfTypeInst BfError* error = mModule->Fail(StrFormat("Not enough parameters specified, expected %d more.", tupleType->mFieldInstances.size() - (int)argValues.mArguments->size()), refNode); if (error != NULL) mModule->mCompiler->mPassInstance->MoreInfo(StrFormat("See enum declaration"), fieldDef->mFieldDeclaration); + if (wantConst) + constFailed = true; break; } @@ -7700,13 +7712,22 @@ BfTypedValue BfExprEvaluator::CheckEnumCreation(BfAstNode* targetSrc, BfTypeInst } auto argValue = ResolveArgValue(argValues.mResolvedArgs[tupleFieldIdx], resolvedFieldType, &receivingValue); - + + if (!argValue) + { + if (wantConst) + constFailed = true; + continue; + } + if (argValue.IsValuelessType()) + { + continue; + } + // Used receiving value? if (argValue.mValue == receivingValue.mValue) continue; - if ((!argValue) || (argValue.IsValuelessType())) - continue; argValue = mModule->AggregateSplat(argValue); argValues.mResolvedArgs[tupleFieldIdx].mExpectedType = resolvedFieldType; if ((argValues.mResolvedArgs[tupleFieldIdx].mArgFlags & (BfArgFlag_DelegateBindAttempt | BfArgFlag_LambdaBindAttempt | BfArgFlag_UnqualifiedDotAttempt)) != 0) @@ -7721,13 +7742,24 @@ BfTypedValue BfExprEvaluator::CheckEnumCreation(BfAstNode* targetSrc, BfTypeInst // argValue can have a value even if tuplePtr does not have a value. This can happen if we are assigning to a (void) tuple, // but we have a value that needs to be attempted to be casted to void argValue = mModule->Cast(argValues.mResolvedArgs[tupleFieldIdx].mExpression, argValue, resolvedFieldType); - if (tupleFieldPtr) + if (wantConst) + { + if (!argValue.mValue.IsConst()) + { + mModule->Fail("Field not const", argValues.mResolvedArgs[tupleFieldIdx].mExpression); + constFailed = true; + } + constTupleMembers.Add(argValue.mValue); + } + else if (tupleFieldPtr) { argValue = mModule->LoadValue(argValue); if (argValue) mModule->mBfIRBuilder->CreateAlignedStore(argValue.mValue, tupleFieldPtr, resolvedFieldType->mAlign); } } + else if (wantConst) + constFailed = true; } if ((intptr)argValues.mResolvedArgs.size() > tupleType->mFieldInstances.size()) @@ -7739,14 +7771,49 @@ BfTypedValue BfExprEvaluator::CheckEnumCreation(BfAstNode* targetSrc, BfTypeInst BfError* error = mModule->Fail(StrFormat("Too many arguments, expected %d fewer.", argValues.mResolvedArgs.size() - tupleType->mFieldInstances.size()), errorRef); if (error != NULL) mModule->mCompiler->mPassInstance->MoreInfo(StrFormat("See enum declaration"), fieldDef->mFieldDeclaration); + + if (wantConst) + constFailed = true; } - - //auto fieldPtr = mModule->mBfIRBuilder->CreateInBoundsGEP(enumValue, 0, 2); - + auto dscrType = enumType->GetDiscriminatorType(); auto dscrField = &enumType->mFieldInstances.back(); - int tagIdx = -fieldInstance->mDataIdx - 1; + + if ((wantConst) && (!constFailed)) + { + auto unionType = enumType->GetUnionInnerType(); + auto constTuple = mModule->mBfIRBuilder->CreateConstAgg(mModule->mBfIRBuilder->MapType(tupleType, BfIRPopulateType_Full), constTupleMembers); + + Array memArr; + memArr.Resize(unionType->mSize); + if (!mModule->mBfIRBuilder->WriteConstant(constTuple, memArr.mVals, tupleType)) + { + constFailed = true; + } + else + { + auto unionValue = mModule->mBfIRBuilder->ReadConstant(memArr.mVals, unionType); + if (!unionValue) + { + constFailed = true; + } + else + { + SizedArray constEnumMembers; + constEnumMembers.Add(mModule->mBfIRBuilder->CreateConstAggZero(mModule->mBfIRBuilder->MapType(enumType->mBaseType, BfIRPopulateType_Full))); + constEnumMembers.Add(unionValue); + constEnumMembers.Add(mModule->mBfIRBuilder->CreateConst(dscrType->mTypeDef->mTypeCode, tagIdx)); + return BfTypedValue(mModule->mBfIRBuilder->CreateConstAgg(mModule->mBfIRBuilder->MapType(enumType, BfIRPopulateType_Full), constEnumMembers), enumType); + } + } + } + + if (constFailed) + { + return mModule->GetDefaultTypedValue(enumType, false, BfDefaultValueKind_Addr); + } + auto dscFieldPtr = mModule->mBfIRBuilder->CreateInBoundsGEP(enumValue, 0, dscrField->mDataIdx); mModule->mBfIRBuilder->CreateAlignedStore(mModule->mBfIRBuilder->CreateConst(dscrType->mTypeDef->mTypeCode, tagIdx), dscFieldPtr, 4); return result; @@ -18598,7 +18665,7 @@ void BfExprEvaluator::Visit(BfTupleExpression* tupleExpr) Array irValues; irValues.Resize(typedValues.mSize + 1); - irValues[0] = mModule->mBfIRBuilder->CreateConstStructZero(mModule->mBfIRBuilder->MapType(tupleType->mBaseType)); + irValues[0] = mModule->mBfIRBuilder->CreateConstAggZero(mModule->mBfIRBuilder->MapType(tupleType->mBaseType)); for (int fieldIdx = 0; fieldIdx < (int)tupleType->mFieldInstances.size(); fieldIdx++) { diff --git a/IDEHelper/Compiler/BfIRBuilder.cpp b/IDEHelper/Compiler/BfIRBuilder.cpp index 578b8337..9469c721 100644 --- a/IDEHelper/Compiler/BfIRBuilder.cpp +++ b/IDEHelper/Compiler/BfIRBuilder.cpp @@ -664,7 +664,7 @@ BfIRValue BfIRConstHolder::CreateConst(BfConstant* fromConst, BfIRConstHolder* f else if (fromConst->mConstType == BfConstType_AggZero) { auto aggZero = (BfConstant*)fromConst; - return CreateConstStructZero(fromConst->mIRType); + return CreateConstAggZero(fromConst->mIRType); } else if (fromConst->mConstType == BfConstType_Agg) { @@ -747,7 +747,7 @@ BfIRValue BfIRConstHolder::CreateConstNull(BfIRType ptrType) return irValue; } -BfIRValue BfIRConstHolder::CreateConstStructZero(BfIRType aggType) +BfIRValue BfIRConstHolder::CreateConstAggZero(BfIRType aggType) { BfConstant* constant = mTempAlloc.Alloc(); constant->mConstType = BfConstType_AggZero; @@ -863,6 +863,203 @@ BfIRValue BfIRConstHolder::GetUndefConstValue(BfIRType irType) return undefVal; } +bool BfIRConstHolder::WriteConstant(BfIRValue val, void* ptr, BfType* type) +{ + auto constant = GetConstant(val); + if (constant == NULL) + return false; + + switch (constant->mTypeCode) + { + case BfTypeCode_Int8: + case BfTypeCode_UInt8: + case BfTypeCode_Boolean: + case BfTypeCode_Char8: + *(int8*)ptr = constant->mInt8; + return true; + case BfTypeCode_Int16: + case BfTypeCode_UInt16: + case BfTypeCode_Char16: + *(int16*)ptr = constant->mInt16; + return true; + case BfTypeCode_Int32: + case BfTypeCode_UInt32: + case BfTypeCode_Char32: + *(int32*)ptr = constant->mInt32; + return true; + case BfTypeCode_Int64: + case BfTypeCode_UInt64: + *(int64*)ptr = constant->mInt64; + return true; + case BfTypeCode_NullPtr: + if (mModule->mSystem->mPtrSize == 4) + *(int32*)ptr = 0; + else + *(int64*)ptr = 0; + return true; + case BfTypeCode_Float: + *(float*)ptr = (float)constant->mDouble; + return true; + case BfTypeCode_Double: + *(double*)ptr = constant->mDouble; + return true; + } + + if (constant->mConstType == BfConstType_Agg) + { + auto aggConstant = (BfConstantAgg*)constant; + if (type->IsSizedArray()) + { + auto sizedArrayType = (BfSizedArrayType*)type; + for (int i = 0; i < sizedArrayType->mElementCount; i++) + { + if (!WriteConstant(aggConstant->mValues[i], (uint8*)ptr + (i * sizedArrayType->mElementType->GetStride()), sizedArrayType->mElementType)) + return false; + } + + return false; + } + else + { + BF_ASSERT(type->IsStruct()); + + mModule->PopulateType(type); + auto typeInst = type->ToTypeInstance(); + int idx = 0; + + if (typeInst->mBaseType != NULL) + { + if (!WriteConstant(aggConstant->mValues[0], ptr, typeInst->mBaseType)) + return false; + } + + for (auto& fieldInstance : typeInst->mFieldInstances) + { + if (fieldInstance.mDataOffset < 0) + continue; + if (!WriteConstant(aggConstant->mValues[fieldInstance.mDataIdx], (uint8*)ptr + fieldInstance.mDataOffset, fieldInstance.mResolvedType)) + return false; + } + } + return true; + } + + if (constant->mConstType == BfConstType_AggZero) + { + BF_ASSERT(type->IsComposite()); + memset(ptr, 0, type->mSize); + return true; + } + + if (constant->mConstType == BfConstType_BitCast) + { + auto constBitCast = (BfConstantBitCast*)constant; + + auto constTarget = mModule->mBfIRBuilder->GetConstantById(constBitCast->mTarget); + return WriteConstant(BfIRValue(BfIRValueFlags_Const, constBitCast->mTarget), ptr, type); + } + + return false; +} + +BfIRValue BfIRConstHolder::ReadConstant(void* ptr, BfType* type) +{ + if (type->IsPrimitiveType()) + { + auto primType = (BfPrimitiveType*)type; + switch (primType->mTypeDef->mTypeCode) + { + case BfTypeCode_Int8: + case BfTypeCode_UInt8: + case BfTypeCode_Boolean: + case BfTypeCode_Char8: + return CreateConst(primType->mTypeDef->mTypeCode, *(int8*)ptr); + case BfTypeCode_Int16: + case BfTypeCode_UInt16: + case BfTypeCode_Char16: + return CreateConst(primType->mTypeDef->mTypeCode, *(int16*)ptr); + case BfTypeCode_Int32: + case BfTypeCode_UInt32: + case BfTypeCode_Char32: + return CreateConst(primType->mTypeDef->mTypeCode, *(int32*)ptr); + case BfTypeCode_Int64: + case BfTypeCode_UInt64: + return CreateConst(primType->mTypeDef->mTypeCode, *(uint64*)ptr); + case BfTypeCode_NullPtr: + return CreateConstNull(); + case BfTypeCode_Float: + return CreateConst(primType->mTypeDef->mTypeCode, *(float*)ptr); + case BfTypeCode_Double: + return CreateConst(primType->mTypeDef->mTypeCode, *(double*)ptr); + case BfTypeCode_IntPtr: + case BfTypeCode_UIntPtr: + if (mModule->mSystem->mPtrSize == 4) + return CreateConst(primType->mTypeDef->mTypeCode, *(int32*)ptr); + else + return CreateConst(primType->mTypeDef->mTypeCode, *(uint64*)ptr); + default: + return BfIRValue(); + } + } + + if (type->IsTypedPrimitive()) + { + return ReadConstant(ptr, type->GetUnderlyingType()); + } + + if (type->IsSizedArray()) + { + SizedArray irValues; + + auto sizedArrayType = (BfSizedArrayType*)type; + for (int i = 0; i < sizedArrayType->mElementCount; i++) + { + auto val = ReadConstant((uint8*)ptr + (i * sizedArrayType->mElementType->GetStride()), sizedArrayType->mElementType); + if (!val) + return BfIRValue(); + irValues.Add(val); + } + + BfIRType irType; + irType.mKind = BfIRTypeData::TypeKind_TypeId; + irType.mId = type->mTypeId; + return CreateConstAgg(irType, irValues); + } + + if (type->IsStruct()) + { + mModule->PopulateType(type); + auto typeInst = type->ToTypeInstance(); + int idx = 0; + + SizedArray irValues; + + if (typeInst->mBaseType != NULL) + { + auto val = ReadConstant(ptr, typeInst->mBaseType); + if (!val) + return BfIRValue(); + irValues.Add(val); + } + + for (auto& fieldInstance : typeInst->mFieldInstances) + { + if (fieldInstance.mDataOffset < 0) + continue; + auto val = ReadConstant((uint8*)ptr + fieldInstance.mDataOffset, fieldInstance.mResolvedType); + if (!val) + return BfIRValue(); + irValues.Add(val); + } + BfIRType irType; + irType.mKind = BfIRTypeData::TypeKind_TypeId; + irType.mId = type->mTypeId; + return CreateConstAgg(irType, irValues); + } + + return BfIRValue(); +} + ////////////////////////////////////////////////////////////////////////// void BfIRBuilder::OpFailed() diff --git a/IDEHelper/Compiler/BfIRBuilder.h b/IDEHelper/Compiler/BfIRBuilder.h index 5fda7c7c..ff098a6c 100644 --- a/IDEHelper/Compiler/BfIRBuilder.h +++ b/IDEHelper/Compiler/BfIRBuilder.h @@ -928,7 +928,7 @@ public: BfIRValue CreateConst(BfConstant* fromConst, BfIRConstHolder* fromHolder); BfIRValue CreateConstNull(); BfIRValue CreateConstNull(BfIRType nullType); - BfIRValue CreateConstStructZero(BfIRType aggType); + BfIRValue CreateConstAggZero(BfIRType aggType); BfIRValue CreateConstAgg(BfIRType type, const BfSizedArray& values); BfIRValue CreateConstAggCE(BfIRType type, addr_ce ptr); BfIRValue CreateConstArrayZero(BfIRType type, int count); @@ -936,6 +936,9 @@ public: BfIRValue CreateTypeOf(BfType* type); BfIRValue CreateTypeOf(BfType* type, BfIRValue typeData); BfIRValue GetUndefConstValue(BfIRType type); + + bool WriteConstant(BfIRValue val, void* ptr, BfType* type); + BfIRValue ReadConstant(void* ptr, BfType* type); }; enum BfIRPopulateType diff --git a/IDEHelper/Compiler/BfModule.cpp b/IDEHelper/Compiler/BfModule.cpp index 4d612f19..9fdf6c83 100644 --- a/IDEHelper/Compiler/BfModule.cpp +++ b/IDEHelper/Compiler/BfModule.cpp @@ -1454,7 +1454,7 @@ BfIRValue BfModule::GetDefaultValue(BfType* type) } if (type->IsVoid()) return mBfIRBuilder->CreateConstNull(mBfIRBuilder->MapType(type)); - return mBfIRBuilder->CreateConstStructZero(mBfIRBuilder->MapType(type)); + return mBfIRBuilder->CreateConstAggZero(mBfIRBuilder->MapType(type)); } BfTypedValue BfModule::GetFakeTypedValue(BfType* type) @@ -8440,7 +8440,7 @@ BfIRValue BfModule::GetDbgRawAllocData(BfType* type) } SizedArray dataValues; - dataValues.Add(mBfIRBuilder->CreateConstStructZero(mBfIRBuilder->MapType(dbgRawAllocDataType->mBaseType, BfIRPopulateType_Full))); + dataValues.Add(mBfIRBuilder->CreateConstAggZero(mBfIRBuilder->MapType(dbgRawAllocDataType->mBaseType, BfIRPopulateType_Full))); dataValues.Add(typeDataRef); dataValues.Add(markFuncPtr); dataValues.Add(mBfIRBuilder->CreateConst(BfTypeCode_Int32, stackCount)); diff --git a/IDEHelper/Compiler/BfModuleTypeUtils.cpp b/IDEHelper/Compiler/BfModuleTypeUtils.cpp index c1a4f780..a3ef29e8 100644 --- a/IDEHelper/Compiler/BfModuleTypeUtils.cpp +++ b/IDEHelper/Compiler/BfModuleTypeUtils.cpp @@ -11351,7 +11351,7 @@ BfIRValue BfModule::CastToValue(BfAstNode* srcNode, BfTypedValue typedVal, BfTyp return allocaInst; } - auto zeroNullable = mBfIRBuilder->CreateConstStructZero(mBfIRBuilder->MapType(toType)); + auto zeroNullable = mBfIRBuilder->CreateConstAggZero(mBfIRBuilder->MapType(toType)); return zeroNullable; } @@ -11778,7 +11778,7 @@ BfIRValue BfModule::CastToValue(BfAstNode* srcNode, BfTypedValue typedVal, BfTyp auto stringCharPtr = GetStringCharPtr(stringId); SizedArray spanFieldVals; - spanFieldVals.Add(mBfIRBuilder->CreateConstStructZero(mBfIRBuilder->MapType(svTypeInst->mBaseType->mBaseType))); + spanFieldVals.Add(mBfIRBuilder->CreateConstAggZero(mBfIRBuilder->MapType(svTypeInst->mBaseType->mBaseType))); spanFieldVals.Add(stringCharPtr); spanFieldVals.Add(mBfIRBuilder->CreateConst(BfTypeCode_IntPtr, entry->mString.mLength)); diff --git a/IDEHelper/Compiler/CeMachine.cpp b/IDEHelper/Compiler/CeMachine.cpp index a72aa8cd..e184fb05 100644 --- a/IDEHelper/Compiler/CeMachine.cpp +++ b/IDEHelper/Compiler/CeMachine.cpp @@ -3368,7 +3368,8 @@ bool CeContext::WriteConstant(BfModule* module, addr_ce addr, BfConstant* consta auto fieldConstant = module->mBfIRBuilder->GetConstant(aggConstant->mValues[i]); if (fieldConstant == NULL) return false; - WriteConstant(module, elemsAddr + i * elemType->GetStride(), fieldConstant, elemType); + if (!WriteConstant(module, elemsAddr + i * elemType->GetStride(), fieldConstant, elemType)) + return false; } if (mCeMachine->mCeModule->mSystem->mPtrSize == 4) @@ -3388,7 +3389,8 @@ bool CeContext::WriteConstant(BfModule* module, addr_ce addr, BfConstant* consta auto fieldConstant = module->mBfIRBuilder->GetConstant(aggConstant->mValues[i]); if (fieldConstant == NULL) return false; - WriteConstant(module, elemsAddr + i * elemType->GetStride(), fieldConstant, elemType); + if (!WriteConstant(module, elemsAddr + i * elemType->GetStride(), fieldConstant, elemType)) + return false; } if (mCeMachine->mCeModule->mSystem->mPtrSize == 4) @@ -3415,7 +3417,8 @@ bool CeContext::WriteConstant(BfModule* module, addr_ce addr, BfConstant* consta if (typeInst->mBaseType != NULL) { auto baseConstant = module->mBfIRBuilder->GetConstant(aggConstant->mValues[0]); - WriteConstant(module, addr, baseConstant, typeInst->mBaseType); + if (!WriteConstant(module, addr, baseConstant, typeInst->mBaseType)) + return false; } for (auto& fieldInstance : typeInst->mFieldInstances) @@ -3426,7 +3429,8 @@ bool CeContext::WriteConstant(BfModule* module, addr_ce addr, BfConstant* consta auto fieldConstant = module->mBfIRBuilder->GetConstant(aggConstant->mValues[fieldInstance.mDataIdx]); if (fieldConstant == NULL) return false; - WriteConstant(module, addr + fieldInstance.mDataOffset, fieldConstant, fieldInstance.mResolvedType); + if (!WriteConstant(module, addr + fieldInstance.mDataOffset, fieldConstant, fieldInstance.mResolvedType)) + return false; } } return true; diff --git a/IDEHelper/Tests/src/Enums.bf b/IDEHelper/Tests/src/Enums.bf index 6cd8a593..8e6d01b3 100644 --- a/IDEHelper/Tests/src/Enums.bf +++ b/IDEHelper/Tests/src/Enums.bf @@ -85,6 +85,9 @@ namespace Tests } Test.Assert(a == 3); Test.Assert(b == 4); + + const EnumE e0 = .A; + const EnumE e1 = .B(1); } [Test]