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

More explicit alignments

Browse source
This commit is contained in:
Brian Fiete 2022-04-16 13:22:32 -07:00
parent fb8d528c6b
commit 229c7fbd12
4 changed files with 65 additions and 62 deletions
Download patch file Download diff file Expand all files Collapse all files

42
IDEHelper/Compiler/BfExprEvaluator.cpp
View file

@ -7428,8 +7428,8 @@ BfTypedValue BfExprEvaluator::CreateCall(BfAstNode* targetSrc, const BfTypedValu
expandedParamsArray = BfTypedValue(mModule->CreateAlloca(wantType), wantType, true); expandedParamsArray = BfTypedValue(mModule->CreateAlloca(wantType), wantType, true);
expandedParamAlloca = mModule->CreateAlloca(genericTypeInst->mGenericTypeInfo->mTypeGenericArguments[0], true, NULL, mModule->GetConstValue(numElements)); expandedParamAlloca = mModule->CreateAlloca(genericTypeInst->mGenericTypeInfo->mTypeGenericArguments[0], true, NULL, mModule->GetConstValue(numElements));
mModule->mBfIRBuilder->CreateStore(expandedParamAlloca, mModule->mBfIRBuilder->CreateInBoundsGEP(expandedParamsArray.mValue, 0, 1)); mModule->mBfIRBuilder->CreateAlignedStore(expandedParamAlloca, mModule->mBfIRBuilder->CreateInBoundsGEP(expandedParamsArray.mValue, 0, 1), mModule->mSystem->mPtrSize);
mModule->mBfIRBuilder->CreateStore(mModule->GetConstValue(numElements), mModule->mBfIRBuilder->CreateInBoundsGEP(expandedParamsArray.mValue, 0, 2)); mModule->mBfIRBuilder->CreateAlignedStore(mModule->GetConstValue(numElements), mModule->mBfIRBuilder->CreateInBoundsGEP(expandedParamsArray.mValue, 0, 2), mModule->mSystem->mPtrSize);
PushArg(expandedParamsArray, irArgs, !wantsSplat); PushArg(expandedParamsArray, irArgs, !wantsSplat);
continue; continue;
@ -11701,16 +11701,16 @@ void BfExprEvaluator::Visit(BfCheckTypeExpression* checkTypeExpr)
auto endBB = mModule->mBfIRBuilder->CreateBlock("is.done"); auto endBB = mModule->mBfIRBuilder->CreateBlock("is.done");
BfIRValue boolResult = mModule->CreateAlloca(boolType); BfIRValue boolResult = mModule->CreateAlloca(boolType);
irb->CreateStore(irb->CreateConst(BfTypeCode_Boolean, 0), boolResult); irb->CreateAlignedStore(irb->CreateConst(BfTypeCode_Boolean, 0), boolResult, 1);
mModule->EmitDynamicCastCheck(targetValue, targetType, matchBB, endBB); mModule->EmitDynamicCastCheck(targetValue, targetType, matchBB, endBB);
mModule->AddBasicBlock(matchBB); mModule->AddBasicBlock(matchBB);
irb->CreateStore(irb->CreateConst(BfTypeCode_Boolean, 1), boolResult); irb->CreateAlignedStore(irb->CreateConst(BfTypeCode_Boolean, 1), boolResult, 1);
irb->CreateBr(endBB); irb->CreateBr(endBB);
mModule->AddBasicBlock(endBB); mModule->AddBasicBlock(endBB);
mResult = BfTypedValue(irb->CreateLoad(boolResult), boolType); mResult = BfTypedValue(irb->CreateAlignedLoad(boolResult, 1), boolType);
} }
void BfExprEvaluator::Visit(BfDynamicCastExpression* dynCastExpr) void BfExprEvaluator::Visit(BfDynamicCastExpression* dynCastExpr)
@ -11986,17 +11986,17 @@ void BfExprEvaluator::Visit(BfDynamicCastExpression* dynCastExpr)
auto matchBlock = irb->CreateBlock("as.match"); auto matchBlock = irb->CreateBlock("as.match");
BfIRValue targetVal = mModule->CreateAlloca(targetType); BfIRValue targetVal = mModule->CreateAlloca(targetType);
irb->CreateStore(irb->CreateConstNull(irb->MapType(targetType)), targetVal); irb->CreateAlignedStore(irb->CreateConstNull(irb->MapType(targetType)), targetVal, targetType->mAlign);
mModule->EmitDynamicCastCheck(targetValue, targetType, matchBlock, endBB); mModule->EmitDynamicCastCheck(targetValue, targetType, matchBlock, endBB);
mModule->AddBasicBlock(matchBlock); mModule->AddBasicBlock(matchBlock);
BfIRValue castedCallResult = mModule->mBfIRBuilder->CreateBitCast(targetValue.mValue, mModule->mBfIRBuilder->MapType(targetType)); BfIRValue castedCallResult = mModule->mBfIRBuilder->CreateBitCast(targetValue.mValue, mModule->mBfIRBuilder->MapType(targetType));
irb->CreateStore(castedCallResult, targetVal); irb->CreateAlignedStore(castedCallResult, targetVal, targetValue.mType->mAlign);
irb->CreateBr(endBB); irb->CreateBr(endBB);
mModule->AddBasicBlock(endBB); mModule->AddBasicBlock(endBB);
mResult = BfTypedValue(irb->CreateLoad(targetVal), targetType); mResult = BfTypedValue(irb->CreateAlignedLoad(targetVal, targetType->mAlign), targetType);
_CheckResult(); _CheckResult();
} }
@ -12260,7 +12260,7 @@ BfTypedValue BfExprEvaluator::DoImplicitArgCapture(BfAstNode* refNode, BfIdentif
{ {
auto refType = (BfRefType*)field.mResolvedType; auto refType = (BfRefType*)field.mResolvedType;
auto underlyingType = refType->GetUnderlyingType(); auto underlyingType = refType->GetUnderlyingType();
result = BfTypedValue(mModule->mBfIRBuilder->CreateLoad(result.mValue), underlyingType, true); result = BfTypedValue(mModule->mBfIRBuilder->CreateAlignedLoad(result.mValue, underlyingType->mAlign), underlyingType, true);
} }
else if (fieldDef->mIsReadOnly) else if (fieldDef->mIsReadOnly)
result = mModule->LoadValue(result); result = mModule->LoadValue(result);
@ -14275,7 +14275,7 @@ void BfExprEvaluator::Visit(BfLambdaBindExpression* lambdaBindExpr)
else else
valPtr = mModule->GetDefaultValue(nullPtrType); valPtr = mModule->GetDefaultValue(nullPtrType);
auto fieldPtr = mModule->mBfIRBuilder->CreateInBoundsGEP(baseDelegate, 0, targetField.mDataIdx); auto fieldPtr = mModule->mBfIRBuilder->CreateInBoundsGEP(baseDelegate, 0, targetField.mDataIdx);
mModule->mBfIRBuilder->CreateStore(valPtr, fieldPtr); mModule->mBfIRBuilder->CreateAlignedStore(valPtr, fieldPtr, targetField.mResolvedType->mAlign);
// >> delegate.mFuncPtr = bindResult.mFunc // >> delegate.mFuncPtr = bindResult.mFunc
if (lambdaInstance->mClosureFunc) if (lambdaInstance->mClosureFunc)
@ -14283,7 +14283,7 @@ void BfExprEvaluator::Visit(BfLambdaBindExpression* lambdaBindExpr)
auto nullPtrType = mModule->GetPrimitiveType(BfTypeCode_NullPtr); auto nullPtrType = mModule->GetPrimitiveType(BfTypeCode_NullPtr);
auto valPtr = mModule->mBfIRBuilder->CreateBitCast(lambdaInstance->mClosureFunc, mModule->mBfIRBuilder->MapType(nullPtrType)); auto valPtr = mModule->mBfIRBuilder->CreateBitCast(lambdaInstance->mClosureFunc, mModule->mBfIRBuilder->MapType(nullPtrType));
auto fieldPtr = mModule->mBfIRBuilder->CreateInBoundsGEP(baseDelegate, 0, funcPtrField.mDataIdx); auto fieldPtr = mModule->mBfIRBuilder->CreateInBoundsGEP(baseDelegate, 0, funcPtrField.mDataIdx);
mModule->mBfIRBuilder->CreateStore(valPtr, fieldPtr); mModule->mBfIRBuilder->CreateAlignedStore(valPtr, fieldPtr, funcPtrField.mResolvedType->mAlign);
} }
mModule->AddDependency(useTypeInstance, mModule->mCurTypeInstance, BfDependencyMap::DependencyFlag_Calls); mModule->AddDependency(useTypeInstance, mModule->mCurTypeInstance, BfDependencyMap::DependencyFlag_Calls);
@ -14303,7 +14303,7 @@ void BfExprEvaluator::Visit(BfLambdaBindExpression* lambdaBindExpr)
auto localVar = mModule->mCurMethodState->mLocals[0]; auto localVar = mModule->mCurMethodState->mLocals[0];
auto capturedValue = mModule->mBfIRBuilder->CreateInBoundsGEP(localVar->mValue, 0, fieldInstance.mDataIdx); auto capturedValue = mModule->mBfIRBuilder->CreateInBoundsGEP(localVar->mValue, 0, fieldInstance.mDataIdx);
capturedValue = mModule->mBfIRBuilder->CreateLoad(capturedValue); capturedValue = mModule->mBfIRBuilder->CreateAlignedLoad(capturedValue, fieldInstance.mResolvedType->mAlign);
auto fieldPtr = mModule->mBfIRBuilder->CreateInBoundsGEP(mResult.mValue, 0, fieldInstance.mDataIdx); auto fieldPtr = mModule->mBfIRBuilder->CreateInBoundsGEP(mResult.mValue, 0, fieldInstance.mDataIdx);
mModule->mBfIRBuilder->CreateStore(capturedValue, fieldPtr); mModule->mBfIRBuilder->CreateStore(capturedValue, fieldPtr);
@ -14340,7 +14340,7 @@ void BfExprEvaluator::Visit(BfLambdaBindExpression* lambdaBindExpr)
if (!IsVar(capturedTypedVal.mType)) if (!IsVar(capturedTypedVal.mType))
{ {
auto fieldPtr = mModule->mBfIRBuilder->CreateInBoundsGEP(mResult.mValue, 0, fieldInstance->mDataIdx); auto fieldPtr = mModule->mBfIRBuilder->CreateInBoundsGEP(mResult.mValue, 0, fieldInstance->mDataIdx);
mModule->mBfIRBuilder->CreateStore(capturedValue, fieldPtr); mModule->mBfIRBuilder->CreateAlignedStore(capturedValue, fieldPtr, fieldInstance->mResolvedType->mAlign);
} }
} }
else else
@ -14359,7 +14359,7 @@ void BfExprEvaluator::Visit(BfLambdaBindExpression* lambdaBindExpr)
auto voidPtrType = mModule->CreatePointerType(voidType); auto voidPtrType = mModule->CreatePointerType(voidType);
auto dtorThunk = mModule->mBfIRBuilder->CreateBitCast(lambdaInstance->mDtorFunc, mModule->mBfIRBuilder->MapType(voidPtrType)); auto dtorThunk = mModule->mBfIRBuilder->CreateBitCast(lambdaInstance->mDtorFunc, mModule->mBfIRBuilder->MapType(voidPtrType));
mModule->mBfIRBuilder->CreateStore(dtorThunk, fieldPtr); mModule->mBfIRBuilder->CreateAlignedStore(dtorThunk, fieldPtr, mModule->mSystem->mPtrSize);
fieldIdx++; fieldIdx++;
} }
} }
@ -20360,7 +20360,7 @@ void BfExprEvaluator::Visit(BfTupleExpression* tupleExpr)
else if (typedVal.IsSplat()) else if (typedVal.IsSplat())
mModule->AggregateSplatIntoAddr(typedVal, memberVal); mModule->AggregateSplatIntoAddr(typedVal, memberVal);
else else
mModule->mBfIRBuilder->CreateStore(typedVal.mValue, memberVal); mModule->mBfIRBuilder->CreateAlignedStore(typedVal.mValue, memberVal, typedVal.mType->mAlign);
} }
} }
} }
@ -20445,14 +20445,14 @@ BfTypedValue BfExprEvaluator::SetupNullConditional(BfTypedValue thisValue, BfTok
{ {
thisValue = mModule->MakeAddressable(thisValue); thisValue = mModule->MakeAddressable(thisValue);
BfIRValue hasValuePtr = mModule->mBfIRBuilder->CreateInBoundsGEP(thisValue.mValue, 0, 1); // mHasValue BfIRValue hasValuePtr = mModule->mBfIRBuilder->CreateInBoundsGEP(thisValue.mValue, 0, 1); // mHasValue
isNotNull = mModule->mBfIRBuilder->CreateLoad(hasValuePtr); isNotNull = mModule->mBfIRBuilder->CreateAlignedLoad(hasValuePtr, 1);
thisValue = BfTypedValue(mModule->mBfIRBuilder->GetFakeVal(), elementType, true); thisValue = BfTypedValue(mModule->mBfIRBuilder->GetFakeVal(), elementType, true);
} }
else else
{ {
thisValue = mModule->MakeAddressable(thisValue); thisValue = mModule->MakeAddressable(thisValue);
BfIRValue hasValuePtr = mModule->mBfIRBuilder->CreateInBoundsGEP(thisValue.mValue, 0, 2); // mHasValue BfIRValue hasValuePtr = mModule->mBfIRBuilder->CreateInBoundsGEP(thisValue.mValue, 0, 2); // mHasValue
isNotNull = mModule->mBfIRBuilder->CreateLoad(hasValuePtr); isNotNull = mModule->mBfIRBuilder->CreateAlignedLoad(hasValuePtr, 1);
BfIRValue valuePtr = mModule->mBfIRBuilder->CreateInBoundsGEP(thisValue.mValue, 0, 1); // mValue BfIRValue valuePtr = mModule->mBfIRBuilder->CreateInBoundsGEP(thisValue.mValue, 0, 1); // mValue
thisValue = BfTypedValue(valuePtr, elementType, true); thisValue = BfTypedValue(valuePtr, elementType, true);
} }
@ -21650,7 +21650,7 @@ void BfExprEvaluator::PerformUnaryOperation_OnResult(BfExpression* unaryOpExpr,
if ((propDef != NULL) && (!ptr.IsAddr())) if ((propDef != NULL) && (!ptr.IsAddr()))
writeToProp = BfTypedValue(resultValue, ptr.mType); writeToProp = BfTypedValue(resultValue, ptr.mType);
else else
mModule->mBfIRBuilder->CreateStore(resultValue, ptr.mValue, mIsVolatileReference); mModule->mBfIRBuilder->CreateAlignedStore(resultValue, ptr.mValue, ptr.mType->mAlign, mIsVolatileReference);
if (unaryOp == BfUnaryOp_PostIncrement) if (unaryOp == BfUnaryOp_PostIncrement)
mResult = BfTypedValue(origVal, ptr.mType, false); mResult = BfTypedValue(origVal, ptr.mType, false);
else else
@ -21707,7 +21707,7 @@ void BfExprEvaluator::PerformUnaryOperation_OnResult(BfExpression* unaryOpExpr,
if ((propDef != NULL) && (!ptr.IsAddr())) if ((propDef != NULL) && (!ptr.IsAddr()))
writeToProp = BfTypedValue(resultValue, ptr.mType); writeToProp = BfTypedValue(resultValue, ptr.mType);
else else
mModule->mBfIRBuilder->CreateStore(resultValue, ptr.mValue, mIsVolatileReference); mModule->mBfIRBuilder->CreateAlignedStore(resultValue, ptr.mValue, ptr.mType->mAlign, mIsVolatileReference);
if (unaryOp == BfUnaryOp_PostDecrement) if (unaryOp == BfUnaryOp_PostDecrement)
mResult = BfTypedValue(origVal, ptr.mType, false); mResult = BfTypedValue(origVal, ptr.mType, false);
else else
@ -22706,7 +22706,7 @@ void BfExprEvaluator::PerformBinaryOperation(BfAstNode* leftExpression, BfAstNod
mModule->mBfIRBuilder->PopulateType(resultType); mModule->mBfIRBuilder->PopulateType(resultType);
BfTypedValue nullableTypedVale = mModule->MakeAddressable(*resultTypedValue); BfTypedValue nullableTypedVale = mModule->MakeAddressable(*resultTypedValue);
BfIRValue hasValuePtr = mModule->mBfIRBuilder->CreateInBoundsGEP(nullableTypedVale.mValue, 0, 1); BfIRValue hasValuePtr = mModule->mBfIRBuilder->CreateInBoundsGEP(nullableTypedVale.mValue, 0, 1);
BfIRValue hasValueValue = mModule->mBfIRBuilder->CreateLoad(hasValuePtr); BfIRValue hasValueValue = mModule->mBfIRBuilder->CreateAlignedLoad(hasValuePtr, 1);
if (isEquality) if (isEquality)
hasValueValue = mModule->mBfIRBuilder->CreateNot(hasValueValue); hasValueValue = mModule->mBfIRBuilder->CreateNot(hasValueValue);
mResult = BfTypedValue(hasValueValue, boolType); mResult = BfTypedValue(hasValueValue, boolType);
@ -22716,7 +22716,7 @@ void BfExprEvaluator::PerformBinaryOperation(BfAstNode* leftExpression, BfAstNod
mModule->mBfIRBuilder->PopulateType(resultType); mModule->mBfIRBuilder->PopulateType(resultType);
BfTypedValue nullableTypedVale = mModule->MakeAddressable(*resultTypedValue); BfTypedValue nullableTypedVale = mModule->MakeAddressable(*resultTypedValue);
BfIRValue hasValuePtr = mModule->mBfIRBuilder->CreateInBoundsGEP(nullableTypedVale.mValue, 0, 2); BfIRValue hasValuePtr = mModule->mBfIRBuilder->CreateInBoundsGEP(nullableTypedVale.mValue, 0, 2);
BfIRValue hasValueValue = mModule->mBfIRBuilder->CreateLoad(hasValuePtr); BfIRValue hasValueValue = mModule->mBfIRBuilder->CreateAlignedLoad(hasValuePtr, 1);
if (isEquality) if (isEquality)
hasValueValue = mModule->mBfIRBuilder->CreateNot(hasValueValue); hasValueValue = mModule->mBfIRBuilder->CreateNot(hasValueValue);
mResult = BfTypedValue(hasValueValue, boolType); mResult = BfTypedValue(hasValueValue, boolType);

55
IDEHelper/Compiler/BfModule.cpp
View file

@ -762,9 +762,9 @@ public:
} }
else else
{ {
auto prevVal = mModule->mBfIRBuilder->CreateLoad(accumValuePtr); auto prevVal = mModule->mBfIRBuilder->CreateAlignedLoad(accumValuePtr, intPtrType->mAlign);
auto addedVal = mModule->mBfIRBuilder->CreateAdd(sizeValue, prevVal); auto addedVal = mModule->mBfIRBuilder->CreateAdd(sizeValue, prevVal);
mModule->mBfIRBuilder->CreateStore(addedVal, accumValuePtr); mModule->mBfIRBuilder->CreateAlignedStore(addedVal, accumValuePtr, intPtrType->mAlign);
} }
} }
} }
@ -2049,7 +2049,7 @@ BfDeferredCallEntry* BfModule::AddStackAlloc(BfTypedValue val, BfIRValue arraySi
BF_ASSERT(!isDynAlloc); BF_ASSERT(!isDynAlloc);
auto valPtr = CreateAlloca(checkBaseType); auto valPtr = CreateAlloca(checkBaseType);
mBfIRBuilder->ClearDebugLocation_Last(); mBfIRBuilder->ClearDebugLocation_Last();
mBfIRBuilder->CreateStore(useVal, valPtr); mBfIRBuilder->CreateAlignedStore(useVal, valPtr, checkBaseType->mAlign);
mBfIRBuilder->ClearDebugLocation_Last(); mBfIRBuilder->ClearDebugLocation_Last();
useVal = valPtr; useVal = valPtr;
} }
@ -4523,7 +4523,7 @@ BfTypedValue BfModule::GetFieldInitializerValue(BfFieldInstance* fieldInstance,
{ {
result = LoadValue(result); result = LoadValue(result);
if (!result.mType->IsValuelessType()) if (!result.mType->IsValuelessType())
mBfIRBuilder->CreateStore(result.mValue, staticVarRef.mValue); mBfIRBuilder->CreateAlignedStore(result.mValue, staticVarRef.mValue, result.mType->mAlign);
} }
} }
@ -8613,9 +8613,9 @@ BfTypedValue BfModule::FlushNullConditional(BfTypedValue result, bool ignoreNull
else else
{ {
BfIRValue ptrValue = mBfIRBuilder->CreateInBoundsGEP(nullableTypedValue.mValue, 0, 1); // mValue BfIRValue ptrValue = mBfIRBuilder->CreateInBoundsGEP(nullableTypedValue.mValue, 0, 1); // mValue
mBfIRBuilder->CreateStore(result.mValue, ptrValue); mBfIRBuilder->CreateAlignedStore(result.mValue, ptrValue, result.mType->mAlign);
ptrValue = mBfIRBuilder->CreateInBoundsGEP(nullableTypedValue.mValue, 0, 2); // mHasValue ptrValue = mBfIRBuilder->CreateInBoundsGEP(nullableTypedValue.mValue, 0, 2); // mHasValue
mBfIRBuilder->CreateStore(GetConstValue(1, GetPrimitiveType(BfTypeCode_Boolean)), ptrValue); mBfIRBuilder->CreateAlignedStore(GetConstValue(1, GetPrimitiveType(BfTypeCode_Boolean)), ptrValue, 1);
} }
result = nullableTypedValue; result = nullableTypedValue;
} }
@ -10444,7 +10444,7 @@ BfTypedValue BfModule::BoxValue(BfAstNode* srcNode, BfTypedValue typedVal, BfTyp
AggregateSplatIntoAddr(typedVal, valPtr); AggregateSplatIntoAddr(typedVal, valPtr);
} }
else else
mBfIRBuilder->CreateStore(typedVal.mValue, valPtr); mBfIRBuilder->CreateStore(typedVal.mValue, valPtr, typedVal.mType->mAlign);
} }
} }
@ -12446,7 +12446,7 @@ BfTypedValue BfModule::RemoveRef(BfTypedValue typedValue)
typedValue = BfTypedValue(typedValue.mValue, elementType, true); typedValue = BfTypedValue(typedValue.mValue, elementType, true);
} }
else else
typedValue = BfTypedValue(mBfIRBuilder->CreateLoad(typedValue.mValue), elementType, true); typedValue = BfTypedValue(mBfIRBuilder->CreateAlignedLoad(typedValue.mValue, elementType->mAlign), elementType, true);
} }
else else
typedValue = BfTypedValue(typedValue.mValue, elementType, true); typedValue = BfTypedValue(typedValue.mValue, elementType, true);
@ -12881,7 +12881,7 @@ BfIRValue BfModule::ExtractSplatValue(BfTypedValue typedValue, int componentIdx,
} }
else else
{ {
val = mBfIRBuilder->CreateLoad(val); val = mBfIRBuilder->CreateAlignedLoad(val, wantType->mAlign);
break; break;
} }
} }
@ -13083,7 +13083,7 @@ BfIRValue BfModule::ExtractValue(BfTypedValue typedValue, int dataIdx)
if (typedValue.IsAddr()) if (typedValue.IsAddr())
{ {
auto addrVal = mBfIRBuilder->CreateInBoundsGEP(typedValue.mValue, 0, dataIdx); auto addrVal = mBfIRBuilder->CreateInBoundsGEP(typedValue.mValue, 0, dataIdx);
return mBfIRBuilder->CreateLoad(addrVal); return mBfIRBuilder->CreateAlignedLoad(addrVal, typedValue.mType->mAlign);
} }
return mBfIRBuilder->CreateExtractValue(typedValue.mValue, dataIdx); return mBfIRBuilder->CreateExtractValue(typedValue.mValue, dataIdx);
} }
@ -14509,7 +14509,7 @@ BfIRValue BfModule::GetInterfaceSlotNum(BfTypeInstance* ifaceType)
mInterfaceSlotRefs[ifaceType] = globalValue; mInterfaceSlotRefs[ifaceType] = globalValue;
} }
return mBfIRBuilder->CreateLoad(globalValue/*, "slotOfs"*/); return mBfIRBuilder->CreateAlignedLoad(globalValue/*, "slotOfs"*/, 4);
} }
void BfModule::HadSlotCountDependency() void BfModule::HadSlotCountDependency()
@ -14724,7 +14724,7 @@ BfTypedValue BfModule::ReferenceStaticField(BfFieldInstance* fieldInstance)
return BfTypedValue(globalValue, type, !fieldDef->mIsConst); return BfTypedValue(globalValue, type, !fieldDef->mIsConst);
} }
int BfModule::GetFieldDataIdx(BfTypeInstance* typeInst, int fieldIdx, const char* fieldName) BfFieldInstance* BfModule::GetFieldInstance(BfTypeInstance* typeInst, int fieldIdx, const char* fieldName)
{ {
if (typeInst->IsDataIncomplete()) if (typeInst->IsDataIncomplete())
PopulateType(typeInst); PopulateType(typeInst);
@ -14733,8 +14733,7 @@ int BfModule::GetFieldDataIdx(BfTypeInstance* typeInst, int fieldIdx, const char
Fail(StrFormat("Invalid field data in type '%s'", TypeToString(typeInst).c_str())); Fail(StrFormat("Invalid field data in type '%s'", TypeToString(typeInst).c_str()));
return 0; return 0;
} }
auto& fieldInstance = typeInst->mFieldInstances[fieldIdx]; return &typeInst->mFieldInstances[fieldIdx];
return fieldInstance.mDataIdx;
} }
void BfModule::MarkUsingThis() void BfModule::MarkUsingThis()
@ -14866,7 +14865,7 @@ BfTypedValue BfModule::GetThis(bool markUsing)
else if ((thisLocal->mIsSplat) || (thisLocal->mIsLowered)) else if ((thisLocal->mIsSplat) || (thisLocal->mIsLowered))
thisValue = thisLocal->mAddr; thisValue = thisLocal->mAddr;
else else
thisValue = mBfIRBuilder->CreateLoad(thisLocal->mAddr); thisValue = mBfIRBuilder->CreateAlignedLoad(thisLocal->mAddr, thisLocal->mResolvedType->mAlign);
if (markUsing) if (markUsing)
useMethodState->mLocals[0]->mReadFromId = useMethodState->GetRootMethodState()->mCurAccessId++; useMethodState->mLocals[0]->mReadFromId = useMethodState->GetRootMethodState()->mCurAccessId++;
@ -15935,9 +15934,9 @@ void BfModule::EmitReturn(const BfTypedValue& val)
{ {
BfIRValue retVal = mCurMethodState->mRetVal.mValue; BfIRValue retVal = mCurMethodState->mRetVal.mValue;
if (!mCurMethodState->mRetVal) if (!mCurMethodState->mRetVal)
retVal = mBfIRBuilder->CreateLoad(mCurMethodState->mRetValAddr); retVal = mBfIRBuilder->CreateAlignedLoad(mCurMethodState->mRetValAddr, mCurMethodInstance->mReturnType->mAlign);
mBfIRBuilder->CreateStore(val.mValue, retVal); mBfIRBuilder->CreateAlignedStore(val.mValue, retVal, mCurMethodInstance->mReturnType->mAlign);
} }
else if (mIsComptimeModule) else if (mIsComptimeModule)
{ {
@ -16089,7 +16088,7 @@ void BfModule::CreateDelegateInvokeMethod()
auto multicastDelegate = mBfIRBuilder->CreateBitCast(mCurMethodState->mLocals[0]->mValue, mBfIRBuilder->MapType(multicastDelegateType)); auto multicastDelegate = mBfIRBuilder->CreateBitCast(mCurMethodState->mLocals[0]->mValue, mBfIRBuilder->MapType(multicastDelegateType));
auto fieldPtr = mBfIRBuilder->CreateInBoundsGEP(multicastDelegate, 0, 2); // Load 'delegate.mTarget' auto fieldPtr = mBfIRBuilder->CreateInBoundsGEP(multicastDelegate, 0, 2); // Load 'delegate.mTarget'
auto fieldVal = mBfIRBuilder->CreateLoad(fieldPtr); auto fieldVal = mBfIRBuilder->CreateAlignedLoad(fieldPtr, mSystem->mPtrSize);
BfExprEvaluator exprEvaluator(this); BfExprEvaluator exprEvaluator(this);
@ -16151,7 +16150,7 @@ void BfModule::CreateDelegateInvokeMethod()
memberFuncArgs[thisIdx] = mBfIRBuilder->CreateBitCast(fieldVal, mBfIRBuilder->MapType(mCurTypeInstance)); memberFuncArgs[thisIdx] = mBfIRBuilder->CreateBitCast(fieldVal, mBfIRBuilder->MapType(mCurTypeInstance));
auto fieldPtr = mBfIRBuilder->CreateInBoundsGEP(multicastDelegate, 0, 1); // Load 'delegate.mFuncPtr' auto fieldPtr = mBfIRBuilder->CreateInBoundsGEP(multicastDelegate, 0, 1); // Load 'delegate.mFuncPtr'
auto funcPtrPtr = mBfIRBuilder->CreateBitCast(fieldPtr, memberFuncPtrPtr); auto funcPtrPtr = mBfIRBuilder->CreateBitCast(fieldPtr, memberFuncPtrPtr);
auto funcPtr = mBfIRBuilder->CreateLoad(funcPtrPtr); auto funcPtr = mBfIRBuilder->CreateAlignedLoad(funcPtrPtr, mSystem->mPtrSize);
nonStaticResult = mBfIRBuilder->CreateCall(funcPtr, memberFuncArgs); nonStaticResult = mBfIRBuilder->CreateCall(funcPtr, memberFuncArgs);
if ((!mIsComptimeModule) && (mCurMethodInstance->GetStructRetIdx() != -1)) if ((!mIsComptimeModule) && (mCurMethodInstance->GetStructRetIdx() != -1))
mBfIRBuilder->Call_AddAttribute(nonStaticResult, mCurMethodInstance->GetStructRetIdx() + 1, BfIRAttribute_StructRet); mBfIRBuilder->Call_AddAttribute(nonStaticResult, mCurMethodInstance->GetStructRetIdx() + 1, BfIRAttribute_StructRet);
@ -16169,7 +16168,7 @@ void BfModule::CreateDelegateInvokeMethod()
mBfIRBuilder->SetInsertPoint(falseBB); mBfIRBuilder->SetInsertPoint(falseBB);
auto fieldPtr = mBfIRBuilder->CreateInBoundsGEP(multicastDelegate, 0, 1); // Load 'delegate.mFuncPtr' auto fieldPtr = mBfIRBuilder->CreateInBoundsGEP(multicastDelegate, 0, 1); // Load 'delegate.mFuncPtr'
auto funcPtrPtr = mBfIRBuilder->CreateBitCast(fieldPtr, staticFuncPtrPtr); auto funcPtrPtr = mBfIRBuilder->CreateBitCast(fieldPtr, staticFuncPtrPtr);
auto funcPtr = mBfIRBuilder->CreateLoad(funcPtrPtr); auto funcPtr = mBfIRBuilder->CreateAlignedLoad(funcPtrPtr, mSystem->mPtrSize);
staticResult = mBfIRBuilder->CreateCall(funcPtr, staticFuncArgs); staticResult = mBfIRBuilder->CreateCall(funcPtr, staticFuncArgs);
if ((!mIsComptimeModule) && (mCurMethodInstance->GetStructRetIdx(true) != -1)) if ((!mIsComptimeModule) && (mCurMethodInstance->GetStructRetIdx(true) != -1))
{ {
@ -17452,7 +17451,7 @@ void BfModule::EmitCtorBody(bool& skipBody)
if ((mCurTypeInstance->IsTypedPrimitive()) && (!mCurTypeInstance->IsValuelessType())) if ((mCurTypeInstance->IsTypedPrimitive()) && (!mCurTypeInstance->IsValuelessType()))
{ {
// Zero out typed primitives in ctor // Zero out typed primitives in ctor
mBfIRBuilder->CreateStore(GetDefaultValue(mCurTypeInstance->GetUnderlyingType()), mBfIRBuilder->GetArgument(0)); mBfIRBuilder->CreateAlignedStore(GetDefaultValue(mCurTypeInstance->GetUnderlyingType()), mBfIRBuilder->GetArgument(0), mCurTypeInstance->mAlign);
} }
if ((!mCurTypeInstance->IsBoxed()) && (methodDef->mMethodType == BfMethodType_Ctor) && (!hadThisInitializer)) if ((!mCurTypeInstance->IsBoxed()) && (methodDef->mMethodType == BfMethodType_Ctor) && (!hadThisInitializer))
@ -17636,7 +17635,7 @@ void BfModule::EmitCtorBody(bool& skipBody)
} }
if ((fieldAddr) && (assignValue)) if ((fieldAddr) && (assignValue))
mBfIRBuilder->CreateStore(assignValue.mValue, fieldAddr); mBfIRBuilder->CreateAlignedStore(assignValue.mValue, fieldAddr, fieldInst->mResolvedType->mAlign);
} }
} }
@ -20300,7 +20299,7 @@ void BfModule::ProcessMethod(BfMethodInstance* methodInstance, bool isInlineDup,
auto primType = mBfIRBuilder->GetPrimitiveType(loweredTypeCode); auto primType = mBfIRBuilder->GetPrimitiveType(loweredTypeCode);
auto primPtrType = mBfIRBuilder->GetPointerTo(primType); auto primPtrType = mBfIRBuilder->GetPointerTo(primType);
auto primPtrVal = mBfIRBuilder->CreateBitCast(paramVar->mAddr, primPtrType); auto primPtrVal = mBfIRBuilder->CreateBitCast(paramVar->mAddr, primPtrType);
mBfIRBuilder->CreateStore(paramVar->mValue, primPtrVal); mBfIRBuilder->CreateAlignedStore(paramVar->mValue, primPtrVal, mCurTypeInstance->mAlign);
if (loweredTypeCode2 != BfTypeCode_None) if (loweredTypeCode2 != BfTypeCode_None)
{ {
@ -20474,7 +20473,7 @@ void BfModule::ProcessMethod(BfMethodInstance* methodInstance, bool isInlineDup,
// We don't allow actually assignment to "this", so we just do a single load // We don't allow actually assignment to "this", so we just do a single load
// Keep in mind we don't use the ACTUAL mValue value because that's a register, but // Keep in mind we don't use the ACTUAL mValue value because that's a register, but
// we need to store it in the stack frame for debugging purposes // we need to store it in the stack frame for debugging purposes
auto loadedThis = mBfIRBuilder->CreateLoad(paramVar->mAddr/*, "this"*/); auto loadedThis = mBfIRBuilder->CreateAlignedLoad(paramVar->mAddr/*, "this"*/, paramVar->mResolvedType->mAlign);
mBfIRBuilder->ClearDebugLocation(loadedThis); mBfIRBuilder->ClearDebugLocation(loadedThis);
paramVar->mValue = loadedThis; paramVar->mValue = loadedThis;
} }
@ -20985,7 +20984,7 @@ void BfModule::ProcessMethod(BfMethodInstance* methodInstance, bool isInlineDup,
BfExprEvaluator exprEvaluator(this); BfExprEvaluator exprEvaluator(this);
auto localVal = exprEvaluator.LoadLocal(lastParam); auto localVal = exprEvaluator.LoadLocal(lastParam);
localVal = LoadOrAggregateValue(localVal); localVal = LoadOrAggregateValue(localVal);
mBfIRBuilder->CreateStore(localVal.mValue, lookupAddr); mBfIRBuilder->CreateAlignedStore(localVal.mValue, lookupAddr, localVal.mType->mAlign);
} }
else if (!fieldInstance->mResolvedType->IsValuelessType()) else if (!fieldInstance->mResolvedType->IsValuelessType())
{ {
@ -21034,7 +21033,7 @@ void BfModule::ProcessMethod(BfMethodInstance* methodInstance, bool isInlineDup,
{ {
auto ptrType = CreatePointerType(mCurMethodInstance->mReturnType); auto ptrType = CreatePointerType(mCurMethodInstance->mReturnType);
auto allocaInst = AllocLocalVariable(ptrType, "__return.addr", false); auto allocaInst = AllocLocalVariable(ptrType, "__return.addr", false);
auto storeInst = mBfIRBuilder->CreateStore(mBfIRBuilder->GetArgument(mCurMethodInstance->GetStructRetIdx()), allocaInst); auto storeInst = mBfIRBuilder->CreateAlignedStore(mBfIRBuilder->GetArgument(mCurMethodInstance->GetStructRetIdx()), allocaInst, mCurMethodInstance->mReturnType->mAlign);
mBfIRBuilder->ClearDebugLocation(storeInst); mBfIRBuilder->ClearDebugLocation(storeInst);
mCurMethodState->mRetValAddr = allocaInst; mCurMethodState->mRetValAddr = allocaInst;
} }
@ -21047,7 +21046,7 @@ void BfModule::ProcessMethod(BfMethodInstance* methodInstance, bool isInlineDup,
if (methodDef->mMethodType == BfMethodType_CtorCalcAppend) if (methodDef->mMethodType == BfMethodType_CtorCalcAppend)
{ {
mBfIRBuilder->CreateStore(GetConstValue(0), mCurMethodState->mRetVal.mValue); mBfIRBuilder->CreateAlignedStore(GetConstValue(0), mCurMethodState->mRetVal.mValue, mCurMethodState->mRetVal.mType->mAlign);
BfGetSymbolReferenceKind prevSymbolKind; BfGetSymbolReferenceKind prevSymbolKind;
BfAutoComplete* prevAutoComplete; BfAutoComplete* prevAutoComplete;
if (mCompiler->mResolvePassData != NULL) if (mCompiler->mResolvePassData != NULL)
@ -21234,7 +21233,7 @@ void BfModule::ProcessMethod(BfMethodInstance* methodInstance, bool isInlineDup,
if ((mCurMethodState->mRetVal) && if ((mCurMethodState->mRetVal) &&
((mIsComptimeModule) || (mCurMethodInstance->GetStructRetIdx() == -1))) ((mIsComptimeModule) || (mCurMethodInstance->GetStructRetIdx() == -1)))
{ {
auto loadedVal = mBfIRBuilder->CreateLoad(mCurMethodState->mRetVal.mValue); auto loadedVal = mBfIRBuilder->CreateAlignedLoad(mCurMethodState->mRetVal.mValue, mCurMethodState->mRetVal.mType->mAlign);
CreateReturn(loadedVal); CreateReturn(loadedVal);

2
IDEHelper/Compiler/BfModule.h
View file

@ -1696,7 +1696,7 @@ public:
BfTypedValue GetCompilerFieldValue(const StringImpl& str); BfTypedValue GetCompilerFieldValue(const StringImpl& str);
BfTypedValue GetCompilerFieldValue(const BfTypedValue typedVal); BfTypedValue GetCompilerFieldValue(const BfTypedValue typedVal);
BfTypedValue ReferenceStaticField(BfFieldInstance* fieldInstance); BfTypedValue ReferenceStaticField(BfFieldInstance* fieldInstance);
int GetFieldDataIdx(BfTypeInstance* typeInst, int fieldIdx, const char* fieldName = NULL); BfFieldInstance* GetFieldInstance(BfTypeInstance* typeInst, int fieldIdx, const char* fieldName = NULL);
BfTypedValue GetThis(bool markUsing = true); BfTypedValue GetThis(bool markUsing = true);
void MarkUsingThis(); void MarkUsingThis();
BfLocalVariable* GetThisVariable(); BfLocalVariable* GetThisVariable();

28
IDEHelper/Compiler/BfStmtEvaluator.cpp
View file

@ -1924,7 +1924,7 @@ BfLocalVariable* BfModule::HandleVariableDeclaration(BfVariableDeclaration* varD
BfLocalVariable* localVar = AddLocalVariableDef(localDef, true, false, BfIRValue(), initType); BfLocalVariable* localVar = AddLocalVariableDef(localDef, true, false, BfIRValue(), initType);
if (wantsStore) if (wantsStore)
mBfIRBuilder->CreateStore(initValue.mValue, localVar->mAddr); mBfIRBuilder->CreateAlignedStore(initValue.mValue, localVar->mAddr, localVar->mResolvedType->mAlign);
return localVar; return localVar;
} }
@ -5962,7 +5962,7 @@ void BfModule::DoForLess(BfForEachStatement* forEachStmt)
CheckVariableDef(localDef); CheckVariableDef(localDef);
mBfIRBuilder->CreateStore(GetDefaultValue(varType), localDef->mAddr); mBfIRBuilder->CreateAlignedStore(GetDefaultValue(varType), localDef->mAddr, varType->mAlign);
localDef->Init(); localDef->Init();
UpdateExprSrcPos(forEachStmt->mVariableName); UpdateExprSrcPos(forEachStmt->mVariableName);
@ -5992,7 +5992,7 @@ void BfModule::DoForLess(BfForEachStatement* forEachStmt)
// Cond // Cond
auto valueScopeStart = ValueScopeStart(); auto valueScopeStart = ValueScopeStart();
auto localVal = mBfIRBuilder->CreateLoad(localDef->mAddr); auto localVal = mBfIRBuilder->CreateAlignedLoad(localDef->mAddr, localDef->mResolvedType->mAlign);
if (!target) if (!target)
{ {
// Soldier on // Soldier on
@ -6029,9 +6029,9 @@ void BfModule::DoForLess(BfForEachStatement* forEachStmt)
auto one = GetConstValue(1, localDef->mResolvedType); auto one = GetConstValue(1, localDef->mResolvedType);
// We have to reload localVal before the inc, user logic could have changed it // We have to reload localVal before the inc, user logic could have changed it
localVal = mBfIRBuilder->CreateLoad(localDef->mAddr); localVal = mBfIRBuilder->CreateAlignedLoad(localDef->mAddr, localDef->mResolvedType->mAlign);
auto result = mBfIRBuilder->CreateAdd(localVal, one); auto result = mBfIRBuilder->CreateAdd(localVal, one);
mBfIRBuilder->CreateStore(result, localDef->mAddr); mBfIRBuilder->CreateAlignedStore(result, localDef->mAddr, localDef->mResolvedType->mAlign);
ValueScopeEnd(valueScopeStart); ValueScopeEnd(valueScopeStart);
mBfIRBuilder->CreateBr(condBB); mBfIRBuilder->CreateBr(condBB);
@ -6508,7 +6508,7 @@ void BfModule::Visit(BfForEachStatement* forEachStmt)
else else
tuplePtr = mBfIRBuilder->CreateBitCast(varInst, mBfIRBuilder->MapType(tuplePtrType)); tuplePtr = mBfIRBuilder->CreateBitCast(varInst, mBfIRBuilder->MapType(tuplePtrType));
auto valAddr = mBfIRBuilder->CreateInBoundsGEP(tuplePtr, 0, fieldInstance->mDataIdx); auto valAddr = mBfIRBuilder->CreateInBoundsGEP(tuplePtr, 0, fieldInstance->mDataIdx);
mBfIRBuilder->CreateStore(valAddr, localDef->mAddr); mBfIRBuilder->CreateAlignedStore(valAddr, localDef->mAddr, localDef->mResolvedType->mAlign);
} }
UpdateSrcPos(forEachStmt); UpdateSrcPos(forEachStmt);
@ -6550,7 +6550,7 @@ void BfModule::Visit(BfForEachStatement* forEachStmt)
if (!needsValCopy) if (!needsValCopy)
{ {
auto valAddr = mBfIRBuilder->CreateBitCast(nextResult.mValue, mBfIRBuilder->MapType(varType)); auto valAddr = mBfIRBuilder->CreateBitCast(nextResult.mValue, mBfIRBuilder->MapType(varType));
mBfIRBuilder->CreateStore(valAddr, varInst); mBfIRBuilder->CreateAlignedStore(valAddr, varInst, varType->mAlign);
} }
UpdateSrcPos(forEachStmt); UpdateSrcPos(forEachStmt);
@ -6605,7 +6605,7 @@ void BfModule::Visit(BfForEachStatement* forEachStmt)
autoComplete->CheckVarResolution(forEachStmt->mVariableTypeRef, varType); autoComplete->CheckVarResolution(forEachStmt->mVariableTypeRef, varType);
if (isArray || isSizedArray) if (isArray || isSizedArray)
mBfIRBuilder->CreateStore(GetConstValue(0), itr.mValue); mBfIRBuilder->CreateAlignedStore(GetConstValue(0), itr.mValue, itr.mType->mAlign);
auto valueScopeStartInner = ValueScopeStart(); auto valueScopeStartInner = ValueScopeStart();
@ -6642,7 +6642,7 @@ void BfModule::Visit(BfForEachStatement* forEachStmt)
} }
else if (isArray) // if (i < array.mLength) else if (isArray) // if (i < array.mLength)
{ {
auto itrVal = mBfIRBuilder->CreateLoad(itr.mValue); auto itrVal = mBfIRBuilder->CreateAlignedLoad(itr.mValue, itr.mType->mAlign);
auto arrayType = (BfArrayType*)target.mType; auto arrayType = (BfArrayType*)target.mType;
PopulateType(arrayType); PopulateType(arrayType);
auto arrayBaseValue = mBfIRBuilder->CreateBitCast(target.mValue, mBfIRBuilder->MapType(arrayType->mBaseType, BfIRPopulateType_Full)); auto arrayBaseValue = mBfIRBuilder->CreateBitCast(target.mValue, mBfIRBuilder->MapType(arrayType->mBaseType, BfIRPopulateType_Full));
@ -6659,8 +6659,12 @@ void BfModule::Visit(BfForEachStatement* forEachStmt)
} }
else else
{ {
auto lengthValAddr = mBfIRBuilder->CreateInBoundsGEP(arrayBaseValue, 0, GetFieldDataIdx(arrayType->mBaseType, 0, "mLength")); auto fieldInst = GetFieldInstance(arrayType->mBaseType, 0, "mLength");
lengthVal = mBfIRBuilder->CreateLoad(lengthValAddr); if (fieldInst != NULL)
{
auto lengthValAddr = mBfIRBuilder->CreateInBoundsGEP(arrayBaseValue, 0, fieldInst->mDataIdx);
lengthVal = mBfIRBuilder->CreateAlignedLoad(lengthValAddr, fieldInst->mResolvedType->mAlign);
}
} }
lengthVal = mBfIRBuilder->CreateNumericCast(lengthVal, true, BfTypeCode_IntPtr); lengthVal = mBfIRBuilder->CreateNumericCast(lengthVal, true, BfTypeCode_IntPtr);
conditionValue = mBfIRBuilder->CreateCmpLT(itrVal, lengthVal, true); conditionValue = mBfIRBuilder->CreateCmpLT(itrVal, lengthVal, true);
@ -6808,7 +6812,7 @@ void BfModule::Visit(BfForEachStatement* forEachStmt)
nextVal = Cast(forEachStmt->mCollectionExpression, nextVal, varType, BfCastFlags_Explicit); nextVal = Cast(forEachStmt->mCollectionExpression, nextVal, varType, BfCastFlags_Explicit);
nextVal = LoadValue(nextVal); nextVal = LoadValue(nextVal);
if ((nextVal) && (!nextVal.mType->IsValuelessType())) if ((nextVal) && (!nextVal.mType->IsValuelessType()))
mBfIRBuilder->CreateStore(nextVal.mValue, varInst); mBfIRBuilder->CreateAlignedStore(nextVal.mValue, varInst, nextVal.mType->mAlign);
} }
} }
} }