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

Start of SIMD support

Browse source
This commit is contained in:
Brian Fiete 2020-08-23 05:42:42 -07:00
parent 73e260c1d5
commit 64b62c09be
30 changed files with 5846 additions and 5096 deletions
Download patch file Download diff file Expand all files Collapse all files

29
IDEHelper/Backend/BeContext.cpp
View file

@ -56,6 +56,15 @@ BeType* BeContext::GetPrimitiveType(BeTypeCode typeCode)
case BeTypeCode_Double:
primType->mSize = primType->mAlign = 8;
break;
case BeTypeCode_M128:
primType->mSize = primType->mAlign = 16;
break;
case BeTypeCode_M256:
primType->mSize = primType->mAlign = 32;
break;
case BeTypeCode_M512:
primType->mSize = primType->mAlign = 64;
break;
}
mPrimitiveTypes[(int)typeCode] = primType;
return primType;
@ -152,6 +161,18 @@ BeSizedArrayType* BeContext::CreateSizedArrayType(BeType* type, int length)
return arrayType;
}
BeVectorType* BeContext::CreateVectorType(BeType* type, int length)
{
auto arrayType = mTypes.Alloc<BeVectorType>();
arrayType->mContext = this;
arrayType->mTypeCode = BeTypeCode_Vector;
arrayType->mElementType = type;
arrayType->mLength = length;
arrayType->mSize = type->mSize * length;
arrayType->mAlign = type->mAlign;
return arrayType;
}
BeFunctionType* BeContext::CreateFunctionType(BeType* returnType, const SizedArrayImpl<BeType*>& paramTypes, bool isVarArg)
{
auto funcType = mTypes.Alloc<BeFunctionType>();
@ -196,6 +217,14 @@ bool BeContext::AreTypesEqual(BeType* lhs, BeType* rhs)
if (lhsSizedArray->mLength != rhsSizedArray->mLength)
return false;
return AreTypesEqual(lhsSizedArray->mElementType, rhsSizedArray->mElementType);
}
case BeTypeCode_Vector:
{
auto lhsSizedArray = (BeVectorType*)lhs;
auto rhsSizedArray = (BeVectorType*)rhs;
if (lhsSizedArray->mLength != rhsSizedArray->mLength)
return false;
return AreTypesEqual(lhsSizedArray->mElementType, rhsSizedArray->mElementType);
}
}
return false;

35
IDEHelper/Backend/BeContext.h
View file

@ -20,10 +20,14 @@ enum BeTypeCode
BeTypeCode_Int64,
BeTypeCode_Float,
BeTypeCode_Double,
BeTypeCode_M128,
BeTypeCode_M256,
BeTypeCode_M512,
BeTypeCode_Struct,
BeTypeCode_Function,
BeTypeCode_Pointer,
BeTypeCode_SizedArray,
BeTypeCode_Vector,
BeTypeCode_CmpResult, // Psuedo
BeTypeCode_COUNT
@ -122,7 +126,22 @@ public:
return (mTypeCode == BeTypeCode_SizedArray);
}
bool IsVector()
{
return (mTypeCode == BeTypeCode_Vector) || (mTypeCode == BeTypeCode_M128) || (mTypeCode == BeTypeCode_M256) || (mTypeCode == BeTypeCode_M512);
}
bool IsExplicitVectorType()
{
return (mTypeCode == BeTypeCode_Vector);
}
bool IsComposite()
{
return (mTypeCode == BeTypeCode_Struct) || (mTypeCode == BeTypeCode_SizedArray) || (mTypeCode == BeTypeCode_Vector) || (mTypeCode == BeTypeCode_M128) || (mTypeCode == BeTypeCode_M256) || (mTypeCode == BeTypeCode_M512);
}
bool IsNonVectorComposite()
{
return (mTypeCode == BeTypeCode_Struct) || (mTypeCode == BeTypeCode_SizedArray);
}
@ -191,6 +210,21 @@ public:
}
};
class BeVectorType : public BeType
{
public:
BeContext* mContext;
BeType* mElementType;
int mLength;
virtual void HashContent(BeHashContext& hashCtx) override
{
hashCtx.Mixin(BeTypeCode_Vector);
hashCtx.Mixin(mLength);
mElementType->HashReference(hashCtx);
}
};
class BeFunctionTypeParam
{
public:
@ -239,6 +273,7 @@ public:
BePointerType* GetPointerTo(BeType* beType);
void SetStructBody(BeStructType* structType, const SizedArrayImpl<BeType*>& types, bool packed);
BeSizedArrayType* CreateSizedArrayType(BeType* type, int length);
BeVectorType* CreateVectorType(BeType* type, int length);
BeFunctionType* CreateFunctionType(BeType* returnType, const SizedArrayImpl<BeType*>& paramTypes, bool isVarArg);
bool AreTypesEqual(BeType* lhs, BeType* rhs);

56
IDEHelper/Backend/BeIRCodeGen.cpp
View file

@ -1015,7 +1015,10 @@ void BeIRCodeGen::HandleNextCmd()
{
CMD_PARAM(int, typeId);
CMD_PARAM(BeType*, type);
GetTypeEntry(typeId).mBeType = type;
auto& typeEntry = GetTypeEntry(typeId);
typeEntry.mBeType = type;
if (typeEntry.mInstBeType == NULL)
typeEntry.mInstBeType = type;
}
break;
case BfIRCmd_SetInstType:
@ -1100,6 +1103,13 @@ void BeIRCodeGen::HandleNextCmd()
SetResult(curId, mBeContext->CreateSizedArrayType(elementType, length));
}
break;
case BfIRCmd_GetVectorType:
{
CMD_PARAM(BeType*, elementType);
CMD_PARAM(int, length);
SetResult(curId, mBeContext->CreateVectorType(elementType, length));
}
break;
case BfIRCmd_CreateConstStruct:
{
CMD_PARAM(BeType*, type);
@ -2050,49 +2060,14 @@ void BeIRCodeGen::HandleNextCmd()
break;
case BfIRCmd_GetIntrinsic:
{
CMD_PARAM(String, intrinName);
CMD_PARAM(int, intrinId);
CMD_PARAM(BeType*, returnType);
CMD_PARAM(CmdParamVec<BeType*>, paramTypes);
auto intrin = mBeModule->mAlloc.Alloc<BeIntrinsic>();
intrin->mKind = (BfIRIntrinsic)intrinId;
switch (intrin->mKind)
{
case BfIRIntrinsic_Abs:
intrin->mReturnType = paramTypes[0];
break;
case BfIRIntrinsic_AtomicAdd:
case BfIRIntrinsic_AtomicAnd:
case BfIRIntrinsic_AtomicCmpXChg:
case BfIRIntrinsic_AtomicLoad:
case BfIRIntrinsic_AtomicMax:
case BfIRIntrinsic_AtomicMin:
case BfIRIntrinsic_AtomicNAnd:
case BfIRIntrinsic_AtomicOr:
case BfIRIntrinsic_AtomicSub:
case BfIRIntrinsic_AtomicUMax:
case BfIRIntrinsic_AtomicUMin:
case BfIRIntrinsic_AtomicXChg:
case BfIRIntrinsic_AtomicXor:
if (!paramTypes.IsEmpty())
{
BF_ASSERT(paramTypes[0]->IsPointer());
if (paramTypes[0]->IsPointer())
intrin->mReturnType = ((BePointerType*)paramTypes[0])->mElementType;
}
else
intrin->mReturnType = mBeContext->GetPrimitiveType(BeTypeCode_None);
break;
case BfIRIntrinsic_AtomicCmpStore:
case BfIRIntrinsic_AtomicCmpStore_Weak:
intrin->mReturnType = mBeContext->GetPrimitiveType(BeTypeCode_Boolean);
break;
case BfIRIntrinsic_Cast:
intrin->mReturnType = returnType;
break;
}
intrin->mReturnType = returnType;
SetResult(curId, intrin);
}
break;
@ -2585,7 +2560,10 @@ void BeIRCodeGen::HandleNextCmd()
{
CMD_PARAM(int, typeId);
CMD_PARAM(BeMDNode*, type);
GetTypeEntry(typeId).mDIType = (BeDbgType*)type;
auto& typeEntry = GetTypeEntry(typeId);
typeEntry.mDIType = (BeDbgType*)type;
if (typeEntry.mInstDIType == NULL)
typeEntry.mInstDIType = (BeDbgType*)type;
}
break;
case BfIRCmd_DbgSetInstType:

9744
IDEHelper/Backend/BeMCContext.cpp
View file

File diff suppressed because it is too large Load diff

16
IDEHelper/Backend/BeMCContext.h
View file

@ -192,11 +192,13 @@ enum BeMCOperandKind
BeMCOperandKind_Immediate_i16,
BeMCOperandKind_Immediate_i32,
BeMCOperandKind_Immediate_i64,
BeMCOperandKind_Immediate_HomeSize,
BeMCOperandKind_Immediate_Null,
BeMCOperandKind_Immediate_f32,
BeMCOperandKind_Immediate_f64,
BeMCOperandKind_Immediate_f32_Packed128,
BeMCOperandKind_Immediate_f64_Packed128,
BeMCOperandKind_Immediate_int32x4,
BeMCOperandKind_ConstAgg,
BeMCOperandKind_Block,
BeMCOperandKind_Label,
@ -283,12 +285,12 @@ public:
bool IsImmediateInt() const
{
return ((mKind >= BeMCOperandKind_Immediate_i8) && (mKind <= BeMCOperandKind_Immediate_i64));
return ((mKind >= BeMCOperandKind_Immediate_i8) && (mKind <= BeMCOperandKind_Immediate_HomeSize));
}
bool IsImmediateFloat() const
{
return ((mKind >= BeMCOperandKind_Immediate_f32) && (mKind <= BeMCOperandKind_Immediate_f64_Packed128));
return ((mKind >= BeMCOperandKind_Immediate_f32) && (mKind <= BeMCOperandKind_Immediate_int32x4));
}
bool IsNativeReg() const
@ -925,10 +927,12 @@ enum BeMCInstForm
BeMCInstForm_FRM64_XMM32,
BeMCInstForm_FRM32_XMM64,
BeMCInstForm_FRM64_XMM64,
BeMCInstForm_FRM128_XMM128,
BeMCInstForm_XMM32_RM32,
BeMCInstForm_XMM64_RM32,
BeMCInstForm_XMM32_RM64,
BeMCInstForm_XMM64_RM64,
BeMCInstForm_XMM128_RM128,
BeMCInstForm_R32_F32,
BeMCInstForm_R64_F32,
BeMCInstForm_R32_F64,
@ -1209,6 +1213,9 @@ enum BeMCNativeTypeCode
BeMCNativeTypeCode_Int64,
BeMCNativeTypeCode_Float,
BeMCNativeTypeCode_Double,
BeMCNativeTypeCode_M128,
BeMCNativeTypeCode_M256,
BeMCNativeTypeCode_M512,
BeMCNativeTypeCode_COUNT
};
@ -1347,6 +1354,7 @@ public:
void Print();
BeMCOperand GetOperand(BeValue* value, bool allowMetaResult = false, bool allowFail = false); // Meta results are PHIs or CmpResults
BeMCOperand CreateNot(const BeMCOperand& operand);
BeMCOperand TryToVector(BeValue* value);
BeType* GetType(const BeMCOperand& operand);
bool AreTypesEquivalent(BeType* type0, BeType* type1);
void AddRelRefs(BeMCOperand& operand, int refCount);
@ -1413,10 +1421,12 @@ public:
bool IsVolatileReg(X64CPURegister reg);
bool IsXMMReg(X64CPURegister reg);
X64CPURegister ResizeRegister(X64CPURegister reg, int numBits);
X64CPURegister ResizeRegister(X64CPURegister reg, BeType* type);
X64CPURegister GetFullRegister(X64CPURegister reg);
bool IsAddress(BeMCOperand& operand);
bool IsAddressable(BeMCOperand& operand);
bool IsVRegExpr(BeMCOperand& operand);
void FixOperand(BeMCOperand& operand);
void FixOperand(BeMCOperand& operand, int depth = 0);
BeMCOperand GetFixedOperand(const BeMCOperand& operand);
uint8 GetREX(const BeMCOperand& op0, const BeMCOperand& op1, bool is64Bit);
void EmitREX(const BeMCOperand& op0, const BeMCOperand& op1, bool is64Bit);

37
IDEHelper/Backend/BeModule.cpp
View file

@ -507,6 +507,12 @@ BeType* BeGEPConstant::GetType()
BF_ASSERT(arrayType->mTypeCode == BeTypeCode_SizedArray);
return arrayType->mContext->GetPointerTo(arrayType->mElementType);
}
else if (ptrType->mElementType->mTypeCode == BeTypeCode_Vector)
{
BeVectorType* arrayType = (BeVectorType*)ptrType->mElementType;
BF_ASSERT(arrayType->mTypeCode == BeTypeCode_Vector);
return arrayType->mContext->GetPointerTo(arrayType->mElementType);
}
/*else if (ptrType->mElementType->IsPointer())
{
return ptrType->mElementType;
@ -528,6 +534,12 @@ BeType* BeExtractValueConstant::GetType()
BF_ASSERT(arrayType->mTypeCode == BeTypeCode_SizedArray);
return arrayType->mElementType;
}
else if (type->mTypeCode == BeTypeCode_Vector)
{
BeVectorType* arrayType = (BeVectorType*)type;
BF_ASSERT(arrayType->mTypeCode == BeTypeCode_Vector);
return arrayType->mElementType;
}
/*else if (ptrType->mElementType->IsPointer())
{
return ptrType->mElementType;
@ -655,6 +667,11 @@ BeType* BeExtractValueInst::GetType()
BeSizedArrayType* arrayType = (BeSizedArrayType*)aggType;
return arrayType->mElementType;
}
if (aggType->mTypeCode == BeTypeCode_Vector)
{
BeVectorType* arrayType = (BeVectorType*)aggType;
return arrayType->mElementType;
}
BF_ASSERT(aggType->mTypeCode == BeTypeCode_Struct);
BeStructType* structType = (BeStructType*)aggType;
return structType->mMembers[mIdx].mType;
@ -703,6 +720,11 @@ BeType* BeGEPInst::GetType()
BeSizedArrayType* arrayType = (BeSizedArrayType*)ptrType->mElementType;
return GetContext()->GetPointerTo(arrayType->mElementType);
}
else if (elementType->IsVector())
{
BeVectorType* arrayType = (BeVectorType*)ptrType->mElementType;
return GetContext()->GetPointerTo(arrayType->mElementType);
}
else
{
BF_FATAL("Bad type");
@ -1308,7 +1330,8 @@ void BeDumpContext::ToString(StringImpl& str, BeValue* value, bool showType, boo
switch (constant->mType->mTypeCode)
{
case BeTypeCode_Struct:
case BeTypeCode_SizedArray:
case BeTypeCode_SizedArray:
case BeTypeCode_Vector:
for (int valIdx = 0; valIdx < (int)constant->mMemberValues.size(); valIdx++)
{
if (valIdx > 0)
@ -1412,7 +1435,8 @@ void BeDumpContext::ToString(StringImpl& str, BeValue* value, bool showType, boo
return;
}
case BeTypeCode_Struct:
case BeTypeCode_SizedArray:
case BeTypeCode_SizedArray:
case BeTypeCode_Vector:
str += "zeroinitializer";
return;
case BeTypeCode_Function:
@ -3033,6 +3057,15 @@ void BeModule::ToString(StringImpl& str, BeType* type)
str += "]";
return;
}
case BeTypeCode_Vector:
{
auto arrayType = (BeSizedArrayType*)type;
ToString(str, arrayType->mElementType);
str += "<";
str += StrFormat("%d", arrayType->mLength);
str += ">";
return;
}
}
str += "<UnknownType>";
}