Extern/Beef
1
0
Fork 0
mirror of https://github.com/beefytech/Beef.git synced 2025-06-08 03:28:20 +02:00
Code Activity

Handle block splitting in tuple match

Browse source
This commit is contained in:
Brian Fiete 2021-11-15 16:44:28 -08:00
parent f58362343b
commit c107a33268
4 changed files with 84 additions and 71 deletions
Download patch file Download diff file Expand all files Collapse all files

4
IDEHelper/Compiler/BfIRCodeGen.cpp
View file

@ -2519,6 +2519,8 @@ void BfIRCodeGen::HandleNextCmd()
case BfIRCmd_SetInsertPoint: case BfIRCmd_SetInsertPoint:
{ {
CMD_PARAM(llvm::BasicBlock*, block); CMD_PARAM(llvm::BasicBlock*, block);
if (mLockedBlocks.Contains(block))
Fail("Attempt to modify locked block");
mIRBuilder->SetInsertPoint(block); mIRBuilder->SetInsertPoint(block);
} }
break; break;
@ -3861,6 +3863,8 @@ void BfIRCodeGen::HandleNextCmd()
if (!useAsm) if (!useAsm)
{ {
mLockedBlocks.Add(irBuilder->GetInsertBlock());
// This is generates slower code than the inline asm in debug mode, but can optimize well in release // This is generates slower code than the inline asm in debug mode, but can optimize well in release
auto int8Ty = llvm::Type::getInt8Ty(*mLLVMContext); auto int8Ty = llvm::Type::getInt8Ty(*mLLVMContext);
auto int8Ptr = irBuilder->CreateBitCast(val, int8Ty->getPointerTo()); auto int8Ptr = irBuilder->CreateBitCast(val, int8Ty->getPointerTo());

1
IDEHelper/Compiler/BfIRCodeGen.h
View file

@ -117,6 +117,7 @@ public:
Dictionary<llvm::Type*, llvm::Value*> mReflectDataMap; Dictionary<llvm::Type*, llvm::Value*> mReflectDataMap;
Dictionary<llvm::Type*, llvm::Type*> mAlignedTypeToNormalType; Dictionary<llvm::Type*, llvm::Type*> mAlignedTypeToNormalType;
Dictionary<llvm::Type*, int> mTypeToTypeIdMap; Dictionary<llvm::Type*, int> mTypeToTypeIdMap;
HashSet<llvm::BasicBlock*> mLockedBlocks;
public: public:
void InitTarget(); void InitTarget();

2
IDEHelper/Compiler/BfModule.h
View file

@ -1800,7 +1800,7 @@ public:
void CheckTupleVariableDeclaration(BfTupleExpression* tupleExpr, BfType* initType); void CheckTupleVariableDeclaration(BfTupleExpression* tupleExpr, BfType* initType);
void HandleTupleVariableDeclaration(BfVariableDeclaration* varDecl, BfTupleExpression* tupleExpr, BfTypedValue initTupleValue, bool isReadOnly, bool isConst, bool forceAddr, BfIRBlock* declBlock = NULL); void HandleTupleVariableDeclaration(BfVariableDeclaration* varDecl, BfTupleExpression* tupleExpr, BfTypedValue initTupleValue, bool isReadOnly, bool isConst, bool forceAddr, BfIRBlock* declBlock = NULL);
void HandleTupleVariableDeclaration(BfVariableDeclaration* varDecl); void HandleTupleVariableDeclaration(BfVariableDeclaration* varDecl);
void HandleCaseEnumMatch_Tuple(BfTypedValue tupleVal, const BfSizedArray<BfExpression*>& arguments, BfAstNode* tooFewRef, BfIRValue phiVal, BfIRBlock& matchedBlock, BfIRBlock falseBlock, bool& hadConditional, bool clearOutOnMismatch); void HandleCaseEnumMatch_Tuple(BfTypedValue tupleVal, const BfSizedArray<BfExpression*>& arguments, BfAstNode* tooFewRef, BfIRValue phiVal, BfIRBlock& matchedBlockStart, BfIRBlock& matchedBlockEnd, BfIRBlock& falseBlockStart, BfIRBlock& falseBlockEnd, bool& hadConditional, bool clearOutOnMismatch);
BfTypedValue TryCaseTupleMatch(BfTypedValue tupleVal, BfTupleExpression* tupleExpr, BfIRBlock* eqBlock, BfIRBlock* notEqBlock, BfIRBlock* matchBlock, bool& hadConditional, bool clearOutOnMismatch); BfTypedValue TryCaseTupleMatch(BfTypedValue tupleVal, BfTupleExpression* tupleExpr, BfIRBlock* eqBlock, BfIRBlock* notEqBlock, BfIRBlock* matchBlock, bool& hadConditional, bool clearOutOnMismatch);
BfTypedValue TryCaseEnumMatch(BfTypedValue enumVal, BfTypedValue tagVal, BfExpression* expr, BfIRBlock* eqBlock, BfIRBlock* notEqBlock, BfIRBlock* matchBlock, int& uncondTagId, bool& hadConditional, bool clearOutOnMismatch); BfTypedValue TryCaseEnumMatch(BfTypedValue enumVal, BfTypedValue tagVal, BfExpression* expr, BfIRBlock* eqBlock, BfIRBlock* notEqBlock, BfIRBlock* matchBlock, int& uncondTagId, bool& hadConditional, bool clearOutOnMismatch);
BfTypedValue HandleCaseBind(BfTypedValue enumVal, const BfTypedValue& tagVal, BfEnumCaseBindExpression* bindExpr, BfIRBlock* eqBlock = NULL, BfIRBlock* notEqBlock = NULL, BfIRBlock* matchBlock = NULL, int* outEnumIdx = NULL); BfTypedValue HandleCaseBind(BfTypedValue enumVal, const BfTypedValue& tagVal, BfEnumCaseBindExpression* bindExpr, BfIRBlock* eqBlock = NULL, BfIRBlock* notEqBlock = NULL, BfIRBlock* matchBlock = NULL, int* outEnumIdx = NULL);

148
IDEHelper/Compiler/BfStmtEvaluator.cpp
View file

@ -2216,7 +2216,7 @@ void BfModule::HandleTupleVariableDeclaration(BfVariableDeclaration* varDecl)
AssertErrorState(); AssertErrorState();
} }
void BfModule::HandleCaseEnumMatch_Tuple(BfTypedValue tupleVal, const BfSizedArray<BfExpression*>& arguments, BfAstNode* tooFewRef, BfIRValue phiVal, BfIRBlock& matchedBlock, BfIRBlock falseBlock, bool& hadConditional, bool clearOutOnMismatch) void BfModule::HandleCaseEnumMatch_Tuple(BfTypedValue tupleVal, const BfSizedArray<BfExpression*>& arguments, BfAstNode* tooFewRef, BfIRValue phiVal, BfIRBlock& matchedBlockStart, BfIRBlock& matchedBlockEnd, BfIRBlock& falseBlockStart, BfIRBlock& falseBlockEnd, bool& hadConditional, bool clearOutOnMismatch)
{ {
SetAndRestoreValue<bool> prevInCondBlock(mCurMethodState->mInConditionalBlock); SetAndRestoreValue<bool> prevInCondBlock(mCurMethodState->mInConditionalBlock);
@ -2297,7 +2297,7 @@ void BfModule::HandleCaseEnumMatch_Tuple(BfTypedValue tupleVal, const BfSizedArr
tooFewRef = tupleExpr->mValues[tupleExpr->mValues.size() - 1]; tooFewRef = tupleExpr->mValues[tupleExpr->mValues.size() - 1];
if (tooFewRef == NULL) if (tooFewRef == NULL)
tooFewRef = tupleExpr->mOpenParen; tooFewRef = tupleExpr->mOpenParen;
HandleCaseEnumMatch_Tuple(tupleElement, tupleExpr->mValues, tooFewRef, phiVal, matchedBlock, falseBlock, hadConditional, clearOutOnMismatch); HandleCaseEnumMatch_Tuple(tupleElement, tupleExpr->mValues, tooFewRef, phiVal, matchedBlockStart, matchedBlockEnd, falseBlockStart, falseBlockEnd, hadConditional, clearOutOnMismatch);
continue; continue;
} }
} }
@ -2345,10 +2345,17 @@ void BfModule::HandleCaseEnumMatch_Tuple(BfTypedValue tupleVal, const BfSizedArr
{ {
tupleElement = LoadValue(tupleElement); tupleElement = LoadValue(tupleElement);
bool isMatchedBlockEnd = matchedBlockEnd == mBfIRBuilder->GetInsertBlock();
bool isFalseBlockEnd = falseBlockEnd == mBfIRBuilder->GetInsertBlock();
BfExprEvaluator exprEvaluator(this); BfExprEvaluator exprEvaluator(this);
exprEvaluator.mExpectingType = tupleFieldInstance->GetResolvedType(); exprEvaluator.mExpectingType = tupleFieldInstance->GetResolvedType();
exprEvaluator.mBfEvalExprFlags = BfEvalExprFlags_AllowOutExpr; exprEvaluator.mBfEvalExprFlags = BfEvalExprFlags_AllowOutExpr;
exprEvaluator.Evaluate(expr); exprEvaluator.Evaluate(expr);
if (isMatchedBlockEnd)
matchedBlockEnd = mBfIRBuilder->GetInsertBlock();
if (isFalseBlockEnd)
falseBlockEnd = mBfIRBuilder->GetInsertBlock();
auto argValue = exprEvaluator.mResult; auto argValue = exprEvaluator.mResult;
if (!argValue) if (!argValue)
continue; continue;
@ -2388,17 +2395,18 @@ void BfModule::HandleCaseEnumMatch_Tuple(BfTypedValue tupleVal, const BfSizedArr
auto insertBlock = mBfIRBuilder->GetInsertBlock(); auto insertBlock = mBfIRBuilder->GetInsertBlock();
mBfIRBuilder->AddPhiIncoming(phiVal, mBfIRBuilder->CreateConst(BfTypeCode_Boolean, 0), insertBlock); mBfIRBuilder->AddPhiIncoming(phiVal, mBfIRBuilder->CreateConst(BfTypeCode_Boolean, 0), insertBlock);
} }
matchedBlock = mBfIRBuilder->CreateBlock("match", false);
mBfIRBuilder->CreateCondBr(exprResult.mValue, matchedBlock, falseBlock); matchedBlockStart = matchedBlockEnd = mBfIRBuilder->CreateBlock("match", false);
mBfIRBuilder->AddBlock(matchedBlock);
mBfIRBuilder->SetInsertPoint(matchedBlock); mBfIRBuilder->CreateCondBr(exprResult.mValue, matchedBlockStart, falseBlockStart);
mBfIRBuilder->AddBlock(matchedBlockStart);
mBfIRBuilder->SetInsertPoint(matchedBlockStart);
} }
} }
} }
if (!deferredAssigns.empty()) if (!deferredAssigns.empty())
mBfIRBuilder->SetInsertPoint(matchedBlock); mBfIRBuilder->SetInsertPoint(matchedBlockEnd);
// We assign these only after the value checks succeed // We assign these only after the value checks succeed
for (auto& deferredAssign : deferredAssigns) for (auto& deferredAssign : deferredAssigns)
@ -2413,7 +2421,7 @@ void BfModule::HandleCaseEnumMatch_Tuple(BfTypedValue tupleVal, const BfSizedArr
if ((clearOutOnMismatch) && (!deferredAssigns.IsEmpty())) if ((clearOutOnMismatch) && (!deferredAssigns.IsEmpty()))
{ {
auto curInsertPoint = mBfIRBuilder->GetInsertBlock(); auto curInsertPoint = mBfIRBuilder->GetInsertBlock();
mBfIRBuilder->SetInsertPoint(falseBlock); mBfIRBuilder->SetInsertPoint(falseBlockEnd);
for (auto& deferredAssign : deferredAssigns) for (auto& deferredAssign : deferredAssigns)
{ {
auto tupleFieldInstance = &tupleType->mFieldInstances[deferredAssign.mFieldIdx]; auto tupleFieldInstance = &tupleType->mFieldInstances[deferredAssign.mFieldIdx];
@ -2428,6 +2436,7 @@ void BfModule::HandleCaseEnumMatch_Tuple(BfTypedValue tupleVal, const BfSizedArr
continue; continue;
mBfIRBuilder->CreateMemSet(argValue.mValue, GetConstValue8(0), GetConstValue(argValue.mType->mSize), GetConstValue(argValue.mType->mAlign)); mBfIRBuilder->CreateMemSet(argValue.mValue, GetConstValue8(0), GetConstValue(argValue.mType->mSize), GetConstValue(argValue.mType->mAlign));
} }
falseBlockEnd = mBfIRBuilder->GetInsertBlock();
mBfIRBuilder->SetInsertPoint(curInsertPoint); mBfIRBuilder->SetInsertPoint(curInsertPoint);
} }
@ -2544,63 +2553,61 @@ BfTypedValue BfModule::TryCaseTupleMatch(BfTypedValue tupleVal, BfTupleExpressio
//auto dscrType = enumType->GetDiscriminatorType(); //auto dscrType = enumType->GetDiscriminatorType();
//BfIRValue eqResult = mBfIRBuilder->CreateCmpEQ(tagVal.mValue, mBfIRBuilder->CreateConst(dscrType->mTypeDef->mTypeCode, tagId)); //BfIRValue eqResult = mBfIRBuilder->CreateCmpEQ(tagVal.mValue, mBfIRBuilder->CreateConst(dscrType->mTypeDef->mTypeCode, tagId));
BfIRBlock falseBlock; BfIRBlock falseBlockStart;
BfIRBlock doneBlock; BfIRBlock falseBlockEnd;
BfIRBlock doneBlockStart;
if (notEqBlock != NULL) if (notEqBlock != NULL)
doneBlock = *notEqBlock; doneBlockStart = *notEqBlock;
else else
doneBlock = mBfIRBuilder->CreateBlock("caseDone", false); doneBlockStart = mBfIRBuilder->CreateBlock("caseDone", false);
BfIRBlock doneBlockEnd = doneBlockStart;
if (clearOutOnMismatch) if (clearOutOnMismatch)
{ {
falseBlock = mBfIRBuilder->CreateBlock("caseNotEq", false); falseBlockStart = falseBlockEnd = mBfIRBuilder->CreateBlock("caseNotEq", false);
mBfIRBuilder->AddBlock(falseBlock); mBfIRBuilder->AddBlock(falseBlockStart);
} }
BfIRBlock matchedBlock = mBfIRBuilder->CreateBlock("caseMatch", false); BfIRBlock matchedBlockStart = mBfIRBuilder->CreateBlock("caseMatch", false);
if (matchBlock != NULL) if (matchBlock != NULL)
*matchBlock = matchedBlock; *matchBlock = matchedBlockStart;
mBfIRBuilder->CreateBr(matchedBlock); mBfIRBuilder->CreateBr(matchedBlockStart);
mBfIRBuilder->AddBlock(matchedBlock); mBfIRBuilder->AddBlock(matchedBlockStart);
mBfIRBuilder->SetInsertPoint(doneBlock); mBfIRBuilder->SetInsertPoint(doneBlockEnd);
BfIRValue phiVal; BfIRValue phiVal;
if (eqBlock == NULL) if (eqBlock == NULL)
phiVal = mBfIRBuilder->CreatePhi(mBfIRBuilder->MapType(boolType), 2); phiVal = mBfIRBuilder->CreatePhi(mBfIRBuilder->MapType(boolType), 2);
if (phiVal)
{ mBfIRBuilder->SetInsertPoint(matchedBlockStart);
auto falseVal = mBfIRBuilder->CreateConst(BfTypeCode_Boolean, 0); BfIRBlock matchedBlockEnd = matchedBlockStart;
HandleCaseEnumMatch_Tuple(tupleVal, tupleExpr->mValues, tooFewRef, falseBlockStart ? BfIRValue() : phiVal, matchedBlockStart, matchedBlockEnd,
if (falseBlock) falseBlockStart ? falseBlockStart : doneBlockStart, falseBlockEnd ? falseBlockEnd : doneBlockEnd, hadConditional, clearOutOnMismatch);
mBfIRBuilder->AddPhiIncoming(phiVal, falseVal, falseBlock);
// else
// mBfIRBuilder->AddPhiIncoming(phiVal, falseVal, startBlock);
}
mBfIRBuilder->SetInsertPoint(matchedBlock);
HandleCaseEnumMatch_Tuple(tupleVal, tupleExpr->mValues, tooFewRef, falseBlock ? BfIRValue() : phiVal, matchedBlock, falseBlock ? falseBlock : doneBlock, hadConditional, clearOutOnMismatch);
if (phiVal) if (phiVal)
{ {
auto falseVal = mBfIRBuilder->CreateConst(BfTypeCode_Boolean, 0);
if (falseBlockEnd)
mBfIRBuilder->AddPhiIncoming(phiVal, falseVal, falseBlockEnd);
auto trueVal = mBfIRBuilder->CreateConst(BfTypeCode_Boolean, 1); auto trueVal = mBfIRBuilder->CreateConst(BfTypeCode_Boolean, 1);
mBfIRBuilder->AddPhiIncoming(phiVal, trueVal, matchedBlock); mBfIRBuilder->AddPhiIncoming(phiVal, trueVal, matchedBlockEnd);
} }
if (eqBlock != NULL) if (eqBlock != NULL)
mBfIRBuilder->CreateBr(*eqBlock); mBfIRBuilder->CreateBr(*eqBlock);
else else
mBfIRBuilder->CreateBr(doneBlock); mBfIRBuilder->CreateBr(doneBlockStart);
if (falseBlock) if (falseBlockEnd)
{ {
mBfIRBuilder->SetInsertPoint(falseBlock); mBfIRBuilder->SetInsertPoint(falseBlockEnd);
mBfIRBuilder->CreateBr(doneBlock); mBfIRBuilder->CreateBr(doneBlockStart);
//mBfIRBuilder->AddPhiIncoming(phiVal, mBfIRBuilder->CreateConst(BfTypeCode_Boolean, 0), falseBlock); //mBfIRBuilder->AddPhiIncoming(phiVal, mBfIRBuilder->CreateConst(BfTypeCode_Boolean, 0), falseBlock);
} }
mBfIRBuilder->AddBlock(doneBlock); mBfIRBuilder->AddBlock(doneBlockStart);
mBfIRBuilder->SetInsertPoint(doneBlock); mBfIRBuilder->SetInsertPoint(doneBlockEnd);
if (phiVal) if (phiVal)
return BfTypedValue(phiVal, boolType); return BfTypedValue(phiVal, boolType);
@ -2709,41 +2716,35 @@ BfTypedValue BfModule::TryCaseEnumMatch(BfTypedValue enumVal, BfTypedValue tagVa
auto dscrType = enumType->GetDiscriminatorType(); auto dscrType = enumType->GetDiscriminatorType();
BfIRValue eqResult = mBfIRBuilder->CreateCmpEQ(tagVal.mValue, mBfIRBuilder->CreateConst(dscrType->mTypeDef->mTypeCode, tagId)); BfIRValue eqResult = mBfIRBuilder->CreateCmpEQ(tagVal.mValue, mBfIRBuilder->CreateConst(dscrType->mTypeDef->mTypeCode, tagId));
BfIRBlock falseBlock; BfIRBlock falseBlockStart;
BfIRBlock doneBlock; BfIRBlock falseBlockEnd;
BfIRBlock doneBlockStart;
BfIRBlock doneBlockEnd;
if (notEqBlock != NULL) if (notEqBlock != NULL)
doneBlock = *notEqBlock; doneBlockStart = doneBlockEnd = *notEqBlock;
else else
doneBlock = mBfIRBuilder->CreateBlock("caseDone", false); doneBlockStart = doneBlockEnd = mBfIRBuilder->CreateBlock("caseDone", false);
if (clearOutOnMismatch) if (clearOutOnMismatch)
{ {
falseBlock = mBfIRBuilder->CreateBlock("caseNotEq", false); falseBlockStart = falseBlockEnd = mBfIRBuilder->CreateBlock("caseNotEq", false);
mBfIRBuilder->AddBlock(falseBlock); mBfIRBuilder->AddBlock(falseBlockStart);
} }
BfIRBlock matchedBlock = mBfIRBuilder->CreateBlock("caseMatch", false); BfIRBlock matchedBlockStart = mBfIRBuilder->CreateBlock("caseMatch", false);
BfIRBlock matchedBlockEnd = matchedBlockStart;
if (matchBlock != NULL) if (matchBlock != NULL)
*matchBlock = matchedBlock; *matchBlock = matchedBlockStart;
mBfIRBuilder->CreateCondBr(eqResult, matchedBlock, falseBlock ? falseBlock : doneBlock); mBfIRBuilder->CreateCondBr(eqResult, matchedBlockStart, falseBlockStart ? falseBlockStart : doneBlockStart);
mBfIRBuilder->AddBlock(matchedBlock); mBfIRBuilder->AddBlock(matchedBlockStart);
mBfIRBuilder->SetInsertPoint(doneBlock); mBfIRBuilder->SetInsertPoint(doneBlockEnd);
BfIRValue phiVal; BfIRValue phiVal;
if (eqBlock == NULL) if (eqBlock == NULL)
phiVal = mBfIRBuilder->CreatePhi(mBfIRBuilder->MapType(boolType), 1 + (int)tupleType->mFieldInstances.size()); phiVal = mBfIRBuilder->CreatePhi(mBfIRBuilder->MapType(boolType), 1 + (int)tupleType->mFieldInstances.size());
if (phiVal)
{ mBfIRBuilder->SetInsertPoint(matchedBlockEnd);
auto falseVal = mBfIRBuilder->CreateConst(BfTypeCode_Boolean, 0);
if (falseBlock)
mBfIRBuilder->AddPhiIncoming(phiVal, falseVal, falseBlock);
else
mBfIRBuilder->AddPhiIncoming(phiVal, falseVal, startBlock);
}
mBfIRBuilder->SetInsertPoint(matchedBlock);
BfTypedValue tupleVal; BfTypedValue tupleVal;
if (!enumVal.IsAddr()) if (!enumVal.IsAddr())
@ -2848,30 +2849,37 @@ BfTypedValue BfModule::TryCaseEnumMatch(BfTypedValue enumVal, BfTypedValue tagVa
/// ///
HandleCaseEnumMatch_Tuple(tupleVal, invocationExpr->mArguments, tooFewRef, falseBlock ? BfIRValue() : phiVal, matchedBlock, falseBlock ? falseBlock : doneBlock, hadConditional, clearOutOnMismatch); HandleCaseEnumMatch_Tuple(tupleVal, invocationExpr->mArguments, tooFewRef, falseBlockStart ? BfIRValue() : phiVal, matchedBlockStart, matchedBlockEnd,
falseBlockStart ? falseBlockStart : doneBlockStart, falseBlockEnd ? falseBlockEnd : doneBlockEnd,
hadConditional, clearOutOnMismatch);
/////// ///////
if (phiVal) if (phiVal)
{ {
auto falseVal = mBfIRBuilder->CreateConst(BfTypeCode_Boolean, 0);
if (falseBlockEnd)
mBfIRBuilder->AddPhiIncoming(phiVal, falseVal, falseBlockEnd);
else
mBfIRBuilder->AddPhiIncoming(phiVal, falseVal, startBlock);
auto trueVal = mBfIRBuilder->CreateConst(BfTypeCode_Boolean, 1); auto trueVal = mBfIRBuilder->CreateConst(BfTypeCode_Boolean, 1);
mBfIRBuilder->AddPhiIncoming(phiVal, trueVal, matchedBlock); mBfIRBuilder->AddPhiIncoming(phiVal, trueVal, matchedBlockEnd);
} }
if (eqBlock != NULL) if (eqBlock != NULL)
mBfIRBuilder->CreateBr(*eqBlock); mBfIRBuilder->CreateBr(*eqBlock);
else else
mBfIRBuilder->CreateBr(doneBlock); mBfIRBuilder->CreateBr(doneBlockStart);
if (falseBlock) if (falseBlockEnd)
{ {
mBfIRBuilder->SetInsertPoint(falseBlock); mBfIRBuilder->SetInsertPoint(falseBlockEnd);
mBfIRBuilder->CreateBr(doneBlock); mBfIRBuilder->CreateBr(doneBlockStart);
//mBfIRBuilder->AddPhiIncoming(phiVal, mBfIRBuilder->CreateConst(BfTypeCode_Boolean, 0), falseBlock); //mBfIRBuilder->AddPhiIncoming(phiVal, mBfIRBuilder->CreateConst(BfTypeCode_Boolean, 0), falseBlock);
} }
mBfIRBuilder->AddBlock(doneBlock); mBfIRBuilder->AddBlock(doneBlockStart);
mBfIRBuilder->SetInsertPoint(doneBlock); mBfIRBuilder->SetInsertPoint(doneBlockEnd);
if (phiVal) if (phiVal)
return BfTypedValue(phiVal, boolType); return BfTypedValue(phiVal, boolType);
@ -5775,7 +5783,7 @@ void BfModule::Visit(BfForStatement* forStmt)
} }
void BfModule::DoForLess(BfForEachStatement* forEachStmt) void BfModule::DoForLess(BfForEachStatement* forEachStmt)
{ {
UpdateSrcPos(forEachStmt); UpdateSrcPos(forEachStmt);
auto startBB = mBfIRBuilder->GetInsertBlock(); auto startBB = mBfIRBuilder->GetInsertBlock();