diff --git a/Debugger32/Debugger32.vcxproj b/Debugger32/Debugger32.vcxproj index a01b983e..b69779d5 100644 --- a/Debugger32/Debugger32.vcxproj +++ b/Debugger32/Debugger32.vcxproj @@ -133,6 +133,7 @@ ../;../IDEHelper;../BeefySysLib/platform/win;../BeefySysLib/third_party;C:\llvm-3.8\llvm\include;C:\llvm-3.8\bin64\include;C:\llvm-3.8\llvm\lib\Target;C:\llvm-3.8\bin64\lib\Target\X86;C:\llvm-3.8\llvm\tools\clang\include false true + stdcpp17 Windows @@ -146,12 +147,13 @@ Level3 Disabled BF_DBG_32;WIN32;_DEBUG;_WINDOWS;_USRDLL;IDEHELPER_EXPORTS;BFSYSLIB_DYNAMIC;%(PreprocessorDefinitions) - ../;../IDEHelper;../BeefySysLib/platform/win;../BeefySysLib/third_party;..\extern\llvm-project_13_0_1\llvm\include;..\extern\llvm_win64_13_0_1\include;..\extern\llvm-project_13_0_1\llvm\lib\Target;..\extern\llvm_win64_13_0_1\lib\Target\X86;..\extern\llvm-project_13_0_1\llvm\tools\clang\include + ../;../IDEHelper;../BeefySysLib/platform/win;../BeefySysLib/third_party;..\extern\llvm-project_18_1_4\llvm\include;..\extern\llvm_win64_18_1_4\include;..\extern\llvm-project_18_1_4\llvm\lib\Target;..\extern\llvm_win64_18_1_4\lib\Target\X86;..\extern\llvm-project_18_1_4\llvm\tools\clang\include false -D_SCL_SECURE_NO_WARNINGS %(AdditionalOptions) false MultiThreadedDebug true + stdcpp17 Windows @@ -169,6 +171,7 @@ BF_DBG_32;WIN32;NDEBUG;_WINDOWS;_USRDLL;IDEHELPER_EXPORTS;BFSYSLIB_DYNAMIC;%(PreprocessorDefinitions) ../;../IDEHelper;../BeefySysLib/platform/win;../BeefySysLib/third_party;C:\llvm-3.8\llvm\include;C:\llvm-3.8\bin64\include;C:\llvm-3.8\llvm\lib\Target;C:\llvm-3.8\bin64\lib\Target\X86;C:\llvm-3.8\llvm\tools\clang\include true + stdcpp17 Windows @@ -186,10 +189,11 @@ true true BF_DBG_32;WIN32;NDEBUG;_WINDOWS;_USRDLL;IDEHELPER_EXPORTS;BFSYSLIB_DYNAMIC;%(PreprocessorDefinitions) - ../;../IDEHelper;../BeefySysLib/platform/win;../BeefySysLib/third_party;..\extern\llvm-project_13_0_1\llvm\include;..\extern\llvm_win64_13_0_1\include;..\extern\llvm-project_13_0_1\llvm\lib\Target;..\extern\llvm_win64_13_0_1\lib\Target\X86;..\extern\llvm-project_13_0_1\llvm\tools\clang\include + ../;../IDEHelper;../BeefySysLib/platform/win;../BeefySysLib/third_party;..\extern\llvm-project_18_1_4\llvm\include;..\extern\llvm_win64_18_1_4\include;..\extern\llvm-project_18_1_4\llvm\lib\Target;..\extern\llvm_win64_18_1_4\lib\Target\X86;..\extern\llvm-project_18_1_4\llvm\tools\clang\include MultiThreaded false true + stdcpp17 Windows diff --git a/Debugger64/Debugger64.vcxproj b/Debugger64/Debugger64.vcxproj index 48fe6bff..93d39f2b 100644 --- a/Debugger64/Debugger64.vcxproj +++ b/Debugger64/Debugger64.vcxproj @@ -133,6 +133,7 @@ ../;../IDEHelper;../BeefySysLib/platform/win;../BeefySysLib/third_party;C:\llvm-3.8\llvm\include;C:\llvm-3.8\bin64\include;C:\llvm-3.8\llvm\lib\Target;C:\llvm-3.8\bin64\lib\Target\X86;C:\llvm-3.8\llvm\tools\clang\include false true + stdcpp17 Windows @@ -146,12 +147,13 @@ Level3 Disabled BF_DBG_64;WIN32;_DEBUG;_WINDOWS;_USRDLL;IDEHELPER_EXPORTS;BFSYSLIB_DYNAMIC;%(PreprocessorDefinitions) - ../;../IDEHelper;../BeefySysLib/platform/win;../BeefySysLib/third_party;..\extern\llvm-project_13_0_1\llvm\include;..\extern\llvm_win64_13_0_1\include;..\extern\llvm-project_13_0_1\llvm\lib\Target;..\extern\llvm_win64_13_0_1\lib\Target\X86;..\extern\llvm-project_13_0_1\llvm\tools\clang\include + ../;../IDEHelper;../BeefySysLib/platform/win;../BeefySysLib/third_party;..\extern\llvm-project_18_1_4\llvm\include;..\extern\llvm_win64_18_1_4\include;..\extern\llvm-project_18_1_4\llvm\lib\Target;..\extern\llvm_win64_18_1_4\lib\Target\X86;..\extern\llvm-project_18_1_4\llvm\tools\clang\include false -D_SCL_SECURE_NO_WARNINGS %(AdditionalOptions) false MultiThreadedDebug true + stdcpp17 Windows @@ -169,6 +171,7 @@ BF_DBG_64;WIN32;NDEBUG;_WINDOWS;_USRDLL;IDEHELPER_EXPORTS;BFSYSLIB_DYNAMIC;%(PreprocessorDefinitions) ../;../IDEHelper;../BeefySysLib/platform/win;../BeefySysLib/third_party;C:\llvm-3.8\llvm\include;C:\llvm-3.8\bin64\include;C:\llvm-3.8\llvm\lib\Target;C:\llvm-3.8\bin64\lib\Target\X86;C:\llvm-3.8\llvm\tools\clang\include true + stdcpp17 Windows @@ -186,10 +189,11 @@ true true BF_DBG_64;WIN32;NDEBUG;_WINDOWS;_USRDLL;IDEHELPER_EXPORTS;BFSYSLIB_DYNAMIC;%(PreprocessorDefinitions) - ../;../IDEHelper;../BeefySysLib/platform/win;../BeefySysLib/third_party;..\extern\llvm-project_13_0_1\llvm\include;..\extern\llvm_win64_13_0_1\include;..\extern\llvm-project_13_0_1\llvm\lib\Target;..\extern\llvm_win64_13_0_1\lib\Target\X86;..\extern\llvm-project_13_0_1\llvm\tools\clang\include + ../;../IDEHelper;../BeefySysLib/platform/win;../BeefySysLib/third_party;..\extern\llvm-project_18_1_4\llvm\include;..\extern\llvm_win64_18_1_4\include;..\extern\llvm-project_18_1_4\llvm\lib\Target;..\extern\llvm_win64_18_1_4\lib\Target\X86;..\extern\llvm-project_18_1_4\llvm\tools\clang\include MultiThreaded false true + stdcpp17 Windows diff --git a/IDEHelper/Backend/BeCOFFObject.cpp b/IDEHelper/Backend/BeCOFFObject.cpp index 6a7a8354..3daef63b 100644 --- a/IDEHelper/Backend/BeCOFFObject.cpp +++ b/IDEHelper/Backend/BeCOFFObject.cpp @@ -5,6 +5,7 @@ #include "BeefySysLib/MemStream.h" #include "codeview/cvinfo.h" #include "BeefySysLib/util/BeefPerf.h" +#include "llvm/IR/DIBuilder.h" #include "BeefySysLib/util/AllocDebug.h" diff --git a/IDEHelper/Backend/BeIRCodeGen.cpp b/IDEHelper/Backend/BeIRCodeGen.cpp index ee44dc6c..d01b31ca 100644 --- a/IDEHelper/Backend/BeIRCodeGen.cpp +++ b/IDEHelper/Backend/BeIRCodeGen.cpp @@ -2,6 +2,7 @@ #include "../Compiler/BfIRCodeGen.h" #include "BeDbgModule.h" #include "BeefySysLib/util/BeefPerf.h" +#include "llvm/IR/DIBuilder.h" #include "BeefySysLib/util/AllocDebug.h" #include "BeefySysLib/util/Hash.h" diff --git a/IDEHelper/Backend/BeModule.cpp b/IDEHelper/Backend/BeModule.cpp index 5f282786..0746845d 100644 --- a/IDEHelper/Backend/BeModule.cpp +++ b/IDEHelper/Backend/BeModule.cpp @@ -4,6 +4,7 @@ #include "BeefySysLib/util/BeefPerf.h" #include "BeefySysLib/util/StackHelper.h" #include "../Compiler/BfIRCodeGen.h" +#include "llvm/IR/DIBuilder.h" #include "BeefySysLib/util/AllocDebug.h" diff --git a/IDEHelper/Clang/CDepChecker.h b/IDEHelper/Clang/CDepChecker.h index fb45f1dd..1b53aa7d 100644 --- a/IDEHelper/Clang/CDepChecker.h +++ b/IDEHelper/Clang/CDepChecker.h @@ -3,6 +3,7 @@ #include "../Compiler/BfSystem.h" #include "../Compiler/BfParser.h" #include "../Compiler/BfReducer.h" +#include NS_BF_BEGIN diff --git a/IDEHelper/Compiler/BfCompiler.cpp b/IDEHelper/Compiler/BfCompiler.cpp index f15c605c..7bb4e946 100644 --- a/IDEHelper/Compiler/BfCompiler.cpp +++ b/IDEHelper/Compiler/BfCompiler.cpp @@ -11,6 +11,13 @@ #include "BeefySysLib/util/AllocDebug.h" #include "llvm/Support/Compiler.h" +#include "llvm/Support/Compiler.h" +#include "llvm/IR/IRBuilder.h" +#include "llvm/IR/Type.h" +#include "llvm/IR/DIBuilder.h" +#include "llvm/IR/DebugInfo.h" +#include "llvm/IR/Argument.h" +#include "llvm/IR/Constants.h" #include "BfCompiler.h" #include "BfSystem.h" @@ -55,11 +62,11 @@ void pt(llvm::Type* t) os << " isSized: " << t->isSized() << "\n"; os.flush(); - if (auto pointerType = llvm::dyn_cast(t)) - { - Beefy::OutputDebugStrF("Element: "); - pt(pointerType->getElementType()); - } +// if (auto pointerType = llvm::dyn_cast(t)) +// { +// Beefy::OutputDebugStrF("Element: "); +// pt(pointerType->getElementType()); +// } } void ppt(llvm::Type* t) @@ -70,7 +77,7 @@ void ppt(llvm::Type* t) Beefy::OutputDebugStrF("Not a pointer type"); return; } - pt(pointerType->getElementType()); + //pt(pointerType->getElementType()); } void pt(llvm::DINode* t) diff --git a/IDEHelper/Compiler/BfCompiler.h b/IDEHelper/Compiler/BfCompiler.h index ff45f079..2cdc6f1e 100644 --- a/IDEHelper/Compiler/BfCompiler.h +++ b/IDEHelper/Compiler/BfCompiler.h @@ -15,13 +15,13 @@ #include "BeefySysLib/util/String.h" #include "BfAst.h" #include "BfSystem.h" -#include "llvm/Support/Compiler.h" +/*#include "llvm/Support/Compiler.h" #include "llvm/IR/IRBuilder.h" #include "llvm/IR/Type.h" #include "llvm/IR/DIBuilder.h" #include "llvm/IR/DebugInfo.h" #include "llvm/IR/Argument.h" -#include "llvm/IR/Constants.h" +#include "llvm/IR/Constants.h"*/ #include "BfResolvedTypeUtils.h" #include #include "BfContext.h" diff --git a/IDEHelper/Compiler/BfIRBuilder.cpp b/IDEHelper/Compiler/BfIRBuilder.cpp index 080c7d81..c6f4e350 100644 --- a/IDEHelper/Compiler/BfIRBuilder.cpp +++ b/IDEHelper/Compiler/BfIRBuilder.cpp @@ -29,6 +29,7 @@ #include "llvm/ADT/ArrayRef.h" #include "llvm/IR/InlineAsm.h" #include "llvm/Support/FileSystem.h" +#include "llvm/IR/DIBuilder.h" #pragma warning(pop) @@ -1894,11 +1895,11 @@ String BfIRBuilder::ToString(BfIRType irType) { auto& typeEntry = mBfIRCodeGen->GetTypeEntry(irType.mId); if (irType.mKind == BfIRType::TypeKind::TypeKind_TypeId) - llvmType = typeEntry.mLLVMType; + llvmType = typeEntry.mType->mLLVMType; else if (irType.mKind == BfIRType::TypeKind::TypeKind_TypeInstId) - llvmType = typeEntry.mInstLLVMType; + llvmType = typeEntry.mInstType->mLLVMType; else if (irType.mKind == BfIRType::TypeKind::TypeKind_TypeInstPtrId) - llvmType = typeEntry.mInstLLVMType->getPointerTo(); + llvmType = typeEntry.mInstType->mLLVMType->getPointerTo(); } if (llvmType == NULL) @@ -1910,7 +1911,7 @@ String BfIRBuilder::ToString(BfIRType irType) if (auto pointerType = llvm::dyn_cast(llvmType)) { strStream << "\n ElementType: "; - pointerType->getElementType()->print(strStream); + //pointerType->getElementType()->print(strStream); } strStream.flush(); return outStr; diff --git a/IDEHelper/Compiler/BfIRCodeGen.cpp b/IDEHelper/Compiler/BfIRCodeGen.cpp index 7515c422..57e8873c 100644 --- a/IDEHelper/Compiler/BfIRCodeGen.cpp +++ b/IDEHelper/Compiler/BfIRCodeGen.cpp @@ -25,10 +25,11 @@ #include "llvm/IR/InlineAsm.h" #include "llvm/IR/Attributes.h" #include "llvm/Support/FileSystem.h" +#include "llvm/TargetParser/Host.h" //#include "llvm/Support/Dwarf.h" #include "llvm/IR/DIBuilder.h" -#include "llvm/ADT/Triple.h" +//#include "llvm/ADT/Triple.h" //#include "llvm/CodeGen/CommandFlags.h" #include "llvm/CodeGen/LinkAllAsmWriterComponents.h" #include "llvm/CodeGen/LinkAllCodegenComponents.h" @@ -37,10 +38,10 @@ #include "llvm/IR/LLVMContext.h" #include "llvm/IR/Module.h" #include "llvm/IRReader/IRReader.h" -#include "llvm/MC/SubtargetFeature.h" +//#include "llvm/MC/SubtargetFeature.h" #include "llvm/MC/MCObjectWriter.h" #include "llvm/Pass.h" -#include "llvm/Transforms/IPO/PassManagerBuilder.h" +//#include "llvm/Transforms/IPO/PassManagerBuilder.h" #include "llvm/Transforms/Utils.h" #include "llvm/Transforms/Scalar/InstSimplifyPass.h" #include "llvm/IR/LegacyPassManager.h" @@ -48,20 +49,21 @@ #include "llvm/Support/Debug.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/FormattedStream.h" -#include "llvm/Support/Host.h" +//#include "llvm/Support/Host.h" #include "llvm/Support/ManagedStatic.h" +#include "llvm/Support/CodeGen.h" #include "llvm/Support/PluginLoader.h" #include "llvm/Support/PrettyStackTrace.h" #include "llvm/Support/Signals.h" #include "llvm/Support/SourceMgr.h" -#include "llvm/Support/TargetRegistry.h" +//#include "llvm/Support/TargetRegistry.h" #include "llvm/Support/TargetSelect.h" #include "llvm/Support/ToolOutputFile.h" //#include "llvm/Target/TargetLibraryInfo.h" #include "llvm/Target/TargetMachine.h" //#include "llvm/Target/TargetSubtargetInfo.h" -#include "llvm/Transforms/IPO/PassManagerBuilder.h" -#include "llvm-c/Transforms/PassManagerBuilder.h" +//#include "llvm/Transforms/IPO/PassManagerBuilder.h" +//#include "llvm-c/Transforms/PassManagerBuilder.h" #include "llvm/ADT/SmallVector.h" #include "llvm/Analysis/Passes.h" #include "llvm/IR/DataLayout.h" @@ -71,8 +73,8 @@ #include "llvm/Support/ManagedStatic.h" #include "llvm/Analysis/BasicAliasAnalysis.h" //#include "llvm/Analysis/CFLAliasAnalysis.h" -#include "llvm/Analysis/CFLAndersAliasAnalysis.h" -#include "llvm/Analysis/CFLSteensAliasAnalysis.h" +//#include "llvm/Analysis/CFLAndersAliasAnalysis.h" +//#include "llvm/Analysis/CFLSteensAliasAnalysis.h" #include "llvm/Analysis/GlobalsModRef.h" #include "llvm/Analysis/ScopedNoAliasAA.h" #include "llvm/Analysis/TargetLibraryInfo.h" @@ -86,7 +88,7 @@ #include "llvm/Transforms/Instrumentation.h" #include "llvm/Transforms/Scalar.h" #include "llvm/Transforms/Scalar/GVN.h" -#include "llvm/Transforms/Vectorize.h" +//#include "llvm/Transforms/Vectorize.h" #include "llvm/Transforms/AggressiveInstCombine/AggressiveInstCombine.h" #include "llvm/Transforms/InstCombine/InstCombine.h" #include "llvm/Transforms/Scalar/SimpleLoopUnswitch.h" @@ -96,14 +98,14 @@ #include "llvm/Analysis/Passes.h" #include "llvm/Transforms/IPO.h" #include "llvm/Transforms/Scalar.h" -#include "llvm/Transforms/Vectorize.h" +//#include "llvm/Transforms/Vectorize.h" #include "llvm/Pass.h" #include "llvm/CodeGen/MachineFunctionPass.h" #include "llvm/Support/raw_ostream.h" #include "llvm/MC/MCAsmBackend.h" #include "llvm/MC/MCCodeEmitter.h" -#include "llvm/Support/TargetRegistry.h" +#include "llvm/MC/TargetRegistry.h" #include "llvm/LTO/LTOBackend.h" #include "llvm/Bitcode/BitcodeWriter.h" @@ -117,6 +119,8 @@ #pragma warning(pop) +void pm(llvm::Module* module); + USING_NS_BF; #pragma warning(disable:4146) @@ -339,7 +343,7 @@ static void AddStdErrCrashInfo() /// BfIRCodeGen::BfIRCodeGen() -{ +{ mStream = NULL; mBfIRBuilder = NULL; mLLVMTargetMachine = NULL; @@ -353,6 +357,7 @@ BfIRCodeGen::BfIRCodeGen() mDIBuilder = NULL; mDICompileUnit = NULL; mActiveFunction = NULL; + mActiveFunctionType = NULL; mLLVMContext = new llvm::LLVMContext(); mLLVMModule = NULL; @@ -360,6 +365,7 @@ BfIRCodeGen::BfIRCodeGen() mHadDLLExport = false; mConstValIdx = 0; mCmdCount = 0; + mCurLine = -1; #ifdef BF_PLATFORM_WINDOWS if (::GetStdHandle(STD_ERROR_HANDLE) == 0) @@ -377,6 +383,9 @@ BfIRCodeGen::~BfIRCodeGen() { mDebugLoc = llvm::DebugLoc(); mSavedDebugLocs.Clear(); + + for (auto typeEx : mIRTypeExs) + delete typeEx; delete mStream; delete mIRBuilder; @@ -466,6 +475,40 @@ void BfIRCodeGen::PrintFunction() os.flush(); } +void pte(BfIRTypeEx* typeEx, int indent) +{ + Beefy::debug_ostream os; + typeEx->mLLVMType->print(os); + os << "\n"; + os.flush(); + + for (int i = 0; i < typeEx->mMembers.mSize; i++) + { + for (int i = 0; i < indent; i++) + os << " "; + os << i << ". "; + os.flush(); + pte(typeEx->mMembers[i], indent + 1); + } +} + +void pte(BfIRTypeEx* typeEx) +{ + if (typeEx == NULL) + return; + pte(typeEx, 0); +} + +void pve(const BfIRTypedValue& typedValue) +{ + Beefy::debug_ostream os; + os << "Value: "; + typedValue.mValue->print(os); + os << "\nType: "; + os.flush(); + pte(typedValue.mTypeEx); +} + void BfIRCodeGen::FixValues(llvm::StructType* structType, llvm::SmallVector& values) { if (values.size() >= structType->getNumElements()) @@ -542,7 +585,7 @@ llvm::Type* BfIRCodeGen::GetLLVMType(BfTypeCode typeCode, bool& isSigned) case BfTypeCode_None: return llvm::Type::getVoidTy(*mLLVMContext); case BfTypeCode_NullPtr: - return llvm::Type::getInt8PtrTy(*mLLVMContext); + return llvm::PointerType::get(*mLLVMContext, 0); case BfTypeCode_Boolean: return llvm::Type::getInt1Ty(*mLLVMContext); case BfTypeCode_Int8: @@ -635,6 +678,100 @@ llvm::Type* BfIRCodeGen::GetLLVMType(BfTypeCode typeCode, bool& isSigned) return NULL; } +BfIRTypeEx* BfIRCodeGen::GetTypeEx(BfTypeCode typeCode, bool& isSigned) +{ + BfIRTypeEx** valuePtr = NULL; + if (mTypeCodeTypeExMap.TryAdd(typeCode, NULL, &valuePtr)) + { + BfIRTypeEx* typeEx = new BfIRTypeEx(); + typeEx->mLLVMType = GetLLVMType(typeCode, isSigned); + + if (typeEx->mLLVMType->isPointerTy()) + { + // Make void* actually be an i8* + typeEx->mMembers.Add(GetTypeEx(llvm::Type::getInt8Ty(*mLLVMContext))); + } + + if (auto arrType = llvm::dyn_cast(typeEx->mLLVMType)) + { + typeEx->mMembers.Add(GetTypeEx(arrType->getElementType())); + } + + if (auto vectorType = llvm::dyn_cast(typeEx->mLLVMType)) + { + typeEx->mMembers.Add(GetTypeEx(vectorType->getElementType())); + } + + *valuePtr = typeEx; + } + else + { + isSigned = false; + switch (typeCode) + { + case BfTypeCode_Int8: + case BfTypeCode_Int16: + case BfTypeCode_Int24: + case BfTypeCode_Int32: + case BfTypeCode_Int40: + case BfTypeCode_Int48: + case BfTypeCode_Int56: + case BfTypeCode_Int64: + case BfTypeCode_Int128: + isSigned = true; + } + } + return *valuePtr; +} + +BfIRTypeEx* BfIRCodeGen::GetTypeEx(llvm::Type* llvmType) +{ + BfIRTypeEx** valuePtr = NULL; + if (mLLVMTypeExMap.TryAdd(llvmType, NULL, &valuePtr)) + { + BfIRTypeEx* typeEx = new BfIRTypeEx(); + mIRTypeExs.Add(typeEx); + typeEx->mLLVMType = llvmType; + *valuePtr = typeEx; + } + return *valuePtr; +} + +BfIRTypeEx* BfIRCodeGen::CreateTypeEx(llvm::Type* llvmType) +{ + BfIRTypeEx* typeEx = new BfIRTypeEx(); + mIRTypeExs.Add(typeEx); + typeEx->mLLVMType = llvmType; + return typeEx; +} + +BfIRTypeEx* BfIRCodeGen::GetPointerTypeEx(BfIRTypeEx* elementType) +{ + BF_ASSERT(elementType != NULL); + BfIRTypeEx** valuePtr = NULL; + if (mPointerTypeExMap.TryAdd(elementType, NULL, &valuePtr)) + { + BfIRTypeEx* typeEx = new BfIRTypeEx(); + mIRTypeExs.Add(typeEx); + typeEx->mLLVMType = llvm::PointerType::get(*mLLVMContext, 0); + typeEx->mMembers.Add(elementType); + *valuePtr = typeEx; + } + return *valuePtr; +} + +BfIRTypeEx* BfIRCodeGen::GetTypeMember(BfIRTypeEx* typeEx, int idx) +{ + if ((idx < 0) || (idx >= typeEx->mMembers.mSize)) + { + Fail("BfIRTypeEx GetTypeMember OOB"); + + bool isSigned; + return GetTypeEx(BfTypeCode_Int8, isSigned); + } + return typeEx->mMembers[idx]; +} + BfIRTypeEntry& BfIRCodeGen::GetTypeEntry(int typeId) { BfIRTypeEntry& typeEntry = mTypes[typeId]; @@ -643,7 +780,7 @@ BfIRTypeEntry& BfIRCodeGen::GetTypeEntry(int typeId) return typeEntry; } -BfIRTypeEntry* BfIRCodeGen::GetTypeEntry(llvm::Type* type) +BfIRTypeEntry* BfIRCodeGen::GetTypeEntry(BfIRTypeEx* type) { int typeId = 0; if (!mTypeToTypeIdMap.TryGetValue(type, &typeId)) @@ -652,13 +789,24 @@ BfIRTypeEntry* BfIRCodeGen::GetTypeEntry(llvm::Type* type) } void BfIRCodeGen::SetResult(int id, llvm::Value* value) -{ +{ + BF_ASSERT(!value->getType()->isAggregateType()); + BF_ASSERT(!value->getType()->isPointerTy()); + BfIRCodeGenEntry entry; entry.mKind = BfIRCodeGenEntryKind_LLVMValue; entry.mLLVMValue = value; mResults.TryAdd(id, entry); } +void BfIRCodeGen::SetResult(int id, const BfIRTypedValue& value) +{ + BfIRCodeGenEntry entry; + entry.mKind = BfIRCodeGenEntryKind_TypedValue; + entry.mTypedValue = value; + mResults.TryAdd(id, entry); +} + void BfIRCodeGen::SetResultAligned(int id, llvm::Value* value) { BfIRCodeGenEntry entry; @@ -667,6 +815,14 @@ void BfIRCodeGen::SetResultAligned(int id, llvm::Value* value) mResults.TryAdd(id, entry); } +void BfIRCodeGen::SetResultAligned(int id, const BfIRTypedValue& value) +{ + BfIRCodeGenEntry entry; + entry.mKind = BfIRCodeGenEntryKind_TypedValue_Aligned; + entry.mTypedValue = value; + mResults.TryAdd(id, entry); +} + void BfIRCodeGen::SetResult(int id, llvm::Type* type) { BfIRCodeGenEntry entry; @@ -675,7 +831,15 @@ void BfIRCodeGen::SetResult(int id, llvm::Type* type) mResults.TryAdd(id, entry); } -void BfIRCodeGen::SetResult(int id, llvm::BasicBlock * value) +void BfIRCodeGen::SetResult(int id, BfIRTypeEx* typeEx) +{ + BfIRCodeGenEntry entry; + entry.mKind = BfIRCodeGenEntryKind_TypeEx; + entry.mTypeEx = typeEx; + mResults.TryAdd(id, entry); +} + +void BfIRCodeGen::SetResult(int id, llvm::BasicBlock* value) { BfIRCodeGenEntry entry; entry.mKind = BfIRCodeGenEntryKind_LLVMBasicBlock; @@ -781,71 +945,123 @@ void BfIRCodeGen::Read(BfIRTypeEntry*& type) type = &GetTypeEntry(typeId); } -void BfIRCodeGen::Read(llvm::Type*& llvmType, BfIRTypeEntry** outTypeEntry) +void BfIRCodeGen::Read(BfIRTypeEx*& typeEx, BfIRTypeEntry** outTypeEntry) { + typeEx = NULL; + BfIRType::TypeKind typeKind = (BfIRType::TypeKind)mStream->Read(); if (typeKind == BfIRType::TypeKind::TypeKind_None) - { - llvmType = NULL; - return; - } + return; if (typeKind == BfIRType::TypeKind::TypeKind_Stream) { int streamId = (int)ReadSLEB128(); if (streamId == -1) - { - llvmType = NULL; + { + typeEx = NULL; return; } - auto& result = mResults[streamId]; - BF_ASSERT(result.mKind == BfIRCodeGenEntryKind_LLVMType); - llvmType = result.mLLVMType; + auto& result = mResults[streamId]; + BF_ASSERT(result.mKind == BfIRCodeGenEntryKind_TypeEx); + typeEx = result.mTypeEx; return; } if (typeKind == BfIRType::TypeKind::TypeKind_SizedArray) { - CMD_PARAM(llvm::Type*, elementType); + CMD_PARAM(BfIRTypeEx*, elementType); CMD_PARAM(int, length); - llvmType = llvm::ArrayType::get(elementType, length); + typeEx = new BfIRTypeEx(); + typeEx->mLLVMType = llvm::ArrayType::get(elementType->mLLVMType, length); + BF_ASSERT(elementType != NULL); + typeEx->mMembers.Add(elementType); + mIRTypeExs.Add(typeEx); return; } int typeId = (int)ReadSLEB128(); if (typeKind == BfIRType::TypeKind::TypeKind_TypeCode) - { + { bool isSigned = false; - llvmType = GetLLVMType((BfTypeCode)typeId, isSigned); + typeEx = GetTypeEx((BfTypeCode)typeId, isSigned); return; } auto& typeEntry = GetTypeEntry(typeId); if (typeKind == BfIRType::TypeKind::TypeKind_TypeId) - llvmType = typeEntry.mLLVMType; + typeEx = typeEntry.mType; else if (typeKind == BfIRType::TypeKind::TypeKind_TypeInstId) - llvmType = typeEntry.mInstLLVMType; + typeEx = typeEntry.mInstType; else if (typeKind == BfIRType::TypeKind::TypeKind_TypeInstPtrId) - llvmType = typeEntry.mInstLLVMType->getPointerTo(); + typeEx = GetPointerTypeEx(typeEntry.mInstType); if (outTypeEntry != NULL) *outTypeEntry = &typeEntry; } +void BfIRCodeGen::Read(llvm::Type*& llvmType, BfIRTypeEntry** outTypeEntry) +{ + BfIRTypeEx* typeEx = NULL; + Read(typeEx, outTypeEntry); + if (typeEx != NULL) + { + llvmType = typeEx->mLLVMType; + } + else + llvmType = NULL; +} + void BfIRCodeGen::Read(llvm::FunctionType*& llvmType) { int streamId = (int)ReadSLEB128(); auto& result = mResults[streamId]; + + if (result.mKind == BfIRCodeGenEntryKind_TypeEx) + { + llvmType = (llvm::FunctionType*)result.mTypeEx->mLLVMType; + return; + } + BF_ASSERT(result.mKind == BfIRCodeGenEntryKind_LLVMType); llvmType = (llvm::FunctionType*)result.mLLVMType; } -void BfIRCodeGen::Read(llvm::Value*& llvmValue, BfIRCodeGenEntry** codeGenEntry, BfIRSizeAlignKind sizeAlignKind) +void BfIRCodeGen::ReadFunctionType(BfIRTypeEx*& typeEx) { + int streamId = (int)ReadSLEB128(); + auto& result = mResults[streamId]; + + if (result.mKind == BfIRCodeGenEntryKind_TypeEx) + { + typeEx = result.mTypeEx; + return; + } + + BF_FATAL("Invalid path in ReadFunctionType"); + + BF_ASSERT(result.mKind == BfIRCodeGenEntryKind_LLVMType); + typeEx = GetTypeEx(result.mLLVMType); +} + +void BfIRCodeGen::FixTypedValue(BfIRTypedValue& typedValue) +{ + if ((typedValue.mValue != NULL) && (typedValue.mTypeEx == NULL)) + { + typedValue.mTypeEx = GetTypeEx(typedValue.mValue->getType()); + BF_ASSERT(!typedValue.mValue->getType()->isStructTy()); + BF_ASSERT(!typedValue.mValue->getType()->isFunctionTy()); + } +} + +void BfIRCodeGen::Read(BfIRTypedValue& typedValue, BfIRCodeGenEntry** codeGenEntry, BfIRSizeAlignKind sizeAlignKind) +{ + typedValue.mValue = NULL; + typedValue.mTypeEx = NULL; + BfIRParamType paramType = (BfIRParamType)mStream->Read(); if (paramType == BfIRParamType_None) { - llvmValue = NULL; + // } else if (paramType == BfIRParamType_Const) { @@ -858,7 +1074,7 @@ void BfIRCodeGen::Read(llvm::Value*& llvmValue, BfIRCodeGenEntry** codeGenEntry, { int streamId = mCmdCount++; - CMD_PARAM(llvm::Type*, varType); + CMD_PARAM(BfIRTypeEx*, varType); CMD_PARAM(bool, isConstant); BfIRLinkageType linkageType = (BfIRLinkageType)mStream->Read(); CMD_PARAM(llvm::Constant*, initializer); @@ -873,19 +1089,20 @@ void BfIRCodeGen::Read(llvm::Value*& llvmValue, BfIRCodeGenEntry** codeGenEntry, { globalVariable = new llvm::GlobalVariable( *mLLVMModule, - varType, + varType->mLLVMType, isConstant, LLVMMapLinkageType(linkageType), initializer, name.c_str(), NULL, isTLS ? llvm::GlobalValue::GeneralDynamicTLSModel : llvm::GlobalValue::NotThreadLocal); } } - llvmValue = globalVariable; - - SetResult(streamId, globalVariable); + typedValue.mTypeEx = GetPointerTypeEx(varType); + typedValue.mValue = globalVariable; + SetResult(streamId, typedValue); } else - llvmValue = GetLLVMValue(streamId); + typedValue = GetTypedValue(streamId); + FixTypedValue(typedValue); return; } /*else if (constType == BfConstType_GlobalVar_TypeInst) @@ -923,47 +1140,66 @@ void BfIRCodeGen::Read(llvm::Value*& llvmValue, BfIRCodeGenEntry** codeGenEntry, else if ((constType == BfConstType_BitCast) || (constType == BfConstType_BitCastNull)) { CMD_PARAM(llvm::Constant*, target); - CMD_PARAM(llvm::Type*, toType); + CMD_PARAM(BfIRTypeEx*, toType); - if ((constType == BfConstType_BitCastNull) && (toType->isIntegerTy())) + typedValue.mTypeEx = toType; + if ((constType == BfConstType_BitCastNull) && (toType->mLLVMType->isIntegerTy())) { - llvmValue = llvm::ConstantInt::getNullValue(toType); + typedValue.mValue = llvm::ConstantInt::getNullValue(toType->mLLVMType); } else if (target->getType()->isIntegerTy()) - llvmValue = llvm::ConstantExpr::getIntToPtr(target, toType); + typedValue.mValue = llvm::ConstantExpr::getIntToPtr(target, toType->mLLVMType); else - llvmValue = llvm::ConstantExpr::getBitCast(target, toType); + typedValue.mValue = llvm::ConstantExpr::getBitCast(target, toType->mLLVMType); + FixTypedValue(typedValue); return; } else if (constType == BfConstType_GEP32_1) { - CMD_PARAM(llvm::Constant*, target); + CMD_PARAM(BfIRTypedValue, target); CMD_PARAM(int, idx0); llvm::Value* gepArgs[] = { llvm::ConstantInt::get(llvm::Type::getInt32Ty(*mLLVMContext), idx0)}; + + auto compositeType = GetTypeMember(target.mTypeEx, 0); + auto constant = llvm::dyn_cast(target.mValue); - llvmValue = FixGEP(target, llvm::ConstantExpr::getInBoundsGetElementPtr(target->getType()->getPointerElementType(), target, gepArgs)); + typedValue.mTypeEx = target.mTypeEx; + typedValue.mValue = llvm::ConstantExpr::getInBoundsGetElementPtr(compositeType->mLLVMType, constant, gepArgs); + FixTypedValue(typedValue); return; } else if (constType == BfConstType_GEP32_2) { - CMD_PARAM(llvm::Constant*, target); + CMD_PARAM(BfIRTypedValue, target); CMD_PARAM(int, idx0); CMD_PARAM(int, idx1); llvm::Value* gepArgs[] = { llvm::ConstantInt::get(llvm::Type::getInt32Ty(*mLLVMContext), idx0), llvm::ConstantInt::get(llvm::Type::getInt32Ty(*mLLVMContext), idx1)}; - llvmValue = FixGEP(target, llvm::ConstantExpr::getInBoundsGetElementPtr(target->getType()->getPointerElementType(), target, gepArgs)); + auto compositeType = GetTypeMember(target.mTypeEx, 0); + int elemIdx = BF_MIN(idx1, (int)compositeType->mMembers.mSize - 1); + auto elemType = GetTypeMember(compositeType, elemIdx); + + auto constant = llvm::dyn_cast(target.mValue); + typedValue.mValue = llvm::ConstantExpr::getInBoundsGetElementPtr(compositeType->mLLVMType, constant, gepArgs); + typedValue.mTypeEx = GetPointerTypeEx(elemType); return; } else if (constType == BfConstType_ExtractValue) { - CMD_PARAM(llvm::Constant*, target); - CMD_PARAM(int, idx0); - unsigned int gepArgs[] = { - (unsigned int)idx0 }; - llvmValue = FixGEP(target, llvm::ConstantExpr::getExtractValue(target, gepArgs)); + CMD_PARAM(BfIRTypedValue, target); + CMD_PARAM(int, idx0); + + auto compositeType = target.mTypeEx; + int elemIdx = BF_MIN(idx0, (int)compositeType->mMembers.mSize - 1); + auto elemType = GetTypeMember(compositeType, elemIdx); + + typedValue.mTypeEx = elemType; + if (auto constant = llvm::dyn_cast(target.mValue)) + typedValue.mValue = constant->getAggregateElement(llvm::ConstantInt::get(llvm::Type::getInt32Ty(*mLLVMContext), idx0)); + FixTypedValue(typedValue); return; } else if (constType == BfConstType_PtrToInt) @@ -972,44 +1208,53 @@ void BfIRCodeGen::Read(llvm::Value*& llvmValue, BfIRCodeGenEntry** codeGenEntry, BfTypeCode toTypeCode = (BfTypeCode)mStream->Read(); bool isSigned; - llvm::Type* llvmToType = GetLLVMType(toTypeCode, isSigned); - llvmValue = llvm::ConstantExpr::getPtrToInt(target, llvmToType); + BfIRTypeEx* toType = GetTypeEx(toTypeCode, isSigned); + typedValue.mTypeEx = toType; + typedValue.mValue = llvm::ConstantExpr::getPtrToInt(target, toType->mLLVMType); + FixTypedValue(typedValue); return; } else if (constType == BfConstType_IntToPtr) { CMD_PARAM(llvm::Constant*, target); - CMD_PARAM(llvm::Type*, toType); - llvmValue = llvm::ConstantExpr::getIntToPtr(target, toType); + CMD_PARAM(BfIRTypeEx*, toType); + typedValue.mTypeEx = toType; + typedValue.mValue = llvm::ConstantExpr::getIntToPtr(target, toType->mLLVMType); + FixTypedValue(typedValue); return; } else if (constType == BfConstType_AggZero) { BfIRTypeEntry* typeEntry = NULL; - llvm::Type* type = NULL; + BfIRTypeEx* type = NULL; Read(type, &typeEntry); + typedValue.mTypeEx = type; if ((sizeAlignKind == BfIRSizeAlignKind_Aligned) && (typeEntry != NULL)) - llvmValue = llvm::ConstantAggregateZero::get(GetSizeAlignedType(typeEntry)); + typedValue.mValue = llvm::ConstantAggregateZero::get(GetSizeAlignedType(typeEntry)->mLLVMType); else - llvmValue = llvm::ConstantAggregateZero::get(type); + typedValue.mValue = llvm::ConstantAggregateZero::get(type->mLLVMType); + FixTypedValue(typedValue); return; } else if (constType == BfConstType_ArrayZero8) { CMD_PARAM(int, count); auto arrType = llvm::ArrayType::get(llvm::Type::getInt8Ty(*mLLVMContext), count); - llvmValue = llvm::ConstantAggregateZero::get(arrType); + typedValue.mValue = llvm::ConstantAggregateZero::get(arrType); + FixTypedValue(typedValue); return; } else if (constType == BfConstType_Agg) { BfIRTypeEntry* typeEntry = NULL; - llvm::Type* type = NULL; + BfIRTypeEx* type = NULL; Read(type, &typeEntry); CmdParamVec values; - Read(values, type->isArrayTy() ? BfIRSizeAlignKind_Aligned : BfIRSizeAlignKind_Original); + Read(values, type->mLLVMType->isArrayTy() ? BfIRSizeAlignKind_Aligned : BfIRSizeAlignKind_Original); - if (auto arrayType = llvm::dyn_cast(type)) + typedValue.mTypeEx = type; + + if (auto arrayType = llvm::dyn_cast(type->mLLVMType)) { int fillCount = (int)(arrayType->getNumElements() - values.size()); if (fillCount > 0) @@ -1018,9 +1263,9 @@ void BfIRCodeGen::Read(llvm::Value*& llvmValue, BfIRCodeGenEntry** codeGenEntry, for (int i = 0; i < fillCount; i++) values.push_back(lastValue); } - llvmValue = llvm::ConstantArray::get(arrayType, values); + typedValue.mValue = llvm::ConstantArray::get(arrayType, values); } - else if (auto structType = llvm::dyn_cast(type)) + else if (auto structType = llvm::dyn_cast(type->mLLVMType)) { for (int i = 0; i < (int)values.size(); i++) { @@ -1039,45 +1284,51 @@ void BfIRCodeGen::Read(llvm::Value*& llvmValue, BfIRCodeGenEntry** codeGenEntry, if ((sizeAlignKind == BfIRSizeAlignKind_Aligned) && (typeEntry != NULL)) { - auto alignedType = llvm::dyn_cast(GetSizeAlignedType(typeEntry)); - if (type != alignedType) + auto alignedTypeEx = GetSizeAlignedType(typeEntry); + auto alignedType = llvm::dyn_cast(alignedTypeEx->mLLVMType); + if (type != alignedTypeEx) values.push_back(llvm::ConstantAggregateZero::get(alignedType->getElementType(alignedType->getNumElements() - 1))); - llvmValue = llvm::ConstantStruct::get(alignedType, values); + typedValue.mTypeEx = alignedTypeEx; + typedValue.mValue = llvm::ConstantStruct::get(alignedType, values); } else - llvmValue = llvm::ConstantStruct::get(structType, values); + { + typedValue.mValue = llvm::ConstantStruct::get(structType, values); + } } - else if (auto vecType = llvm::dyn_cast(type)) + else if (auto vecType = llvm::dyn_cast(type->mLLVMType)) { - llvmValue = llvm::ConstantVector::get(values); + typedValue.mValue = llvm::ConstantVector::get(values); } else { - llvmValue = NULL; + typedValue.mValue = NULL; Fail("Bad type"); } + FixTypedValue(typedValue); return; } else if (constType == BfConstType_Undef) { - CMD_PARAM(llvm::Type*, type); - llvmValue = llvm::UndefValue::get(type); + CMD_PARAM(BfIRTypeEx*, type); + typedValue.mTypeEx = type; + typedValue.mValue = llvm::UndefValue::get(type->mLLVMType); return; } else if (constType == BfConstType_TypeOf) { - CMD_PARAM(llvm::Type*, type); - llvmValue = mReflectDataMap[type]; - BF_ASSERT(llvmValue != NULL); + CMD_PARAM(BfIRTypeEx*, type); + typedValue = mReflectDataMap[type]; + BF_ASSERT(typedValue.mValue != NULL); return; } else if (constType == BfConstType_TypeOf_WithData) { - CMD_PARAM(llvm::Type*, type); - CMD_PARAM(llvm::Value*, value); + CMD_PARAM(BfIRTypeEx*, type); + CMD_PARAM(BfIRTypedValue, value); mReflectDataMap[type] = value; - llvmValue = value; + typedValue = value; return; } @@ -1088,37 +1339,37 @@ void BfIRCodeGen::Read(llvm::Value*& llvmValue, BfIRCodeGenEntry** codeGenEntry, { float f; mStream->Read(&f, sizeof(float)); - llvmValue = llvm::ConstantFP::get(llvmConstType, f); + typedValue.mValue = llvm::ConstantFP::get(llvmConstType, f); } else if (typeCode == BfTypeCode_Double) { double d; mStream->Read(&d, sizeof(double)); - llvmValue = llvm::ConstantFP::get(llvmConstType, d); + typedValue.mValue = llvm::ConstantFP::get(llvmConstType, d); } else if (typeCode == BfTypeCode_Boolean) { CMD_PARAM(bool, boolVal); - llvmValue = llvm::ConstantInt::get(llvmConstType, boolVal ? 1 : 0); + typedValue.mValue = llvm::ConstantInt::get(llvmConstType, boolVal ? 1 : 0); } else if (typeCode == BfTypeCode_None) { - llvmValue = NULL; + typedValue.mValue = NULL; } else if (typeCode == BfTypeCode_NullPtr) { CMD_PARAM(llvm::Type*, nullType); if (nullType != NULL) - llvmValue = llvm::ConstantPointerNull::get((llvm::PointerType*)nullType); + typedValue.mValue = llvm::ConstantPointerNull::get((llvm::PointerType*)nullType); else - llvmValue = llvm::ConstantPointerNull::get((llvm::PointerType*)llvmConstType); + typedValue.mValue = llvm::ConstantPointerNull::get((llvm::PointerType*)llvmConstType); } else if (BfIRBuilder::IsInt(typeCode)) { int64 intVal = ReadSLEB128(); auto constVal = llvm::ConstantInt::get(llvmConstType, intVal); auto constInt = (llvm::ConstantInt*)constVal; - llvmValue = constInt; + typedValue.mValue = constInt; } else { @@ -1133,11 +1384,14 @@ void BfIRCodeGen::Read(llvm::Value*& llvmValue, BfIRCodeGenEntry** codeGenEntry, FatalError(StrFormat("ARG out of bounds %d", argIdx)); } + auto typeEx = mActiveFunctionType; + BF_ASSERT(argIdx < mActiveFunction->arg_size()); auto argItr = mActiveFunction->arg_begin(); for (int i = 0; i < argIdx; i++) argItr++; - llvmValue = &(*argItr); + typedValue.mValue = &(*argItr); + typedValue.mTypeEx = GetTypeMember(typeEx, argIdx + 1); } else { @@ -1153,9 +1407,30 @@ void BfIRCodeGen::Read(llvm::Value*& llvmValue, BfIRCodeGenEntry** codeGenEntry, else { cmdId = mCmdCount - (paramType - BfIRParamType_StreamId_Back1) - 1; - } + } auto& result = mResults[cmdId]; + + if ((codeGenEntry != NULL) && (result.mKind != BfIRCodeGenEntryKind_None)) + *codeGenEntry = &result; + + if (result.mKind == BfIRCodeGenEntryKind_TypedValue_Aligned) + { + typedValue = result.mTypedValue; + + BfIRTypeEx* normalType = NULL; + if (mAlignedTypeToNormalType.TryGetValue(typedValue.mTypeEx, &normalType)) + typedValue.mTypeEx = normalType; + + return; + } + + if (result.mKind == BfIRCodeGenEntryKind_TypedValue) + { + typedValue = result.mTypedValue; + return; + } + if (result.mKind != BfIRCodeGenEntryKind_LLVMValue) { if ((codeGenEntry != NULL) && (result.mKind != BfIRCodeGenEntryKind_None)) @@ -1167,24 +1442,33 @@ void BfIRCodeGen::Read(llvm::Value*& llvmValue, BfIRCodeGenEntry** codeGenEntry, if (result.mKind == BfIRCodeGenEntryKind_LLVMValue_Aligned) { - llvmValue = result.mLLVMValue; + typedValue.mValue = result.mLLVMValue; if (sizeAlignKind != BfIRSizeAlignKind_Original) return; llvm::Type* normalType = NULL; - if (auto ptrType = llvm::dyn_cast(llvmValue->getType())) + //TODO: if (auto ptrType = llvm::dyn_cast(llvmValue->getType())) { - if (mAlignedTypeToNormalType.TryGetValue(ptrType->getElementType(), &normalType)) - { - llvmValue = mIRBuilder->CreateBitCast(llvmValue, normalType->getPointerTo()); - return; - } + +// if (mAlignedTypeToNormalType.TryGetValue(ptrType->getElementType(), &normalType)) +// { +// llvmValue = mIRBuilder->CreateBitCast(llvmValue, normalType->getPointerTo()); +// return; +// } } } BF_ASSERT(result.mKind == BfIRCodeGenEntryKind_LLVMValue); - llvmValue = result.mLLVMValue; + typedValue.mValue = result.mLLVMValue; } + FixTypedValue(typedValue); +} + +void BfIRCodeGen::Read(llvm::Value*& llvmValue, BfIRCodeGenEntry** codeGenEntry, BfIRSizeAlignKind sizeAlignKind) +{ + BfIRTypedValue typedValue; + Read(typedValue, codeGenEntry, sizeAlignKind); + llvmValue = typedValue.mValue; } void BfIRCodeGen::Read(llvm::Constant*& llvmConstant, BfIRSizeAlignKind sizeAlignKind) @@ -1210,12 +1494,40 @@ void BfIRCodeGen::Read(llvm::Function*& llvmFunc) llvmFunc = NULL; return; } - auto& result = mResults[streamId]; + auto& result = mResults[streamId]; + if (result.mKind == BfIRCodeGenEntryKind_TypedValue) + { + llvmFunc = (llvm::Function*)result.mTypedValue.mValue; + return; + } + BF_ASSERT(result.mKind == BfIRCodeGenEntryKind_LLVMValue); BF_ASSERT(llvm::isa(result.mLLVMValue)); llvmFunc = (llvm::Function*)result.mLLVMValue; } +void BfIRCodeGen::ReadFunction(BfIRTypedValue& typedValue) +{ + int streamId = (int)ReadSLEB128(); + if (streamId == -1) + { + typedValue.mValue = NULL; + typedValue.mTypeEx = NULL; + return; + } + auto& result = mResults[streamId]; + if (result.mKind == BfIRCodeGenEntryKind_TypedValue) + { + typedValue = result.mTypedValue; + return; + } + + BF_ASSERT(result.mKind == BfIRCodeGenEntryKind_LLVMValue); + BF_ASSERT(llvm::isa(result.mLLVMValue)); + typedValue.mValue = result.mLLVMValue; + FixTypedValue(typedValue); +} + void BfIRCodeGen::Read(llvm::BasicBlock*& llvmBlock) { int streamId = (int)ReadSLEB128(); @@ -1264,101 +1576,38 @@ void BfIRCodeGen::AddNop() } llvm::CallInst* callInst = mIRBuilder->CreateCall(mNopInlineAsm); - callInst->addAttribute(llvm::AttributeList::FunctionIndex, llvm::Attribute::NoUnwind); + + callInst->addFnAttr(llvm::Attribute::NoUnwind); } -llvm::Value* BfIRCodeGen::TryToVector(llvm::Value* value) +llvm::Value* BfIRCodeGen::TryToVector(const BfIRTypedValue& value) { - auto valueType = value->getType(); + auto valueType = value.mTypeEx->mLLVMType; if (llvm::isa(valueType)) - return value; - - if (auto ptrType = llvm::dyn_cast(valueType)) - { - auto ptrElemType = ptrType->getElementType(); - if (auto arrType = llvm::dyn_cast(ptrElemType)) - { - auto vecType = llvm::FixedVectorType::get(arrType->getArrayElementType(), (uint)arrType->getArrayNumElements()); - auto vecPtrType = vecType->getPointerTo(); - - auto ptrVal0 = mIRBuilder->CreateBitCast(value, vecPtrType); - return mIRBuilder->CreateAlignedLoad(ptrVal0, llvm::MaybeAlign(1)); - } - - if (auto vecType = llvm::dyn_cast(ptrElemType)) - { - return mIRBuilder->CreateAlignedLoad(value, llvm::MaybeAlign(1)); - } - } + return value.mValue; + + if (auto ptrType = llvm::dyn_cast(valueType)) + { + auto ptrElemType = GetTypeMember(value.mTypeEx, 0); + if (auto arrType = llvm::dyn_cast(ptrElemType->mLLVMType)) + { + auto vecType = llvm::FixedVectorType::get(arrType->getArrayElementType(), (uint)arrType->getArrayNumElements()); + auto vecPtrType = vecType->getPointerTo(); + + auto ptrVal0 = mIRBuilder->CreateBitCast(value.mValue, vecPtrType); + return mIRBuilder->CreateAlignedLoad(vecType, ptrVal0, llvm::MaybeAlign(1)); + } + + if (auto vecType = llvm::dyn_cast(ptrElemType->mLLVMType)) + { + return mIRBuilder->CreateAlignedLoad(vecType, value.mValue, llvm::MaybeAlign(1)); + } + } return NULL; } -llvm::Value* BfIRCodeGen::TryToVector(llvm::Value* value, llvm::Type* elemType) -{ - auto valueType = value->getType(); - if (auto vecType = llvm::dyn_cast(valueType)) - { - if (vecType->getElementType() == elemType) - return value; - - //TODO: We need an alloca.... - FatalError("Failed to get vector"); - - return value; - } - - if (auto ptrType = llvm::dyn_cast(valueType)) - { - auto ptrElemType = ptrType->getElementType(); - if (auto arrType = llvm::dyn_cast(ptrElemType)) - { - auto vecType = llvm::FixedVectorType::get(arrType->getArrayElementType(), (uint)arrType->getArrayNumElements()); - auto vecPtrType = vecType->getPointerTo(); - - auto ptrVal0 = mIRBuilder->CreateBitCast(value, vecPtrType); - return mIRBuilder->CreateAlignedLoad(ptrVal0, llvm::MaybeAlign(1)); - } - - if (auto vecType = llvm::dyn_cast(ptrElemType)) - { - if (vecType->getElementType() == elemType) - return mIRBuilder->CreateAlignedLoad(value, llvm::MaybeAlign(1)); - - auto dataLayout = llvm::DataLayout(mLLVMModule); - int wantNumElements = (int)vecType->getNumElements() * (int)dataLayout.getTypeSizeInBits(vecType->getElementType()) / (int)dataLayout.getTypeSizeInBits(elemType); - - auto newVecType = llvm::FixedVectorType::get(elemType, wantNumElements); - auto vecPtrType = newVecType->getPointerTo(); - - auto ptrVal0 = mIRBuilder->CreateBitCast(value, vecPtrType); - return mIRBuilder->CreateAlignedLoad(ptrVal0, llvm::MaybeAlign(1)); - } - } - - return NULL; -} - -llvm::Type* BfIRCodeGen::GetElemType(llvm::Value* value) -{ - auto valueType = value->getType(); - if (auto vecType = llvm::dyn_cast(valueType)) - return vecType->getElementType(); - - if (auto ptrType = llvm::dyn_cast(valueType)) - { - auto ptrElemType = ptrType->getElementType(); - if (auto arrType = llvm::dyn_cast(ptrElemType)) - return arrType->getArrayElementType(); - - if (auto vecType = llvm::dyn_cast(ptrElemType)) - return vecType->getElementType(); - } - - return NULL; -} - -bool BfIRCodeGen::TryMemCpy(llvm::Value* ptr, llvm::Value* val) +bool BfIRCodeGen::TryMemCpy(const BfIRTypedValue& ptr, llvm::Value* val) { auto valType = val->getType(); @@ -1377,7 +1626,7 @@ bool BfIRCodeGen::TryMemCpy(llvm::Value* ptr, llvm::Value* val) if (auto loadInst = llvm::dyn_cast(val)) { mIRBuilder->CreateMemCpy( - mIRBuilder->CreateBitCast(ptr, int8PtrTy), + mIRBuilder->CreateBitCast(ptr.mValue, int8PtrTy), llvm::MaybeAlign(1), mIRBuilder->CreateBitCast(loadInst->getPointerOperand(), int8PtrTy), llvm::MaybeAlign(1), @@ -1392,7 +1641,7 @@ bool BfIRCodeGen::TryMemCpy(llvm::Value* ptr, llvm::Value* val) if (llvm::isa(constVal)) { mIRBuilder->CreateMemSet( - mIRBuilder->CreateBitCast(ptr, int8PtrTy), + mIRBuilder->CreateBitCast(ptr.mValue, int8PtrTy), llvm::ConstantInt::get(int8Ty, 0), llvm::ConstantInt::get(int32Ty, arrayBytes), llvm::MaybeAlign(1)); @@ -1410,7 +1659,7 @@ bool BfIRCodeGen::TryMemCpy(llvm::Value* ptr, llvm::Value* val) llvm::GlobalValue::NotThreadLocal); mIRBuilder->CreateMemCpy( - mIRBuilder->CreateBitCast(ptr, int8PtrTy), + mIRBuilder->CreateBitCast(ptr.mValue, int8PtrTy), llvm::MaybeAlign(1), mIRBuilder->CreateBitCast(globalVariable, int8PtrTy), llvm::MaybeAlign(1), @@ -1419,48 +1668,43 @@ bool BfIRCodeGen::TryMemCpy(llvm::Value* ptr, llvm::Value* val) return true; } -bool BfIRCodeGen::TryVectorCpy(llvm::Value* ptr, llvm::Value* val) -{ - if (ptr->getType()->getPointerElementType() == val->getType()) - return false; +bool BfIRCodeGen::TryVectorCpy(const BfIRTypedValue& ptr, llvm::Value* val) +{ + if (GetTypeMember(ptr.mTypeEx, 0)->mLLVMType == val->getType()) + return false; if (!llvm::isa(val->getType())) { return false; } - auto usePtr = mIRBuilder->CreateBitCast(ptr, val->getType()->getPointerTo()); + auto usePtr = mIRBuilder->CreateBitCast(ptr.mValue, val->getType()->getPointerTo()); mIRBuilder->CreateAlignedStore(val, usePtr, llvm::MaybeAlign(1)); -// auto valType = val->getType(); -// auto vecType = llvm::dyn_cast(valType); -// if (vecType == NULL) -// return false; -// -// for (int i = 0; i < (int)vecType->getVectorNumElements(); i++) -// { -// auto extract = mIRBuilder->CreateExtractElement(val, i); -// -// llvm::Value* gepArgs[] = { -// llvm::ConstantInt::get(llvm::Type::getInt32Ty(*mLLVMContext), 0), -// llvm::ConstantInt::get(llvm::Type::getInt32Ty(*mLLVMContext), i) }; -// auto gep = mIRBuilder->CreateInBoundsGEP(ptr, llvm::makeArrayRef(gepArgs)); -// -// mIRBuilder->CreateStore(extract, gep); -// } - return true; } -llvm::Type* BfIRCodeGen::GetSizeAlignedType(BfIRTypeEntry* typeEntry) +llvm::Type* BfIRCodeGen::GetLLVMPointerElementType(BfIRTypeEx* typeEx) { - if ((typeEntry->mAlignLLVMType == NULL) && ((typeEntry->mSize & (typeEntry->mAlign - 1)) != 0)) + BF_ASSERT(typeEx != NULL); + BF_ASSERT(typeEx->mLLVMType->isPointerTy()); + return GetTypeMember(typeEx, 0)->mLLVMType; +} + +BfIRTypeEx* BfIRCodeGen::GetSizeAlignedType(BfIRTypeEntry* typeEntry) +{ + if ((typeEntry->mAlignType == NULL) && ((typeEntry->mSize & (typeEntry->mAlign - 1)) != 0)) { - auto structType = llvm::dyn_cast(typeEntry->mLLVMType); + auto structType = llvm::dyn_cast(typeEntry->mType->mLLVMType); if (structType != NULL) { + //TODO: Fill out properly + BF_ASSERT(structType->isPacked()); + auto alignTypeEx = new BfIRTypeEx(); + mIRTypeExs.Add(alignTypeEx); + auto alignType = llvm::StructType::create(*mLLVMContext, (structType->getName().str() + "_ALIGNED").c_str()); llvm::SmallVector members; for (int elemIdx = 0; elemIdx < (int)structType->getNumElements(); elemIdx++) @@ -1471,53 +1715,39 @@ llvm::Type* BfIRCodeGen::GetSizeAlignedType(BfIRTypeEntry* typeEntry) int fillSize = alignSize - typeEntry->mSize; members.push_back(llvm::ArrayType::get(llvm::Type::getInt8Ty(*mLLVMContext), fillSize)); alignType->setBody(members, structType->isPacked()); - - typeEntry->mAlignLLVMType = alignType; - mAlignedTypeToNormalType[alignType] = structType; + + alignTypeEx->mLLVMType = alignType; + typeEntry->mAlignType = alignTypeEx; + mAlignedTypeToNormalType[alignTypeEx] = typeEntry->mType; } } - if (typeEntry->mAlignLLVMType != NULL) - return typeEntry->mAlignLLVMType; + if (typeEntry->mAlignType != NULL) + return typeEntry->mAlignType; - return typeEntry->mLLVMType; + return typeEntry->mType; } -llvm::Value* BfIRCodeGen::GetAlignedPtr(llvm::Value* val) -{ - if (auto ptrType = llvm::dyn_cast(val->getType())) +BfIRTypedValue BfIRCodeGen::GetAlignedPtr(const BfIRTypedValue& val) +{ + BfIRTypedValue result = val; + + if (auto ptrType = llvm::dyn_cast(val.mTypeEx->mLLVMType)) { - auto elemType = ptrType->getElementType(); + auto elemType = GetTypeMember(val.mTypeEx, 0); auto typeEntry = GetTypeEntry(elemType); if (typeEntry != NULL) { auto alignedType = GetSizeAlignedType(typeEntry); if (alignedType != elemType) - { - return mIRBuilder->CreateBitCast(val, alignedType->getPointerTo()); - } - } - } - return NULL; -} - -llvm::Value* BfIRCodeGen::FixGEP(llvm::Value* fromValue, llvm::Value* result) -{ - if (auto ptrType = llvm::dyn_cast(fromValue->getType())) - { - if (auto arrayType = llvm::dyn_cast(ptrType->getElementType())) - { - llvm::Type* normalType = NULL; - if (mAlignedTypeToNormalType.TryGetValue(arrayType->getElementType(), &normalType)) - { - return mIRBuilder->CreateBitCast(result, normalType->getPointerTo()); - } + result.mTypeEx = GetPointerTypeEx(alignedType); } } return result; } + llvm::Value* BfIRCodeGen::DoCheckedIntrinsic(llvm::Intrinsic::ID intrin, llvm::Value* lhs, llvm::Value* rhs, bool useAsm) { if ((mTargetTriple.GetMachineType() != BfMachineType_x86) && (mTargetTriple.GetMachineType() != BfMachineType_x64)) @@ -1530,9 +1760,8 @@ llvm::Value* BfIRCodeGen::DoCheckedIntrinsic(llvm::Intrinsic::ID intrin, llvm::V CmdParamVec args; args.push_back(lhs); args.push_back(rhs); - llvm::FunctionType* funcType = NULL; - if (auto ptrType = llvm::dyn_cast(func->getType())) - funcType = llvm::dyn_cast(ptrType->getElementType()); + llvm::FunctionType* funcType = func->getFunctionType(); + auto aggResult = mIRBuilder->CreateCall(funcType, func, args); auto valResult = mIRBuilder->CreateExtractValue(aggResult, 0); auto failResult = mIRBuilder->CreateExtractValue(aggResult, 1); @@ -1546,15 +1775,15 @@ llvm::Value* BfIRCodeGen::DoCheckedIntrinsic(llvm::Intrinsic::ID intrin, llvm::V mIRBuilder->CreateCondBr(failResult, failBB, passBB); - mActiveFunction->getBasicBlockList().push_back(failBB); + mActiveFunction->insert(mActiveFunction->end(), failBB); mIRBuilder->SetInsertPoint(failBB); auto trapDecl = llvm::Intrinsic::getDeclaration(mLLVMModule, llvm::Intrinsic::trap); auto callInst = mIRBuilder->CreateCall(trapDecl); - callInst->addAttribute(llvm::AttributeList::FunctionIndex, llvm::Attribute::NoReturn); + callInst->addFnAttr(llvm::Attribute::NoReturn); mIRBuilder->CreateBr(passBB); - - mActiveFunction->getBasicBlockList().push_back(passBB); + + mActiveFunction->insert(mActiveFunction->end(), passBB); mIRBuilder->SetInsertPoint(passBB); } else @@ -1579,7 +1808,7 @@ llvm::Value* BfIRCodeGen::DoCheckedIntrinsic(llvm::Intrinsic::ID intrin, llvm::V llvm::SmallVector llvmArgs; llvmArgs.push_back(mIRBuilder->CreateIntCast(failResult, llvm::Type::getInt8Ty(*mLLVMContext), false)); llvm::CallInst* callInst = mIRBuilder->CreateCall(mOverflowCheckAsm, llvmArgs); - callInst->addAttribute(llvm::AttributeList::FunctionIndex, llvm::Attribute::NoUnwind); + callInst->addFnAttr(llvm::Attribute::NoUnwind); } return valResult; } @@ -1689,7 +1918,7 @@ void BfIRCodeGen::InitTarget() { llvm::SMDiagnostic Err; llvm::Triple theTriple = llvm::Triple(mLLVMModule->getTargetTriple()); - llvm::CodeGenOpt::Level optLvl = llvm::CodeGenOpt::None; + llvm::CodeGenOptLevel optLvl = llvm::CodeGenOptLevel::None; String cpuName = mTargetCPU; String arch = ""; @@ -1712,9 +1941,9 @@ void BfIRCodeGen::InitTarget() //optLvl = CodeGenOpt::Less; } else if (mCodeGenOptions.mOptLevel == BfOptLevel_O2) - optLvl = llvm::CodeGenOpt::Default; + optLvl = llvm::CodeGenOptLevel::Default; else if (mCodeGenOptions.mOptLevel == BfOptLevel_O3) - optLvl = llvm::CodeGenOpt::Aggressive; + optLvl = llvm::CodeGenOptLevel::Aggressive; if (theTriple.isWasm()) featuresStr = "+atomics,+bulk-memory,+mutable-globals,+sign-ext"; @@ -1733,7 +1962,7 @@ void BfIRCodeGen::InitTarget() else if (mCodeGenOptions.mSIMDSetting == BfSIMDSetting_AVX2) featuresStr = "+avx2"; - llvm::Optional relocModel; + std::optional relocModel; llvm::CodeModel::Model cmModel = llvm::CodeModel::Small; switch (mCodeGenOptions.mRelocType) @@ -1811,7 +2040,8 @@ void BfIRCodeGen::HandleNextCmd() CMD_PARAM(String, targetCPU); mTargetTriple.Set(targetTriple); - mTargetCPU = targetCPU; + mTargetCPU = targetCPU; + if (targetTriple.IsEmpty()) mLLVMModule->setTargetTriple(llvm::sys::getDefaultTargetTriple()); else @@ -1846,19 +2076,23 @@ void BfIRCodeGen::HandleNextCmd() case BfIRCmd_SetType: { CMD_PARAM(int, typeId); - CMD_PARAM(llvm::Type*, type); + + CMD_PARAM(BfIRTypeEx*, type); + //llvm::Type* type; + //llvm::Type* elementType; + auto& typeEntry = GetTypeEntry(typeId); - typeEntry.mLLVMType = type; - if (typeEntry.mInstLLVMType == NULL) - typeEntry.mInstLLVMType = type; + typeEntry.mType = type; + if (typeEntry.mInstType == NULL) + typeEntry.mInstType = type; mTypeToTypeIdMap[type] = typeId; } break; case BfIRCmd_SetInstType: { CMD_PARAM(int, typeId); - CMD_PARAM(llvm::Type*, type); - GetTypeEntry(typeId).mInstLLVMType = type; + CMD_PARAM(BfIRTypeEx*, type); + GetTypeEntry(typeId).mInstType = type; } break; case BfIRCmd_PrimitiveType: @@ -1870,32 +2104,58 @@ void BfIRCodeGen::HandleNextCmd() break; case BfIRCmd_CreateAnonymousStruct: { - CMD_PARAM(CmdParamVec, members); - llvm::StructType* structType = llvm::StructType::get(*mLLVMContext, members); - SetResult(curId, structType); + CMD_PARAM(CmdParamVec, members); + + CmdParamVec llvmMembers; + for (auto& memberType : members) + llvmMembers.push_back(memberType->mLLVMType); + + auto structType = llvm::StructType::get(*mLLVMContext, llvmMembers); + auto typeEx = CreateTypeEx(structType); + for (auto& memberType : members) + { + BF_ASSERT(memberType != NULL); + typeEx->mMembers.Add(memberType); + } + + SetResult(curId, typeEx); } break; case BfIRCmd_CreateStruct: { CMD_PARAM(String, typeName); - SetResult(curId, llvm::StructType::create(*mLLVMContext, typeName.c_str())); + + auto structType = llvm::StructType::create(*mLLVMContext, typeName.c_str()); + auto typeEx = CreateTypeEx(structType); + SetResult(curId, typeEx); } break; case BfIRCmd_StructSetBody: { - llvm::Type* type = NULL; + BfIRTypeEx* typeEx = NULL; BfIRTypeEntry* typeEntry = NULL; - Read(type, &typeEntry); - CMD_PARAM(CmdParamVec, members); + Read(typeEx, &typeEntry); + CMD_PARAM(CmdParamVec, members); CMD_PARAM(int, instSize); CMD_PARAM(int, instAlign); CMD_PARAM(bool, isPacked); + typeEx->mMembers.clear(); + auto type = typeEx->mLLVMType; + + CmdParamVec llvmMembers; + for (auto& memberType : members) + { + BF_ASSERT(memberType != NULL); + typeEx->mMembers.Add(memberType); + llvmMembers.push_back(memberType->mLLVMType); + } + BF_ASSERT(llvm::isa(type)); auto structType = (llvm::StructType*)type; if (structType->isOpaque()) - structType->setBody(members, isPacked); + structType->setBody(llvmMembers, isPacked); if (typeEntry != NULL) { typeEntry->mSize = instSize; @@ -1906,68 +2166,80 @@ void BfIRCodeGen::HandleNextCmd() case BfIRCmd_Type: { CMD_PARAM(BfIRTypeEntry*, typeEntry); - auto type = typeEntry->mLLVMType; + auto type = typeEntry->mType; SetResult(curId, type); } break; case BfIRCmd_TypeInst: { CMD_PARAM(BfIRTypeEntry*, typeEntry); - SetResult(curId, typeEntry->mInstLLVMType); + SetResult(curId, typeEntry->mInstType); } break; case BfIRCmd_TypeInstPtr: { CMD_PARAM(BfIRTypeEntry*, typeEntry); - SetResult(curId, typeEntry->mInstLLVMType->getPointerTo()); + SetResult(curId, GetPointerTypeEx(typeEntry->mInstType)); } break; case BfIRCmd_GetType: { - CMD_PARAM(llvm::Value*, value); - auto type = value->getType(); - SetResult(curId, type); + CMD_PARAM(BfIRTypedValue, typedValue); + BF_ASSERT(typedValue.mTypeEx != NULL); + SetResult(curId, typedValue.mTypeEx); } break; case BfIRCmd_GetPointerToFuncType: { - CMD_PARAM(llvm::FunctionType*, funcType); - SetResult(curId, funcType->getPointerTo()); + BfIRTypeEx* funcType = NULL; + ReadFunctionType(funcType); + SetResult(curId, GetPointerTypeEx(funcType)); } break; case BfIRCmd_GetPointerToType: { - CMD_PARAM(llvm::Type*, type); - SetResult(curId, type->getPointerTo()); + CMD_PARAM(BfIRTypeEx*, type); + SetResult(curId, GetPointerTypeEx(type)); } break; case BfIRCmd_GetSizedArrayType: { - llvm::Type* elementType = NULL; + BfIRTypeEx* elementType = NULL; BfIRTypeEntry* elementTypeEntry = NULL; - Read(elementType, &elementTypeEntry); + + auto typeEx = new BfIRTypeEx(); + typeEx->mMembers.Add(elementType); + mIRTypeExs.Add(typeEx); + CMD_PARAM(int, length); if (elementTypeEntry != NULL) - SetResult(curId, llvm::ArrayType::get(GetSizeAlignedType(elementTypeEntry), length)); + typeEx->mLLVMType = llvm::ArrayType::get(GetSizeAlignedType(elementTypeEntry)->mLLVMType, length); else - SetResult(curId, llvm::ArrayType::get(elementType, length)); + typeEx->mLLVMType = llvm::ArrayType::get(elementType->mLLVMType, length); + + SetResult(curId, typeEx); } break; case BfIRCmd_GetVectorType: { - CMD_PARAM(llvm::Type*, elementType); + CMD_PARAM(BfIRTypeEx*, elementType); CMD_PARAM(int, length); - SetResult(curId, llvm::FixedVectorType::get(elementType, length)); + + auto typeEx = new BfIRTypeEx(); + mIRTypeExs.Add(typeEx); + typeEx->mLLVMType = llvm::FixedVectorType::get(elementType->mLLVMType, length); + typeEx->mMembers.Add(elementType); + SetResult(curId, typeEx); } break; case BfIRCmd_CreateConstAgg: { - CMD_PARAM(llvm::Type*, type); + CMD_PARAM(BfIRTypeEx*, type); CMD_PARAM(CmdParamVec, values) llvm::SmallVector copyValues; - if (auto arrayType = llvm::dyn_cast(type)) + if (auto arrayType = llvm::dyn_cast(type->mLLVMType)) { for (auto val : values) { @@ -1983,9 +2255,13 @@ void BfIRCodeGen::HandleNextCmd() for (int i = 0; i < fillCount; i++) copyValues.push_back(lastValue); } - SetResult(curId, llvm::ConstantArray::get(arrayType, copyValues)); + + BfIRTypedValue result; + result.mTypeEx = type; + result.mValue = llvm::ConstantArray::get(arrayType, copyValues); + SetResult(curId, result); } - else if (auto structType = llvm::dyn_cast(type)) + else if (auto structType = llvm::dyn_cast(type->mLLVMType)) { FixValues(structType, values); for (auto val : values) @@ -1994,7 +2270,10 @@ void BfIRCodeGen::HandleNextCmd() BF_ASSERT(constValue != NULL); copyValues.push_back(constValue); } - SetResult(curId, llvm::ConstantStruct::get(structType, copyValues)); + BfIRTypedValue result; + result.mTypeEx = type; + result.mValue = llvm::ConstantStruct::get(structType, copyValues); + SetResult(curId, result); } else Fail("Bad type"); @@ -2002,14 +2281,21 @@ void BfIRCodeGen::HandleNextCmd() break; case BfIRCmd_CreateConstStructZero: { - CMD_PARAM(llvm::Type*, type); - SetResult(curId, llvm::ConstantAggregateZero::get(type)); + CMD_PARAM(BfIRTypeEx*, type); + BfIRTypedValue result; + result.mTypeEx = type; + result.mValue = llvm::ConstantAggregateZero::get(type->mLLVMType); + SetResult(curId, result); } break; case BfIRCmd_CreateConstString: { CMD_PARAM(String, str); - SetResult(curId, llvm::ConstantDataArray::getString(*mLLVMContext, llvm::StringRef(str.c_str(), str.length()))); + + BfIRTypedValue result; + result.mValue = llvm::ConstantDataArray::getString(*mLLVMContext, llvm::StringRef(str.c_str(), str.length())); + result.mTypeEx = GetTypeEx(result.mValue->getType()); + SetResult(curId, result); } break; case BfIRCmd_ConfigConst: @@ -2033,8 +2319,11 @@ void BfIRCodeGen::HandleNextCmd() break; case BfIRCmd_CreateUndefValue: { - CMD_PARAM(llvm::Type*, type); - SetResult(curId, llvm::UndefValue::get(type)); + CMD_PARAM(BfIRTypeEx*, type); + BfIRTypedValue result; + result.mTypeEx = type; + result.mValue = llvm::UndefValue::get(type->mLLVMType); + SetResult(curId, result); } break; case BfIRCmd_NumericCast: @@ -2317,87 +2606,114 @@ void BfIRCodeGen::HandleNextCmd() break; case BfIRCmd_BitCast: { - CMD_PARAM(llvm::Value*, val); - CMD_PARAM(llvm::Type*, toType); + CMD_PARAM(BfIRTypedValue, val); + CMD_PARAM(BfIRTypeEx*, toType); - auto fromType = val->getType(); - if ((!fromType->isPointerTy()) || (!toType->isPointerTy())) + BfIRTypedValue result; + result.mTypeEx = toType; + + auto fromType = val.mValue->getType(); + if ((!fromType->isPointerTy()) || (!toType->mLLVMType->isPointerTy())) { - if (fromType->isIntegerTy()) - { - SetResult(curId, mIRBuilder->CreateIntToPtr(val, toType)); - break; - } - SetResult(curId, mIRBuilder->CreatePtrToInt(val, toType)); - break; + if (fromType->isIntegerTy()) + result.mValue = mIRBuilder->CreateIntToPtr(val.mValue, toType->mLLVMType); + else + result.mValue = mIRBuilder->CreatePtrToInt(val.mValue, toType->mLLVMType); } - - SetResult(curId, mIRBuilder->CreateBitCast(val, toType)); + else + result.mValue = mIRBuilder->CreateBitCast(val.mValue, toType->mLLVMType); + SetResult(curId, result); } break; case BfIRCmd_PtrToInt: { CMD_PARAM(llvm::Value*, val); auto typeCode = (BfTypeCode)mStream->Read(); - bool isSigned; - auto llvmType = GetLLVMType(typeCode, isSigned); - SetResult(curId, mIRBuilder->CreatePtrToInt(val, llvmType)); + bool isSigned; + + BfIRTypedValue result; + result.mTypeEx = GetTypeEx(typeCode, isSigned); + result.mValue = mIRBuilder->CreatePtrToInt(val, result.mTypeEx->mLLVMType); + SetResult(curId, result); } break; case BfIRCmd_IntToPtr: { CMD_PARAM(llvm::Value*, val); - CMD_PARAM(llvm::Type*, toType); - SetResult(curId, mIRBuilder->CreateIntToPtr(val, toType)); + CMD_PARAM(BfIRTypeEx*, toType); + + BfIRTypedValue result; + result.mTypeEx = toType; + result.mValue = mIRBuilder->CreateIntToPtr(val, toType->mLLVMType); + SetResult(curId, result); } break; case BfIRCmd_InboundsGEP1_32: { - CMD_PARAM(llvm::Value*, val); + CMD_PARAM(BfIRTypedValue, val); CMD_PARAM(int, idx0); + + BfIRTypedValue result; + result.mTypeEx = val.mTypeEx; + auto alignedPtr = GetAlignedPtr(val); - if (auto alignedPtr = GetAlignedPtr(val)) - { - auto gepResult = mIRBuilder->CreateConstInBoundsGEP1_32(alignedPtr->getType()->getPointerElementType(), alignedPtr, idx0); - SetResult(curId, mIRBuilder->CreateBitCast(gepResult, val->getType())); - break; - } - - SetResult(curId, mIRBuilder->CreateConstInBoundsGEP1_32(val->getType()->getPointerElementType(), val, idx0)); + auto compositeType = GetTypeMember(alignedPtr.mTypeEx, 0); + result.mValue = mIRBuilder->CreateConstInBoundsGEP1_32(compositeType->mLLVMType, alignedPtr.mValue, idx0); + SetResult(curId, result); } break; case BfIRCmd_InboundsGEP2_32: { - CMD_PARAM(llvm::Value*, val); + CMD_PARAM(BfIRTypedValue, val); CMD_PARAM(int, idx0); CMD_PARAM(int, idx1); - SetResult(curId, FixGEP(val, mIRBuilder->CreateConstInBoundsGEP2_32(val->getType()->getPointerElementType(), val, idx0, idx1))); + + auto compositeType = GetTypeMember(val.mTypeEx, 0); + int elemIdx = BF_MIN(idx1, (int)compositeType->mMembers.mSize - 1); + BfIRTypeEx* elemType = GetTypeMember(compositeType, elemIdx); + + BfIRTypedValue result; + result.mValue = mIRBuilder->CreateConstInBoundsGEP2_32(compositeType->mLLVMType, val.mValue, idx0, idx1); + result.mTypeEx = GetPointerTypeEx(elemType); + + SetResult(curId, result); } break; case BfIRCmd_InBoundsGEP1: { - CMD_PARAM(llvm::Value*, val); + CMD_PARAM(BfIRTypedValue, val); CMD_PARAM(llvm::Value*, idx0); - if (auto alignedPtr = GetAlignedPtr(val)) - { - auto gepResult = mIRBuilder->CreateInBoundsGEP(alignedPtr, idx0); - SetResult(curId, mIRBuilder->CreateBitCast(gepResult, val->getType())); - break; - } + BfIRTypedValue result; + auto alignedPtr = GetAlignedPtr(val); + auto compositeType = GetTypeMember(alignedPtr.mTypeEx, 0); + FixIndexer(idx0); - SetResult(curId, mIRBuilder->CreateInBoundsGEP(val, idx0)); + result.mValue = mIRBuilder->CreateInBoundsGEP(compositeType->mLLVMType, alignedPtr.mValue, idx0); + result.mTypeEx = val.mTypeEx; + SetResult(curId, result); } break; case BfIRCmd_InBoundsGEP2: { - CMD_PARAM(llvm::Value*, val); + CMD_PARAM(BfIRTypedValue, val); CMD_PARAM(llvm::Value*, idx0); CMD_PARAM(llvm::Value*, idx1); FixIndexer(idx0); FixIndexer(idx1); llvm::Value* indices[2] = { idx0, idx1 }; - SetResult(curId, FixGEP(val, mIRBuilder->CreateInBoundsGEP(val, llvm::makeArrayRef(indices)))); + + int elemIdx = 0; + if (auto constInt = llvm::dyn_cast(idx1)) + elemIdx = BF_MIN((int)constInt->getSExtValue(), (int)val.mTypeEx->mMembers.mSize - 1); + + auto compositeType = GetTypeMember(val.mTypeEx, 0); + BfIRTypeEx* elemType = GetTypeMember(compositeType, elemIdx); + + BfIRTypedValue result; + result.mValue = mIRBuilder->CreateInBoundsGEP(compositeType->mLLVMType, val.mValue, llvm::makeArrayRef(indices)); + result.mTypeEx = GetPointerTypeEx(elemType); + SetResult(curId, result); } break; case BfIRCmd_IsNull: @@ -2414,41 +2730,48 @@ void BfIRCodeGen::HandleNextCmd() break; case BfIRCmd_ExtractValue: { - CMD_PARAM(llvm::Value*, val); + CMD_PARAM(BfIRTypedValue, val); CMD_PARAM(int, idx); - SetResult(curId, mIRBuilder->CreateExtractValue(val, llvm::makeArrayRef((unsigned)idx))); + + auto compositeType = val.mTypeEx; + int elemIdx = BF_MIN(idx, (int)compositeType->mMembers.mSize - 1); + auto elemType = GetTypeMember(compositeType, elemIdx); + + BfIRTypedValue result; + result.mTypeEx = elemType; + result.mValue = mIRBuilder->CreateExtractValue(val.mValue, llvm::makeArrayRef((unsigned)idx)); + SetResult(curId, result); } break; case BfIRCmd_InsertValue: { - CMD_PARAM(llvm::Value*, agg); - CMD_PARAM(llvm::Value*, val); + CMD_PARAM(BfIRTypedValue, agg); + CMD_PARAM(BfIRTypedValue, val); CMD_PARAM(int, idx); - /*if (idx < 0) - { - idx = -idx; - auto elementType = ((llvm::StructType*)agg->getType())->getElementType(idx); - val = mIRBuilder->CreateBitCast(val, elementType); - }*/ - - SetResult(curId, mIRBuilder->CreateInsertValue(agg, val, llvm::makeArrayRef((unsigned)idx))); + BfIRTypedValue result; + result.mTypeEx = agg.mTypeEx; + result.mValue = mIRBuilder->CreateInsertValue(agg.mValue, val.mValue, llvm::makeArrayRef((unsigned)idx)); + SetResult(curId, result); } break; case BfIRCmd_Alloca: { - CMD_PARAM(llvm::Type*, type); - if (type->isStructTy()) + CMD_PARAM(BfIRTypeEx*, type); + if (type->mLLVMType->isStructTy()) { - BF_ASSERT(!((llvm::StructType*)type)->isOpaque()); + BF_ASSERT(!((llvm::StructType*)type->mLLVMType)->isOpaque()); } - SetResult(curId, mIRBuilder->CreateAlloca(type)); + BfIRTypedValue result; + result.mTypeEx = GetPointerTypeEx(type); + result.mValue = mIRBuilder->CreateAlloca(type->mLLVMType); + SetResult(curId, result); } break; case BfIRCmd_AllocaArray: { - CMD_PARAM(llvm::Type*, type); + CMD_PARAM(BfIRTypeEx*, type); CMD_PARAM(llvm::Value*, arraySize); auto origType = type; @@ -2456,10 +2779,19 @@ void BfIRCodeGen::HandleNextCmd() if (typeEntry != NULL) type = GetSizeAlignedType(typeEntry); + BfIRTypedValue typedValue; + typedValue.mTypeEx = GetPointerTypeEx(type); + if (origType != type) - SetResultAligned(curId, mIRBuilder->CreateAlloca(type, arraySize)); + { + typedValue.mValue = mIRBuilder->CreateAlloca(type->mLLVMType, arraySize); + SetResultAligned(curId, typedValue); + } else - SetResult(curId, mIRBuilder->CreateAlloca(type, arraySize)); + { + typedValue.mValue = mIRBuilder->CreateAlloca(type->mLLVMType, arraySize); + SetResult(curId, typedValue); + } } break; case BfIRCmd_SetAllocaAlignment: @@ -2500,39 +2832,49 @@ void BfIRCodeGen::HandleNextCmd() break; case BfIRCmd_Load: { - CMD_PARAM(llvm::Value*, val); + CMD_PARAM(BfIRTypedValue, typedValue); + BF_ASSERT(typedValue.mTypeEx != NULL); CMD_PARAM(bool, isVolatile); - SetResult(curId, mIRBuilder->CreateLoad(val, isVolatile)); + + BfIRTypedValue result; + result.mTypeEx = GetTypeMember(typedValue.mTypeEx, 0); + result.mValue = mIRBuilder->CreateLoad(result.mTypeEx->mLLVMType, typedValue.mValue, isVolatile); + SetResult(curId, result); } break; case BfIRCmd_AlignedLoad: { - CMD_PARAM(llvm::Value*, val); + CMD_PARAM(BfIRTypedValue, typedValue); + BF_ASSERT(typedValue.mTypeEx != NULL); CMD_PARAM(int, alignment); CMD_PARAM(bool, isVolatile); - SetResult(curId, mIRBuilder->CreateAlignedLoad(val, llvm::MaybeAlign(alignment), isVolatile)); + + BfIRTypedValue result; + result.mTypeEx = GetTypeMember(typedValue.mTypeEx, 0); + result.mValue = mIRBuilder->CreateAlignedLoad(result.mTypeEx->mLLVMType, typedValue.mValue, llvm::MaybeAlign(alignment), isVolatile); + SetResult(curId, result); } break; case BfIRCmd_Store: { - CMD_PARAM(llvm::Value*, val); - CMD_PARAM(llvm::Value*, ptr); + CMD_PARAM(BfIRTypedValue, val); + CMD_PARAM(BfIRTypedValue, ptr); CMD_PARAM(bool, isVolatile); - if ((!TryMemCpy(ptr, val)) && - (!TryVectorCpy(ptr, val))) - SetResult(curId, mIRBuilder->CreateStore(val, ptr, isVolatile)); + if ((!TryMemCpy(ptr, val.mValue)) && + (!TryVectorCpy(ptr, val.mValue))) + SetResult(curId, mIRBuilder->CreateStore(val.mValue, ptr.mValue, isVolatile)); } break; case BfIRCmd_AlignedStore: { - CMD_PARAM(llvm::Value*, val); - CMD_PARAM(llvm::Value*, ptr); + CMD_PARAM(BfIRTypedValue, val); + CMD_PARAM(BfIRTypedValue, ptr); CMD_PARAM(int, alignment); CMD_PARAM(bool, isVolatile); - if ((!TryMemCpy(ptr, val)) && - (!TryVectorCpy(ptr, val))) - SetResult(curId, mIRBuilder->CreateAlignedStore(val, ptr, llvm::MaybeAlign(alignment), isVolatile)); + if ((!TryMemCpy(ptr, val.mValue)) && + (!TryVectorCpy(ptr, val.mValue))) + SetResult(curId, mIRBuilder->CreateAlignedStore(val.mValue, ptr.mValue, llvm::MaybeAlign(alignment), isVolatile)); } break; case BfIRCmd_MemSet: @@ -2554,22 +2896,29 @@ void BfIRCodeGen::HandleNextCmd() break; case BfIRCmd_StackSave: { - auto intrin = llvm::Intrinsic::getDeclaration(mLLVMModule, llvm::Intrinsic::stacksave); - auto callInst = mIRBuilder->CreateCall(intrin); - SetResult(curId, callInst); + //auto intrin = llvm::Intrinsic::getDeclaration(mLLVMModule, llvm::Intrinsic::stacksave); + //CreateStackSave + + //auto callInst = mIRBuilder->CreateCall(intrin); + + BfIRTypedValue result; + result.mValue = mIRBuilder->CreateStackSave(); + result.mTypeEx = GetTypeEx(result.mValue->getType()); + SetResult(curId, result); } break; case BfIRCmd_StackRestore: { CMD_PARAM(llvm::Value*, stackVal); - auto intrin = llvm::Intrinsic::getDeclaration(mLLVMModule, llvm::Intrinsic::stackrestore); - auto callInst = mIRBuilder->CreateCall(intrin, llvm::SmallVector {stackVal }); + //auto intrin = llvm::Intrinsic::getDeclaration(mLLVMModule, llvm::Intrinsic::stackrestore); + //auto callInst = mIRBuilder->CreateCall(intrin, llvm::SmallVector {stackVal }); + auto callInst = mIRBuilder->CreateStackRestore(stackVal); SetResult(curId, callInst); } break; case BfIRCmd_GlobalVariable: { - CMD_PARAM(llvm::Type*, varType); + CMD_PARAM(BfIRTypeEx*, varType); CMD_PARAM(bool, isConstant); BfIRLinkageType linkageType = (BfIRLinkageType)mStream->Read(); CMD_PARAM(String, name); @@ -2581,13 +2930,17 @@ void BfIRCodeGen::HandleNextCmd() { globalVariable = new llvm::GlobalVariable( *mLLVMModule, - varType, + varType->mLLVMType, isConstant, LLVMMapLinkageType(linkageType), initializer, name.c_str(), NULL, isTLS ? llvm::GlobalValue::GeneralDynamicTLSModel : llvm::GlobalValue::NotThreadLocal); } - SetResult(curId, globalVariable); + + BfIRTypedValue result; + result.mValue = globalVariable; + result.mTypeEx = GetPointerTypeEx(varType); + SetResult(curId, result); } break; case BfIRCmd_GlobalVar_SetUnnamedAddr: @@ -2621,13 +2974,17 @@ void BfIRCodeGen::HandleNextCmd() case BfIRCmd_GlobalStringPtr: { CMD_PARAM(String, str); - SetResult(curId, mIRBuilder->CreateGlobalStringPtr(llvm::StringRef(str.c_str(), str.length()))); + + BfIRTypedValue result; + result.mValue = mIRBuilder->CreateGlobalStringPtr(llvm::StringRef(str.c_str(), str.length())); + result.mTypeEx = GetTypeEx(result.mValue->getType()); + SetResult(curId, result); } break; case BfIRCmd_SetReflectTypeData: { - CMD_PARAM(llvm::Type*, type); - CMD_PARAM(llvm::Value*, value); + CMD_PARAM(BfIRTypeEx*, type); + CMD_PARAM(BfIRTypedValue, value); mReflectDataMap[type] = value; } break; @@ -2637,7 +2994,7 @@ void BfIRCodeGen::HandleNextCmd() CMD_PARAM(bool, addNow); auto block = llvm::BasicBlock::Create(*mLLVMContext, name.c_str()); if (addNow) - mActiveFunction->getBasicBlockList().push_back(block); + mActiveFunction->insert(mActiveFunction->end(), block); SetResult(curId, block); } break; @@ -2649,7 +3006,7 @@ void BfIRCodeGen::HandleNextCmd() { auto bb = llvm::BasicBlock::Create(*mLLVMContext, name.c_str()); mIRBuilder->CreateBr(bb); - mActiveFunction->getBasicBlockList().push_back(bb); + mActiveFunction->insert(mActiveFunction->end(), bb); mIRBuilder->SetInsertPoint(bb); newBlock = bb; } @@ -2659,43 +3016,45 @@ void BfIRCodeGen::HandleNextCmd() case BfIRCmd_AddBlock: { CMD_PARAM(llvm::BasicBlock*, block); - mActiveFunction->getBasicBlockList().push_back(block); + mActiveFunction->insert(mActiveFunction->end(), block); } break; case BfIRCmd_DropBlocks: { - CMD_PARAM(llvm::BasicBlock*, startingBlock); - auto& basicBlockList = mActiveFunction->getBasicBlockList(); - int postExitBlockIdx = -1; - - auto itr = basicBlockList.rbegin(); - int blockIdx = (int)basicBlockList.size() - 1; - while (itr != basicBlockList.rend()) - { - auto& block = *itr++; - block.dropAllReferences(); - if (&block == startingBlock) - { - postExitBlockIdx = blockIdx; - break; - } - blockIdx--; - } - - while ((int)basicBlockList.size() > postExitBlockIdx) - { - auto& block = basicBlockList.back(); - block.eraseFromParent(); - } + //TODO: Not even needed +// CMD_PARAM(llvm::BasicBlock*, startingBlock); +// auto& basicBlockList = mActiveFunction->getBasicBlockList(); +// int postExitBlockIdx = -1; +// +// auto itr = basicBlockList.rbegin(); +// int blockIdx = (int)basicBlockList.size() - 1; +// while (itr != basicBlockList.rend()) +// { +// auto& block = *itr++; +// block.dropAllReferences(); +// if (&block == startingBlock) +// { +// postExitBlockIdx = blockIdx; +// break; +// } +// blockIdx--; +// } +// +// while ((int)basicBlockList.size() > postExitBlockIdx) +// { +// auto& block = basicBlockList.back(); +// block.eraseFromParent(); +// } } break; case BfIRCmd_MergeBlockDown: { CMD_PARAM(llvm::BasicBlock*, fromBlock); CMD_PARAM(llvm::BasicBlock*, intoBlock); - llvm::BasicBlock::InstListType& fromInstList = fromBlock->getInstList(); - llvm::BasicBlock::InstListType& intoInstList = intoBlock->getInstList(); - intoInstList.splice(intoInstList.begin(), fromInstList, fromInstList.begin(), fromInstList.end()); + //llvm::BasicBlock::InstListType& fromInstList = fromBlock->getInstList(); + //llvm::BasicBlock::InstListType& intoInstList = intoBlock->getInstList(); + //intoInstList.splice(intoInstList.begin(), fromInstList, fromInstList.begin(), fromInstList.end()); + intoBlock->splice(intoBlock->begin(), fromBlock); fromBlock->eraseFromParent(); } break; @@ -2761,7 +3120,7 @@ void BfIRCodeGen::HandleNextCmd() case BfIRCmd_MoveBlockToEnd: { CMD_PARAM(llvm::BasicBlock*, block); - block->moveAfter(&block->getParent()->getBasicBlockList().back()); + block->moveAfter(&block->getParent()->back()); } break; case BfIRCmd_CreateSwitch: @@ -2791,9 +3150,12 @@ void BfIRCodeGen::HandleNextCmd() break; case BfIRCmd_CreatePhi: { - CMD_PARAM(llvm::Type*, type); - CMD_PARAM(int, incomingCount); - SetResult(curId, mIRBuilder->CreatePHI(type, incomingCount)); + CMD_PARAM(BfIRTypeEx*, type); + CMD_PARAM(int, incomingCount); + BfIRTypedValue result; + result.mTypeEx = type; + result.mValue = mIRBuilder->CreatePHI(type->mLLVMType, incomingCount); + SetResult(curId, result); } break; case BfIRCmd_AddPhiIncoming: @@ -2809,8 +3171,8 @@ void BfIRCodeGen::HandleNextCmd() { CMD_PARAM(String, intrinName); CMD_PARAM(int, intrinId); - CMD_PARAM(llvm::Type*, returnType); - CMD_PARAM(CmdParamVec, paramTypes); + CMD_PARAM(BfIRTypeEx*, returnType); + CMD_PARAM(CmdParamVec, paramTypes); llvm::Function* func = NULL; @@ -2895,13 +3257,13 @@ void BfIRCodeGen::HandleNextCmd() CmdParamVec useParams; if (intrinsics[intrinId].mArg0 != -1) { - useParams.push_back(paramTypes[0]); + useParams.push_back(paramTypes[0]->mLLVMType); if (intrinsics[intrinId].mArg1 != -1) { - useParams.push_back(paramTypes[1]); + useParams.push_back(paramTypes[1]->mLLVMType); if (intrinsics[intrinId].mArg2 != -1) { - useParams.push_back(paramTypes[2]); + useParams.push_back(paramTypes[2]->mLLVMType); } } } @@ -2941,7 +3303,7 @@ void BfIRCodeGen::HandleNextCmd() break; } - llvm::Intrinsic::ID intrin = llvm::Intrinsic::getIntrinsicForGCCBuiltin(platName.c_str(), platIntrinName.c_str()); + llvm::Intrinsic::ID intrin = llvm::Intrinsic::getIntrinsicForClangBuiltin(platName.c_str(), platIntrinName.c_str()); if ((int)intrin <= 0) FatalError(StrFormat("Unable to find intrinsic '%s'", intrinName.c_str())); else @@ -2954,28 +3316,63 @@ void BfIRCodeGen::HandleNextCmd() } mIntrinsicReverseMap[func] = intrinId; - SetResult(curId, func); + auto funcTypeEx = CreateTypeEx(func->getFunctionType()); + funcTypeEx->mMembers.Add(returnType); + for (auto typeEx : paramTypes) + funcTypeEx->mMembers.Add(typeEx); + + BfIRTypedValue result; + result.mTypeEx = GetPointerTypeEx(funcTypeEx); + result.mValue = func; + SetResult(curId, result); } break; case BfIRCmd_CreateFunctionType: { - CMD_PARAM(llvm::Type*, resultType); - CMD_PARAM(CmdParamVec, paramTypes); + CMD_PARAM(BfIRTypeEx*, resultType); + CMD_PARAM(CmdParamVec, paramTypes); CMD_PARAM(bool, isVarArg); - SetResult(curId, llvm::FunctionType::get(resultType, paramTypes, isVarArg)); + + CmdParamVec llvmTypes; + for (auto typeEx : paramTypes) + { + if (typeEx->mLLVMType->isPointerTy()) + { + BF_ASSERT(!typeEx->mMembers.IsEmpty()); + } + + llvmTypes.push_back(typeEx->mLLVMType); + } + + auto funcType = llvm::FunctionType::get(resultType->mLLVMType, llvmTypes, isVarArg); + + auto typeEx = CreateTypeEx(funcType); + if (typeEx->mMembers.IsEmpty()) + { + typeEx->mMembers.Add(resultType); + for (auto paramType : paramTypes) + typeEx->mMembers.Add(paramType); + } + + SetResult(curId, typeEx); } break; case BfIRCmd_CreateFunction: { - CMD_PARAM(llvm::FunctionType*, type); + BfIRTypeEx* type = NULL; + ReadFunctionType(type); + BfIRLinkageType linkageType = (BfIRLinkageType)mStream->Read(); CMD_PARAM(String, name); - auto func = mLLVMModule->getFunction(name.c_str()); - if ((func == NULL) || (func->getFunctionType() != type)) - func = llvm::Function::Create(type, LLVMMapLinkageType(linkageType), name.c_str(), mLLVMModule); + BfIRTypedValue result; + result.mTypeEx = GetPointerTypeEx(type); - SetResult(curId, func); + auto func = mLLVMModule->getFunction(name.c_str()); + if ((func == NULL) || (func->getFunctionType() != type->mLLVMType)) + func = llvm::Function::Create((llvm::FunctionType*)type->mLLVMType, LLVMMapLinkageType(linkageType), name.c_str(), mLLVMModule); + result.mValue = func; + SetResult(curId, result); } break; case BfIRCmd_SetFunctionName: @@ -2995,7 +3392,7 @@ void BfIRCodeGen::HandleNextCmd() if (guessInstBytes < 5) { - for (auto& block : mActiveFunction->getBasicBlockList()) + for (auto& block : *mActiveFunction) { for (auto& inst : block) { @@ -3030,12 +3427,12 @@ void BfIRCodeGen::HandleNextCmd() break; case BfIRCmd_RemapBindFunction: { - CMD_PARAM(llvm::Value*, func); + CMD_PARAM(BfIRTypedValue, func); // We need to store this value to a data segment so we get a symbol we can remap during hot swap // We actually do this to ensure that we don't bind to the NEW method but rather the old one- so // delegate equality checks still work - llvm::Function* llvmFunc = llvm::dyn_cast(func); + llvm::Function* llvmFunc = llvm::dyn_cast(func.mValue); if (llvmFunc != NULL) { @@ -3046,10 +3443,13 @@ void BfIRCodeGen::HandleNextCmd() llvm::GlobalVariable* globalVariable = mLLVMModule->getGlobalVariable(funcName.c_str()); if (globalVariable == NULL) { - globalVariable = new llvm::GlobalVariable(*mLLVMModule, func->getType(), true, llvm::GlobalValue::ExternalLinkage, (llvm::Constant*)func, funcName.c_str()); + globalVariable = new llvm::GlobalVariable(*mLLVMModule, llvmFunc->getType(), true, llvm::GlobalValue::ExternalLinkage, (llvm::Constant*)llvmFunc, funcName.c_str()); } - SetResult(curId, mIRBuilder->CreateLoad(globalVariable)); + BfIRTypedValue result; + result.mTypeEx = func.mTypeEx; + result.mValue = mIRBuilder->CreateLoad(result.mTypeEx->mLLVMType, globalVariable); + SetResult(curId, result); } else SetResult(curId, func); @@ -3057,18 +3457,23 @@ void BfIRCodeGen::HandleNextCmd() break; case BfIRCmd_SetActiveFunction: { - CMD_PARAM(llvm::Function*, func); - mActiveFunction = func; + BfIRTypedValue func; + ReadFunction(func); + mActiveFunction = (llvm::Function*)func.mValue; + if (mActiveFunction == NULL) + mActiveFunctionType = NULL; + else + mActiveFunctionType = GetTypeMember(func.mTypeEx, 0); } break; case BfIRCmd_CreateCall: { - llvm::Value* func = NULL; + BfIRTypedValue func; BfIRCodeGenEntry* codeGenEntry = NULL; Read(func, &codeGenEntry); - CMD_PARAM(CmdParamVec, args); + CMD_PARAM(CmdParamVec, args); - if ((func == NULL) && (codeGenEntry != NULL) && (codeGenEntry->mKind == BfIRCodeGenEntryKind_IntrinsicData)) + if ((func.mValue == NULL) && (codeGenEntry != NULL) && (codeGenEntry->mKind == BfIRCodeGenEntryKind_IntrinsicData)) { auto intrinsicData = codeGenEntry->mIntrinsicData; @@ -3083,7 +3488,7 @@ void BfIRCodeGen::HandleNextCmd() for (int i = 0; i < 2; i++) { - if (const llvm::ConstantExpr* ce = llvm::dyn_cast(args[i])) + if (const llvm::ConstantExpr* ce = llvm::dyn_cast(args[i].mValue)) { llvm::Value* firstOperand = ce->getOperand(0); if (llvm::GlobalVariable* gv = llvm::dyn_cast(firstOperand)) @@ -3164,21 +3569,21 @@ void BfIRCodeGen::HandleNextCmd() val1 = mIRBuilder->CreateInsertElement(val1, val, (uint64)2); val1 = mIRBuilder->CreateInsertElement(val1, val, (uint64)3); } - else if (args[1]->getType()->isPointerTy()) + else if (args[1].mValue->getType()->isPointerTy()) { - auto ptrVal1 = mIRBuilder->CreateBitCast(args[1], vecType->getPointerTo()); - val1 = mIRBuilder->CreateAlignedLoad(ptrVal1, llvm::MaybeAlign(1)); + auto ptrVal1 = mIRBuilder->CreateBitCast(args[1].mValue, vecType->getPointerTo()); + val1 = mIRBuilder->CreateAlignedLoad(vecType, ptrVal1, llvm::MaybeAlign(1)); } - else if (args[1]->getType()->isVectorTy()) + else if (args[1].mValue->getType()->isVectorTy()) { - val1 = args[1]; + val1 = args[1].mValue; } else { - val1 = mIRBuilder->CreateInsertElement(llvm::UndefValue::get(vecType), args[1], (uint64)0); - val1 = mIRBuilder->CreateInsertElement(val1, args[1], (uint64)1); - val1 = mIRBuilder->CreateInsertElement(val1, args[1], (uint64)2); - val1 = mIRBuilder->CreateInsertElement(val1, args[1], (uint64)3); + val1 = mIRBuilder->CreateInsertElement(llvm::UndefValue::get(vecType), args[1].mValue, (uint64)0); + val1 = mIRBuilder->CreateInsertElement(val1, args[1].mValue, (uint64)1); + val1 = mIRBuilder->CreateInsertElement(val1, args[1].mValue, (uint64)2); + val1 = mIRBuilder->CreateInsertElement(val1, args[1].mValue, (uint64)3); } if (isFP) @@ -3309,22 +3714,23 @@ void BfIRCodeGen::HandleNextCmd() } } } - else if (auto ptrType = llvm::dyn_cast(args[1]->getType())) + else if (auto ptrType = llvm::dyn_cast(args[1].mTypeEx->mLLVMType)) { - auto ptrElemType = ptrType->getElementType(); + //auto ptrElemType = ptrType->getElementType(); + auto ptrElemType = GetLLVMPointerElementType(args[1].mTypeEx); if (auto arrType = llvm::dyn_cast(ptrElemType)) { auto vecType = llvm::FixedVectorType::get(arrType->getArrayElementType(), (uint)arrType->getArrayNumElements()); auto vecPtrType = vecType->getPointerTo(); llvm::Value* val0; - val0 = mIRBuilder->CreateInsertElement(llvm::UndefValue::get(vecType), args[0], (uint64)0); - val0 = mIRBuilder->CreateInsertElement(val0, args[0], (uint64)1); - val0 = mIRBuilder->CreateInsertElement(val0, args[0], (uint64)2); - val0 = mIRBuilder->CreateInsertElement(val0, args[0], (uint64)3); + val0 = mIRBuilder->CreateInsertElement(llvm::UndefValue::get(vecType), args[0].mValue, (uint64)0); + val0 = mIRBuilder->CreateInsertElement(val0, args[0].mValue, (uint64)1); + val0 = mIRBuilder->CreateInsertElement(val0, args[0].mValue, (uint64)2); + val0 = mIRBuilder->CreateInsertElement(val0, args[0].mValue, (uint64)3); - auto ptrVal1 = mIRBuilder->CreateBitCast(args[1], vecPtrType); - auto val1 = mIRBuilder->CreateAlignedLoad(ptrVal1, llvm::MaybeAlign(1)); + auto ptrVal1 = mIRBuilder->CreateBitCast(args[1].mValue, vecPtrType); + auto val1 = mIRBuilder->CreateAlignedLoad(vecType, ptrVal1, llvm::MaybeAlign(1)); switch (intrinsicData->mIntrinsic) { @@ -3435,16 +3841,16 @@ void BfIRCodeGen::HandleNextCmd() llvm::Type* elemType = llvm::Type::getInt32Ty(*mLLVMContext); // Check argument errors - if (args.size() != 6 || !args[0]->getType()->isIntegerTy(32) || !args[1]->getType()->isIntegerTy(32)) + if (args.size() != 6 || !args[0].mValue->getType()->isIntegerTy(32) || !args[1].mValue->getType()->isIntegerTy(32)) FatalError("Intrinsic argument error"); - for (int i = 2; i < 6; i++) - { - llvm::Type* type = args[i]->getType(); - - if (!type->isPointerTy() || !type->getPointerElementType()->isIntegerTy(32)) - FatalError("Intrinsic argument error"); - } +// for (int i = 2; i < 6; i++) +// { +// llvm::Type* type = args[i]->getType(); +// +// if (!type->isPointerTy() || !GetPointerElementType(args[1])->isIntegerTy(32)) +// FatalError("Intrinsic argument error"); +// } // Get asm return type llvm::SmallVector asmReturnTypes; @@ -3465,25 +3871,25 @@ void BfIRCodeGen::HandleNextCmd() // Call asm function llvm::SmallVector funcArgs; - funcArgs.push_back(args[0]); - funcArgs.push_back(args[1]); + funcArgs.push_back(args[0].mValue); + funcArgs.push_back(args[1].mValue); llvm::Value* asmResult = mIRBuilder->CreateCall(func, funcArgs); // Store results - mIRBuilder->CreateStore(mIRBuilder->CreateExtractValue(asmResult, 0), args[2]); - mIRBuilder->CreateStore(mIRBuilder->CreateExtractValue(asmResult, 1), args[3]); - mIRBuilder->CreateStore(mIRBuilder->CreateExtractValue(asmResult, 2), args[4]); - mIRBuilder->CreateStore(mIRBuilder->CreateExtractValue(asmResult, 3), args[5]); + mIRBuilder->CreateStore(mIRBuilder->CreateExtractValue(asmResult, 0), args[2].mValue); + mIRBuilder->CreateStore(mIRBuilder->CreateExtractValue(asmResult, 1), args[3].mValue); + mIRBuilder->CreateStore(mIRBuilder->CreateExtractValue(asmResult, 2), args[4].mValue); + mIRBuilder->CreateStore(mIRBuilder->CreateExtractValue(asmResult, 3), args[5].mValue); } break; case BfIRIntrinsic_Xgetbv: { - if (args.size() != 1 || !args[0]->getType()->isIntegerTy(32)) + if (args.size() != 1 || !args[0].mValue->getType()->isIntegerTy(32)) FatalError("Intrinsic argument error"); auto func = mLLVMModule->getOrInsertFunction("llvm.x86.xgetbv", llvm::Type::getInt64Ty(*mLLVMContext), llvm::Type::getInt32Ty(*mLLVMContext)); - SetResult(curId, mIRBuilder->CreateCall(func, args[0])); + SetResult(curId, mIRBuilder->CreateCall(func, args[0].mValue)); } break; case BfIRIntrinsic_Not: @@ -3514,12 +3920,17 @@ void BfIRCodeGen::HandleNextCmd() { llvm::Value* gepArgs[] = { llvm::ConstantInt::get(llvm::Type::getInt32Ty(*mLLVMContext), 0), - args[1] }; - auto gep = mIRBuilder->CreateInBoundsGEP(args[0], llvm::makeArrayRef(gepArgs)); + args[1].mValue }; + auto gep = mIRBuilder->CreateInBoundsGEP(GetLLVMPointerElementType(args[0].mTypeEx), args[0].mValue, llvm::makeArrayRef(gepArgs)); if (args.size() >= 3) - mIRBuilder->CreateStore(args[2], gep); + mIRBuilder->CreateStore(args[2].mValue, gep); else - SetResult(curId, mIRBuilder->CreateLoad(gep)); + { + BfIRTypedValue result; + result.mTypeEx = GetTypeMember(args[0].mTypeEx, 0); + result.mValue = mIRBuilder->CreateLoad(result.mTypeEx->mLLVMType, gep); + SetResult(curId, result); + } } break; @@ -3527,7 +3938,7 @@ void BfIRCodeGen::HandleNextCmd() case BfIRIntrinsic_AtomicCmpStore_Weak: case BfIRIntrinsic_AtomicCmpXChg: { - auto memoryKindConst = llvm::dyn_cast(args[3]); + auto memoryKindConst = llvm::dyn_cast(args[3].mValue); if (memoryKindConst == NULL) { FatalError("Non-constant success ordering on Atomic_CmpXChg"); @@ -3566,7 +3977,7 @@ void BfIRCodeGen::HandleNextCmd() if (args.size() >= 5) { - auto memoryKindConst = llvm::dyn_cast(args[4]); + auto memoryKindConst = llvm::dyn_cast(args[4].mValue); if (memoryKindConst == NULL) { FatalError("Non-constant fail ordering on Atomic_CmpXChg"); @@ -3590,7 +4001,7 @@ void BfIRCodeGen::HandleNextCmd() } } - auto inst = mIRBuilder->CreateAtomicCmpXchg(args[0], args[1], args[2], llvm::MaybeAlign(), successOrdering, failOrdering); + auto inst = mIRBuilder->CreateAtomicCmpXchg(args[0].mValue, args[1].mValue, args[2].mValue, llvm::MaybeAlign(), successOrdering, failOrdering); if (intrinsicData->mIntrinsic == BfIRIntrinsic_AtomicCmpStore_Weak) inst->setWeak(true); if ((memoryKind & BfIRAtomicOrdering_Volatile) != 0) @@ -3628,7 +4039,7 @@ void BfIRCodeGen::HandleNextCmd() break; } - auto memoryKindConst = llvm::dyn_cast(args[0]); + auto memoryKindConst = llvm::dyn_cast(args[0].mValue); if (memoryKindConst == NULL) { FatalError("Non-constant success ordering on AtomicFence"); @@ -3661,15 +4072,19 @@ void BfIRCodeGen::HandleNextCmd() break; case BfIRIntrinsic_AtomicLoad: { - auto memoryKindConst = llvm::dyn_cast(args[1]); + auto memoryKindConst = llvm::dyn_cast(args[1].mValue); if (memoryKindConst == NULL) { FatalError("Non-constant success ordering on AtomicLoad"); break; } + + BfIRTypedValue result; + result.mTypeEx = GetTypeMember(args[0].mTypeEx, 0); + auto memoryKind = (BfIRAtomicOrdering)memoryKindConst->getSExtValue(); - auto ptrType = llvm::dyn_cast(args[0]->getType()); - auto loadInst = mIRBuilder->CreateAlignedLoad(args[0], llvm::MaybeAlign((uint)ptrType->getElementType()->getPrimitiveSizeInBits() / 8)); + auto ptrType = llvm::dyn_cast(args[0].mValue->getType()); + auto loadInst = mIRBuilder->CreateAlignedLoad(result.mTypeEx->mLLVMType, args[0].mValue, llvm::MaybeAlign((uint)GetLLVMPointerElementType(args[0].mTypeEx)->getPrimitiveSizeInBits() / 8)); switch (memoryKind & BfIRAtomicOrdering_ORDERMASK) { case BfIRAtomicOrdering_Acquire: @@ -3686,12 +4101,14 @@ void BfIRCodeGen::HandleNextCmd() } if ((memoryKind & BfIRAtomicOrdering_Volatile) != 0) loadInst->setVolatile(true); - SetResult(curId, loadInst); + result.mValue = loadInst; + + SetResult(curId, result); } break; case BfIRIntrinsic_AtomicStore: { - auto memoryKindConst = llvm::dyn_cast(args[2]); + auto memoryKindConst = llvm::dyn_cast(args[2].mValue); if (memoryKindConst == NULL) { FatalError("Non-constant success ordering on AtomicLoad"); @@ -3699,7 +4116,7 @@ void BfIRCodeGen::HandleNextCmd() } auto memoryKind = (BfIRAtomicOrdering)memoryKindConst->getSExtValue(); - auto storeInst = mIRBuilder->CreateAlignedStore(args[1], args[0], llvm::MaybeAlign((uint)args[1]->getType()->getPrimitiveSizeInBits() / 8)); + auto storeInst = mIRBuilder->CreateAlignedStore(args[1].mValue, args[0].mValue, llvm::MaybeAlign((uint)args[1].mValue->getType()->getPrimitiveSizeInBits() / 8)); switch (memoryKind & BfIRAtomicOrdering_ORDERMASK) { case BfIRAtomicOrdering_Relaxed: @@ -3729,7 +4146,7 @@ void BfIRCodeGen::HandleNextCmd() case BfIRIntrinsic_AtomicXChg: case BfIRIntrinsic_AtomicXor: { - bool isFloat = args[1]->getType()->isFloatingPointTy(); + bool isFloat = args[1].mValue->getType()->isFloatingPointTy(); auto op = llvm::AtomicRMWInst::BinOp::Add; switch (intrinsicData->mIntrinsic) @@ -3770,7 +4187,7 @@ void BfIRCodeGen::HandleNextCmd() default: break; } - auto memoryKindConst = llvm::dyn_cast(args[2]); + auto memoryKindConst = llvm::dyn_cast(args[2].mValue); if (memoryKindConst == NULL) { FatalError("Non-constant ordering on atomic operation"); @@ -3801,7 +4218,7 @@ void BfIRCodeGen::HandleNextCmd() break; } - auto atomicRMW = mIRBuilder->CreateAtomicRMW(op, args[0], args[1], llvm::MaybeAlign(), ordering); + auto atomicRMW = mIRBuilder->CreateAtomicRMW(op, args[0].mValue, args[1].mValue, llvm::MaybeAlign(), ordering); if ((memoryKind & BfIRAtomicOrdering_Volatile) != 0) atomicRMW->setVolatile(true); llvm::Value* result = atomicRMW; @@ -3811,12 +4228,12 @@ void BfIRCodeGen::HandleNextCmd() { case BfIRIntrinsic_AtomicAdd: if (isFloat) - result = mIRBuilder->CreateFAdd(atomicRMW, args[1]); + result = mIRBuilder->CreateFAdd(atomicRMW, args[1].mValue); else - result = mIRBuilder->CreateAdd(atomicRMW, args[1]); + result = mIRBuilder->CreateAdd(atomicRMW, args[1].mValue); break; case BfIRIntrinsic_AtomicAnd: - result = mIRBuilder->CreateAnd(atomicRMW, args[1]); + result = mIRBuilder->CreateAnd(atomicRMW, args[1].mValue); break; case BfIRIntrinsic_AtomicMax: case BfIRIntrinsic_AtomicMin: @@ -3828,45 +4245,45 @@ void BfIRCodeGen::HandleNextCmd() { case BfIRIntrinsic_AtomicMax: if (isFloat) - cmpVal = mIRBuilder->CreateFCmpOGE(atomicRMW, args[1]); + cmpVal = mIRBuilder->CreateFCmpOGE(atomicRMW, args[1].mValue); else - cmpVal = mIRBuilder->CreateICmpSGE(atomicRMW, args[1]); + cmpVal = mIRBuilder->CreateICmpSGE(atomicRMW, args[1].mValue); break; case BfIRIntrinsic_AtomicMin: if (isFloat) - cmpVal = mIRBuilder->CreateFCmpOLE(atomicRMW, args[1]); + cmpVal = mIRBuilder->CreateFCmpOLE(atomicRMW, args[1].mValue); else - cmpVal = mIRBuilder->CreateICmpSLE(atomicRMW, args[1]); + cmpVal = mIRBuilder->CreateICmpSLE(atomicRMW, args[1].mValue); break; case BfIRIntrinsic_AtomicUMax: - cmpVal = mIRBuilder->CreateICmpUGE(atomicRMW, args[1]); + cmpVal = mIRBuilder->CreateICmpUGE(atomicRMW, args[1].mValue); break; case BfIRIntrinsic_AtomicUMin: - cmpVal = mIRBuilder->CreateICmpULE(atomicRMW, args[1]); + cmpVal = mIRBuilder->CreateICmpULE(atomicRMW, args[1].mValue); break; default: break; } - result = mIRBuilder->CreateSelect(cmpVal, atomicRMW, args[1]); + result = mIRBuilder->CreateSelect(cmpVal, atomicRMW, args[1].mValue); } break; case BfIRIntrinsic_AtomicNAnd: - result = mIRBuilder->CreateAnd(atomicRMW, args[1]); + result = mIRBuilder->CreateAnd(atomicRMW, args[1].mValue); result = mIRBuilder->CreateNot(result); break; case BfIRIntrinsic_AtomicOr: - result = mIRBuilder->CreateOr(atomicRMW, args[1]); + result = mIRBuilder->CreateOr(atomicRMW, args[1].mValue); break; case BfIRIntrinsic_AtomicSub: if (isFloat) - result = mIRBuilder->CreateFSub(atomicRMW, args[1]); + result = mIRBuilder->CreateFSub(atomicRMW, args[1].mValue); else - result = mIRBuilder->CreateSub(atomicRMW, args[1]); + result = mIRBuilder->CreateSub(atomicRMW, args[1].mValue); break; case BfIRIntrinsic_AtomicXor: - result = mIRBuilder->CreateXor(atomicRMW, args[1]); + result = mIRBuilder->CreateXor(atomicRMW, args[1].mValue); break; case BfIRIntrinsic_AtomicXChg: - result = args[1]; + result = args[1].mValue; break; default: break; } @@ -3876,34 +4293,39 @@ void BfIRCodeGen::HandleNextCmd() break; case BfIRIntrinsic_Cast: { - auto arg0Type = args[0]->getType(); + BfIRTypedValue result; + result.mTypeEx = intrinsicData->mReturnType; + + auto arg0Type = args[0].mValue->getType(); if (arg0Type->isPointerTy()) { - if (intrinsicData->mReturnType->isPointerTy()) + if (intrinsicData->mReturnType->mLLVMType->isPointerTy()) { - SetResult(curId, mIRBuilder->CreateBitCast(args[0], intrinsicData->mReturnType)); + result.mValue = mIRBuilder->CreateBitCast(args[0].mValue, intrinsicData->mReturnType->mLLVMType); } else { - auto castedRes = mIRBuilder->CreateBitCast(args[0], intrinsicData->mReturnType->getPointerTo()); - SetResult(curId, mIRBuilder->CreateAlignedLoad(castedRes, llvm::MaybeAlign(1))); + auto castedRes = mIRBuilder->CreateBitCast(args[0].mValue, intrinsicData->mReturnType->mLLVMType->getPointerTo()); + result.mValue = mIRBuilder->CreateAlignedLoad(intrinsicData->mReturnType->mLLVMType, castedRes, llvm::MaybeAlign(1)); } } - else if ((arg0Type->isVectorTy()) && (intrinsicData->mReturnType->isVectorTy())) + else if ((arg0Type->isVectorTy()) && (intrinsicData->mReturnType->mLLVMType->isVectorTy())) { - SetResult(curId, mIRBuilder->CreateBitCast(args[0], intrinsicData->mReturnType)); + result.mValue = mIRBuilder->CreateBitCast(args[0].mValue, intrinsicData->mReturnType->mLLVMType); } else FatalError("Invalid cast intrinsic values"); + + SetResult(curId, result); } break; case BfIRIntrinsic_VAArg: { - auto constInt = llvm::dyn_cast(args[2]); + auto constInt = llvm::dyn_cast(args[2].mValue); auto argType = GetLLVMTypeById((int)constInt->getSExtValue()); - auto vaArgVal = mIRBuilder->CreateVAArg(args[0], argType); + auto vaArgVal = mIRBuilder->CreateVAArg(args[0].mValue, argType); - auto resultPtr = mIRBuilder->CreateBitCast(args[1], argType->getPointerTo()); + auto resultPtr = mIRBuilder->CreateBitCast(args[1].mValue, argType->getPointerTo()); mIRBuilder->CreateStore(vaArgVal, resultPtr); } break; @@ -3913,7 +4335,7 @@ void BfIRCodeGen::HandleNextCmd() break; } - if (auto funcPtr = llvm::dyn_cast(func)) + if (auto funcPtr = llvm::dyn_cast(func.mValue)) { // if (funcPtr->getName() == "__FAILCALL") // { @@ -3928,14 +4350,14 @@ void BfIRCodeGen::HandleNextCmd() int align = 1; BF_ASSERT(args.size() == 5); - auto alignConst = llvm::dyn_cast(args[3]); + auto alignConst = llvm::dyn_cast(args[3].mValue); if (alignConst != NULL) align = (int)alignConst->getSExtValue(); bool isVolatile = false; - auto volatileConst = llvm::dyn_cast(args[4]); + auto volatileConst = llvm::dyn_cast(args[4].mValue); if ((volatileConst != NULL) && (volatileConst->getSExtValue() != 0)) isVolatile = true; - CreateMemSet(args[0], args[1], args[2], align, isVolatile); + CreateMemSet(args[0].mValue, args[1].mValue, args[2].mValue, align, isVolatile); break; } else if ((intrinId == BfIRIntrinsic_MemCpy) || (intrinId == BfIRIntrinsic_MemMove)) @@ -3943,17 +4365,17 @@ void BfIRCodeGen::HandleNextCmd() int align = 1; BF_ASSERT(args.size() == 5); - auto alignConst = llvm::dyn_cast(args[3]); + auto alignConst = llvm::dyn_cast(args[3].mValue); if (alignConst != NULL) align = (int)alignConst->getSExtValue(); bool isVolatile = false; - auto volatileConst = llvm::dyn_cast(args[4]); + auto volatileConst = llvm::dyn_cast(args[4].mValue); if ((volatileConst != NULL) && (volatileConst->getSExtValue() != 0)) isVolatile = true; if (intrinId == BfIRIntrinsic_MemCpy) - mIRBuilder->CreateMemCpy(args[0], llvm::MaybeAlign(align), args[1], llvm::MaybeAlign(align), args[2], isVolatile); + mIRBuilder->CreateMemCpy(args[0].mValue, llvm::MaybeAlign(align), args[1].mValue, llvm::MaybeAlign(align), args[2].mValue, isVolatile); else - mIRBuilder->CreateMemMove(args[0], llvm::MaybeAlign(align), args[1], llvm::MaybeAlign(align), args[2], isVolatile); + mIRBuilder->CreateMemMove(args[0].mValue, llvm::MaybeAlign(align), args[1].mValue, llvm::MaybeAlign(align), args[2].mValue, isVolatile); break; } } @@ -3963,17 +4385,31 @@ void BfIRCodeGen::HandleNextCmd() llvm::Value* val1 = NULL; if (args.size() > 0) { - val0 = args[0]; + val0 = args[0].mValue; } if (args.size() > 1) { - val1 = args[1]; + val1 = args[1].mValue; } llvm::FunctionType* funcType = NULL; - if (auto ptrType = llvm::dyn_cast(func->getType())) - funcType = llvm::dyn_cast(ptrType->getElementType()); - SetResult(curId, mIRBuilder->CreateCall(funcType, func, args)); + if (auto ptrType = llvm::dyn_cast(func.mValue->getType())) + funcType = llvm::dyn_cast(GetLLVMPointerElementType(func.mTypeEx)); + + CmdParamVec llvmArgs; + for (auto& arg : args) + llvmArgs.push_back(arg.mValue); + + auto funcTypeEx = GetTypeMember(func.mTypeEx, 0); + auto returnTypeEx = GetTypeMember(funcTypeEx, 0); + + BfIRTypedValue result; + result.mTypeEx = returnTypeEx; + result.mValue = mIRBuilder->CreateCall(funcType, func.mValue, llvmArgs); + SetResult(curId, result); + + mLastFuncCalled.mValue = result.mValue; + mLastFuncCalled.mTypeEx = funcTypeEx; } break; case BfIRCmd_SetCallCallingConv: @@ -4007,7 +4443,7 @@ void BfIRCodeGen::HandleNextCmd() llvm::Attribute::AttrKind attr = llvm::Attribute::None; if (attribute == BfIRAttribute_NoReturn) attr = llvm::Attribute::NoReturn; - ((llvm::CallInst*)callInst)->addAttribute(paramIdx, attr); + ((llvm::CallInst*)callInst)->addParamAttr(paramIdx, attr); } break; case BfIRCmd_CreateRet: @@ -4028,51 +4464,73 @@ void BfIRCodeGen::HandleNextCmd() break; case BfIRCmd_Call_AddAttribute: { - CMD_PARAM(llvm::Value*, callInst); + CMD_PARAM(BfIRTypedValue, inst); CMD_PARAM(int, argIdx); - BfIRAttribute attribute = (BfIRAttribute)mStream->Read(); - BF_ASSERT(llvm::isa(callInst)); + + BF_ASSERT(inst.mValue == mLastFuncCalled.mValue); + + BfIRAttribute attribute = (BfIRAttribute)mStream->Read(); auto attr = LLVMMapAttribute(attribute); + auto callInst = llvm::dyn_cast(inst.mValue); + BfIRTypeEx* funcType = mLastFuncCalled.mTypeEx; + if (attr == llvm::Attribute::StructRet) { - auto funcType = ((llvm::CallInst*)callInst)->getFunctionType(); - llvm::Attribute sret = llvm::Attribute::getWithStructRetType(*mLLVMContext, funcType->getFunctionParamType(argIdx - 1)->getPointerElementType()); - ((llvm::CallInst*)callInst)->addAttribute(argIdx, sret); + auto elemPtrType = GetTypeMember(funcType, argIdx); + auto elemType = GetTypeMember(elemPtrType, 0); + llvm::Attribute sret = llvm::Attribute::getWithStructRetType(*mLLVMContext, elemType->mLLVMType); + ((llvm::CallInst*)callInst)->addParamAttr(argIdx - 1, sret); } else { - ((llvm::CallInst*)callInst)->addAttribute(argIdx, attr); + if (argIdx == -1) + ((llvm::CallInst*)callInst)->addFnAttr(attr); + else if (argIdx == 0) + ((llvm::CallInst*)callInst)->addRetAttr(attr); + else + ((llvm::CallInst*)callInst)->addParamAttr(argIdx - 1, attr); } } break; case BfIRCmd_Call_AddAttribute1: { - CMD_PARAM(llvm::Value*, inst); + CMD_PARAM(BfIRTypedValue, inst); CMD_PARAM(int, argIdx); BfIRAttribute attribute = (BfIRAttribute)mStream->Read(); CMD_PARAM(int, arg); - auto callInst = llvm::dyn_cast(inst); + + BF_ASSERT(inst.mValue == mLastFuncCalled.mValue); + + auto callInst = llvm::dyn_cast(inst.mValue); if (callInst != NULL) { + BfIRTypeEx* funcType = mLastFuncCalled.mTypeEx; + if (attribute == BfIRAttribute_Dereferencable) - { - ((llvm::CallInst*)callInst)->addDereferenceableAttr(argIdx, arg); + { + ((llvm::CallInst*)callInst)->addDereferenceableParamAttr(argIdx - 1, arg); } else if (attribute == BfIRAttribute_ByVal) { - auto funcType = ((llvm::CallInst*)callInst)->getFunctionType(); - llvm::Attribute byValAttr = llvm::Attribute::getWithByValType(*mLLVMContext, funcType->getFunctionParamType(argIdx - 1)->getPointerElementType()); + auto elemPtrType = GetTypeMember(funcType, argIdx); + auto elemType = GetTypeMember(elemPtrType, 0); + llvm::Attribute byValAttr = llvm::Attribute::getWithByValType(*mLLVMContext, elemType->mLLVMType); llvm::Attribute alignAttr = llvm::Attribute::getWithAlignment(*mLLVMContext, llvm::Align(arg)); - ((llvm::CallInst*)callInst)->addAttribute(argIdx, byValAttr); - ((llvm::CallInst*)callInst)->addAttribute(argIdx, alignAttr); + ((llvm::CallInst*)callInst)->addParamAttr(argIdx - 1, byValAttr); + ((llvm::CallInst*)callInst)->addParamAttr(argIdx - 1, alignAttr); } } } break; case BfIRCmd_Func_AddAttribute: { - CMD_PARAM(llvm::Function*, func); - CMD_PARAM(int, argIdx); + BfIRTypedValue typedValue; + ReadFunction(typedValue); + CMD_PARAM(int, argIdx); + + auto func = llvm::dyn_cast(typedValue.mValue); + auto funcType = GetTypeMember(typedValue.mTypeEx, 0); + BfIRAttribute attribute = (BfIRAttribute)mStream->Read(); if (attribute == BFIRAttribute_DllImport) { @@ -4092,13 +4550,13 @@ void BfIRCodeGen::HandleNextCmd() CmdParamVec members; members.push_back(llvm::Type::getInt32Ty(*mLLVMContext)); members.push_back(func->getType()); - members.push_back(llvm::Type::getInt8PtrTy(*mLLVMContext)); + members.push_back(llvm::PointerType::get(*mLLVMContext, 0)); llvm::StructType* structType = llvm::StructType::get(*mLLVMContext, members); CmdParamVec structVals; structVals.push_back(llvm::ConstantInt::get(llvm::Type::getInt32Ty(*mLLVMContext), 0x7FFFFF00)); structVals.push_back(func); - structVals.push_back(llvm::ConstantPointerNull::get(llvm::Type::getInt8PtrTy(*mLLVMContext))); + structVals.push_back(llvm::ConstantPointerNull::get(llvm::PointerType::get(*mLLVMContext, 0))); auto constStruct = llvm::ConstantStruct::get(structType, structVals); CmdParamVec structArrVals; @@ -4120,33 +4578,62 @@ void BfIRCodeGen::HandleNextCmd() { auto attr = LLVMMapAttribute(attribute); if (attr == llvm::Attribute::StructRet) - { - auto funcType = func->getFunctionType(); - llvm::Attribute sret = llvm::Attribute::getWithStructRetType(*mLLVMContext, funcType->getFunctionParamType(argIdx - 1)->getPointerElementType()); - func->addAttribute(argIdx, sret); + { + auto elemPtrType = GetTypeMember(funcType, argIdx); + auto elemType = GetTypeMember(elemPtrType, 0); + llvm::Attribute sret = llvm::Attribute::getWithStructRetType(*mLLVMContext, elemType->mLLVMType); + func->addParamAttr(argIdx - 1, sret); } else if (attr != llvm::Attribute::None) - func->addAttribute(argIdx, attr); + { + if (argIdx < 0) + { + switch (attr) + { + case llvm::Attribute::UWTable: + { + llvm::AttrBuilder attrBuilder(*mLLVMContext); + attrBuilder.addUWTableAttr(llvm::UWTableKind::Default); + func->addFnAttrs(attrBuilder); + } + break; + default: + func->addFnAttr(attr); + } + } + else if (argIdx == 0) + func->addRetAttr(attr); + else + func->addParamAttr(argIdx - 1, attr); + } } } break; case BfIRCmd_Func_AddAttribute1: { - CMD_PARAM(llvm::Function*, func); + BfIRTypedValue typedValue; + ReadFunction(typedValue); CMD_PARAM(int, argIdx); + + auto func = llvm::dyn_cast(typedValue.mValue); + auto funcType = GetTypeMember(typedValue.mTypeEx, 0); + BfIRAttribute attribute = (BfIRAttribute)mStream->Read(); CMD_PARAM(int, arg); if (attribute == BfIRAttribute_Dereferencable) { - ((llvm::Function*)func)->addDereferenceableAttr(argIdx, arg); + ((llvm::Function*)func)->addDereferenceableParamAttr(argIdx - 1, arg); } else if (attribute == BfIRAttribute_ByVal) { + auto elemPtrType = GetTypeMember(funcType, argIdx); + auto elemType = GetTypeMember(elemPtrType, 0); + auto funcType = func->getFunctionType(); - llvm::Attribute byValAttr = llvm::Attribute::getWithByValType(*mLLVMContext, funcType->getFunctionParamType(argIdx - 1)->getPointerElementType()); + llvm::Attribute byValAttr = llvm::Attribute::getWithByValType(*mLLVMContext, elemType->mLLVMType); llvm::Attribute alignAttr = llvm::Attribute::getWithAlignment(*mLLVMContext, llvm::Align(arg)); - func->addAttribute(argIdx, byValAttr); - func->addAttribute(argIdx, alignAttr); + func->addParamAttr(argIdx - 1, byValAttr); + func->addParamAttr(argIdx - 1, alignAttr); } } break; @@ -4228,10 +4715,9 @@ void BfIRCodeGen::HandleNextCmd() llvm::BasicBlock* bb = mIRBuilder->GetInsertBlock(); if (bb != NULL) { - auto& instList = bb->getInstList(); - if (!instList.empty()) + if (!bb->empty()) { - auto& inst = instList.back(); + auto& inst = bb->back(); inst.setDebugLoc(llvm::DebugLoc()); } } @@ -4252,6 +4738,7 @@ void BfIRCodeGen::HandleNextCmd() CMD_PARAM(llvm::MDNode*, diInlinedAt); if (line == 0) column = 0; + mCurLine = line; mDebugLoc = llvm::DILocation::get(*mLLVMContext, line, column, diScope, diInlinedAt); } break; @@ -4281,7 +4768,7 @@ void BfIRCodeGen::HandleNextCmd() // 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 int8Ptr = irBuilder->CreateBitCast(val, int8Ty->getPointerTo()); - auto int8Val = irBuilder->CreateLoad(int8Ptr); + auto int8Val = irBuilder->CreateLoad(int8Ty, int8Ptr); auto cmpResult = irBuilder->CreateICmpUGE(int8Val, llvm::ConstantInt::get(int8Ty, 0x80)); auto failBB = llvm::BasicBlock::Create(*mLLVMContext, "access.fail"); @@ -4289,22 +4776,22 @@ void BfIRCodeGen::HandleNextCmd() irBuilder->CreateCondBr(cmpResult, failBB, passBB); - curLLVMFunc->getBasicBlockList().push_back(failBB); + curLLVMFunc->insert(curLLVMFunc->end(), failBB); irBuilder->SetInsertPoint(failBB); auto trapDecl = llvm::Intrinsic::getDeclaration(mLLVMModule, llvm::Intrinsic::trap); auto callInst = irBuilder->CreateCall(trapDecl); - callInst->addAttribute(llvm::AttributeList::FunctionIndex, llvm::Attribute::NoReturn); + callInst->addFnAttr(llvm::Attribute::NoReturn); irBuilder->CreateBr(passBB); - curLLVMFunc->getBasicBlockList().push_back(passBB); + curLLVMFunc->insert(curLLVMFunc->end(), passBB); irBuilder->SetInsertPoint(passBB); SetResult(curId, passBB); } else { - llvm::Type* voidPtrType = llvm::Type::getInt8PtrTy(*mLLVMContext); + llvm::Type* voidPtrType = llvm::PointerType::get(*mLLVMContext, 0); if (mObjectCheckAsm == NULL) { std::vector paramTypes; @@ -4326,7 +4813,7 @@ void BfIRCodeGen::HandleNextCmd() llvmArgs.push_back(mIRBuilder->CreateBitCast(val, voidPtrType)); llvm::CallInst* callInst = irBuilder->CreateCall(mObjectCheckAsm, llvmArgs); - callInst->addAttribute(llvm::AttributeList::FunctionIndex, llvm::Attribute::NoUnwind); + callInst->addFnAttr(llvm::Attribute::NoUnwind); SetResult(curId, mIRBuilder->GetInsertBlock()); } @@ -4706,7 +5193,7 @@ void BfIRCodeGen::HandleNextCmd() os << "\n"; os.flush();*/ - auto member = mDIBuilder->createStaticMemberType((llvm::DIScope*)scope, name.c_str(), (llvm::DIFile*)file, lineNumber, (llvm::DIType*)type, diFlags, val); + auto member = mDIBuilder->createStaticMemberType((llvm::DIScope*)scope, name.c_str(), (llvm::DIFile*)file, lineNumber, (llvm::DIType*)type, diFlags, val, llvm::dwarf::DW_TAG_member); SetResult(curId, member); //OutputDebugStrF("BfIRCmd_DbgStaticCreateMemberType = %p\n", member); } @@ -5070,9 +5557,24 @@ BfIRSimdType BfIRCodeGen::GetSimdTypeFromFunction(llvm::Function* function) return BfIRSimdType_None; } +BfIRTypedValue BfIRCodeGen::GetTypedValue(int id) +{ + auto& result = mResults[id]; + if (result.mKind == BfIRCodeGenEntryKind_TypedValue) + return result.mTypedValue; + BF_ASSERT(result.mKind == BfIRCodeGenEntryKind_LLVMValue); + + BfIRTypedValue typedValue; + typedValue.mTypeEx = NULL; + typedValue.mValue = result.mLLVMValue; + return typedValue; +} + llvm::Value* BfIRCodeGen::GetLLVMValue(int id) { auto& result = mResults[id]; + if (result.mKind == BfIRCodeGenEntryKind_TypedValue) + return result.mTypedValue.mValue; BF_ASSERT(result.mKind == BfIRCodeGenEntryKind_LLVMValue); return result.mLLVMValue; } @@ -5100,7 +5602,7 @@ llvm::MDNode* BfIRCodeGen::GetLLVMMetadata(int id) llvm::Type* BfIRCodeGen::GetLLVMTypeById(int id) { - return GetTypeEntry(id).mLLVMType; + return GetTypeEntry(id).mType->mLLVMType; } static int GetOptLevel(BfOptLevel optLevel) @@ -5118,20 +5620,22 @@ static int GetOptLevel(BfOptLevel optLevel) static void AddInitialAliasAnalysisPasses(llvm::legacy::PassManagerBase &PM, const BfCodeGenOptions& options) { - switch (options.mUseCFLAA) { - case BfCFLAAType_Steensgaard: - PM.add(llvm::createCFLSteensAAWrapperPass()); - break; - case BfCFLAAType_Andersen: - PM.add(llvm::createCFLAndersAAWrapperPass()); - break; - case BfCFLAAType_Both: - PM.add(llvm::createCFLSteensAAWrapperPass()); - PM.add(llvm::createCFLAndersAAWrapperPass()); - break; - default: - break; - } + + //TODO: +// switch (options.mUseCFLAA) { +// case BfCFLAAType_Steensgaard: +// PM.add(llvm::createCFLSteensAAWrapperPass()); +// break; +// case BfCFLAAType_Andersen: +// PM.add(llvm::createCFLAndersAAWrapperPass()); +// break; +// case BfCFLAAType_Both: +// PM.add(llvm::createCFLSteensAAWrapperPass()); +// PM.add(llvm::createCFLAndersAAWrapperPass()); +// break; +// default: +// break; +// } // Add TypeBasedAliasAnalysis before BasicAliasAnalysis so that // BasicAliasAnalysis wins if they disagree. This is intended to help @@ -5143,11 +5647,14 @@ static void AddInitialAliasAnalysisPasses(llvm::legacy::PassManagerBase &PM, con static void AddInstructionCombiningPass(llvm::legacy::PassManagerBase &PM, const BfCodeGenOptions& options) { bool ExpensiveCombines = GetOptLevel(options.mOptLevel) > 2; - PM.add(llvm::createInstructionCombiningPass(options.mExpensiveCombines)); + //TODO: PM.add(llvm::createInstructionCombiningPass(options.mExpensiveCombines)); } static void AddFunctionSimplificationPasses(llvm::legacy::PassManagerBase &MPM, const BfCodeGenOptions& options) { + //TODO: + + /* // Start of function pass. // Break up aggregate allocas, using SSAUpdater. MPM.add(llvm::createSROAPass()); @@ -5254,6 +5761,7 @@ static void AddFunctionSimplificationPasses(llvm::legacy::PassManagerBase &MPM, // if (options.mEnableCHR && options.mOptLevel >= 3 && // (!PGOInstrUse.empty() || !PGOSampleUse.empty())) // MPM.add(createControlHeightReductionLegacyPass()); + */ } static void PopulateModulePassManager(llvm::legacy::PassManagerBase &MPM, const BfCodeGenOptions& options) @@ -5262,6 +5770,9 @@ static void PopulateModulePassManager(llvm::legacy::PassManagerBase &MPM, const // MPM.add(createPruneEHPass()); // MPM.add(createSampleProfileLoaderPass(PGOSampleUse)); // } + + //TODO: + /* llvm::Pass* Inliner; bool prepareForLTO = false; bool prepareForThinLTO = options.mLTOType == BfLTOType_Thin; @@ -5331,7 +5842,7 @@ static void PopulateModulePassManager(llvm::legacy::PassManagerBase &MPM, const // earlier in the pass pipeline, here before globalopt. Otherwise imported // available_externally functions look unreferenced and are removed. // if (performThinLTO) -// MPM.add(llvm::createPGOIndirectCallPromotionLegacyPass(/*InLTO = */ true, +// MPM.add(llvm::createPGOIndirectCallPromotionLegacyPass(true, // !PGOSampleUse.empty())); // For SamplePGO in ThinLTO compile phase, we do not want to unroll loops @@ -5598,7 +6109,7 @@ static void PopulateModulePassManager(llvm::legacy::PassManagerBase &MPM, const MPM.add(llvm::createCanonicalizeAliasesPass()); // Rename anon globals to be able to handle them in the summary MPM.add(llvm::createNameAnonGlobalPass()); - } + }*/ } namespace @@ -5620,26 +6131,6 @@ namespace char BfPass::ID = 0; static llvm::RegisterPass sBfPass("BfPass", "Beef Pass", false, false); -// We need this wrapper to access LangOpts and CGOpts from extension functions -// that we add to the PassManagerBuilder. -class PassManagerBuilderWrapper : public llvm::PassManagerBuilder -{ -public: - /*PassManagerBuilderWrapper(const Triple &TargetTriple, - const CodeGenOptions &CGOpts, - const LangOptions &LangOpts) - : PassManagerBuilder(), TargetTriple(TargetTriple), CGOpts(CGOpts), - LangOpts(LangOpts) {} - const Triple &getTargetTriple() const { return TargetTriple; } - const CodeGenOptions &getCGOpts() const { return CGOpts; } - const LangOptions &getLangOpts() const { return LangOpts; } - -private: - const Triple &TargetTriple; - const CodeGenOptions &CGOpts; - const LangOptions &LangOpts;*/ -}; - llvm::Expected FindThinLTOModule(llvm::MemoryBufferRef MBRef) { llvm::Expected> BMsOrErr = getBitcodeModuleList(MBRef); @@ -5716,47 +6207,44 @@ bool BfIRCodeGen::WriteObjectFile(const StringImpl& outFileName) return false; } - if (enableLTO) - PM.add(createWriteThinLTOBitcodePass(*outStream, NULL)); - else - PM.add(createBitcodeWriterPass(*outStream, false, false, false)); +// if (enableLTO) +// PM.add(createWriteThinLTOBitcodePass(*outStream, NULL)); + //else + PM.add(createBitcodeWriterPass(*outStream, false)); } - //TargetPassConfig *PassConfig = target->createPassConfig(PM); - //PM.add(new BfPass()); - //PM.add(sBfPass); +// TargetPassConfig *PassConfig = target->createPassConfig(PM); +// PM.add(new BfPass()); +// PM.add(sBfPass); - /*if ((RelaxAll.getNumOccurrences() > 0) && (FileType != TargetMachine::CGFT_ObjectFile)) - { - //errs() << argv[0] << ": warning: ignoring -mc-relax-all because filetype != obj"; - }*/ // Do { //formatted_raw_ostream FOS(out); //raw_pwrite_stream *OS = &out->os(); - llvm::AnalysisID StartAfterID = nullptr; - llvm::AnalysisID StopAfterID = nullptr; - const llvm::PassRegistry *PR = llvm::PassRegistry::getPassRegistry(); - - //WriteBitcode - bool noVerify = false; // Option - - if ((!enableLTO) && (!mCodeGenOptions.mWriteBitcode)) - { - // Ask the target to add backend passes as necessary. - if (mLLVMTargetMachine->addPassesToEmitFile(PM, out, NULL, - (mCodeGenOptions.mAsmKind != BfAsmKind_None) ? llvm::CGFT_AssemblyFile : llvm::CGFT_ObjectFile, - //TargetMachine::CGFT_AssemblyFile, - noVerify /*, StartAfterID, StopAfterID*/)) - { - Fail("Target does not support generation of this file type"); - /*errs() << argv[0] << ": target does not support generation of this" - << " file type!\n";*/ - return false; - } - } + //TODO: + llvm::AnalysisID StartAfterID = nullptr; + llvm::AnalysisID StopAfterID = nullptr; + const llvm::PassRegistry *PR = llvm::PassRegistry::getPassRegistry(); + + //WriteBitcode + bool noVerify = false; // Option + + if ((!enableLTO) && (!mCodeGenOptions.mWriteBitcode)) + { + // Ask the target to add backend passes as necessary. + if (mLLVMTargetMachine->addPassesToEmitFile(PM, out, NULL, + (mCodeGenOptions.mAsmKind != BfAsmKind_None) ? llvm::CodeGenFileType::AssemblyFile : llvm::CodeGenFileType::ObjectFile, + //TargetMachine::CGFT_AssemblyFile, + noVerify /*, StartAfterID, StopAfterID*/)) + { + Fail("Target does not support generation of this file type"); + /*errs() << argv[0] << ": target does not support generation of this" + << " file type!\n";*/ + return false; + } + } bool success = PM.run(*mLLVMModule); diff --git a/IDEHelper/Compiler/BfIRCodeGen.h b/IDEHelper/Compiler/BfIRCodeGen.h index 567a3990..71c98154 100644 --- a/IDEHelper/Compiler/BfIRCodeGen.h +++ b/IDEHelper/Compiler/BfIRCodeGen.h @@ -31,17 +31,40 @@ enum BfIRCodeGenEntryKind BfIRCodeGenEntryKind_LLVMValue, BfIRCodeGenEntryKind_LLVMValue_Aligned, BfIRCodeGenEntryKind_LLVMType, + BfIRCodeGenEntryKind_TypedValue, + BfIRCodeGenEntryKind_TypedValue_Aligned, + BfIRCodeGenEntryKind_TypeEx, BfIRCodeGenEntryKind_LLVMBasicBlock, BfIRCodeGenEntryKind_LLVMMetadata, BfIRCodeGenEntryKind_IntrinsicData, }; +class BfIRTypeEx; + class BfIRIntrinsicData { public: String mName; BfIRIntrinsic mIntrinsic; - llvm::Type* mReturnType; + BfIRTypeEx* mReturnType; +}; + +class BfIRTypeEx +{ +public: + llvm::Type* mLLVMType; + SizedArray mMembers; + + BfIRTypeEx() + { + mLLVMType = NULL; + } +}; + +struct BfIRTypedValue +{ + llvm::Value* mValue; + BfIRTypeEx* mTypeEx; }; struct BfIRCodeGenEntry @@ -51,9 +74,11 @@ struct BfIRCodeGenEntry { llvm::Value* mLLVMValue; llvm::Type* mLLVMType; + BfIRTypeEx* mTypeEx; llvm::BasicBlock* mLLVMBlock; llvm::MDNode* mLLVMMetadata; BfIRIntrinsicData* mIntrinsicData; + BfIRTypedValue mTypedValue; }; }; @@ -65,9 +90,9 @@ public: int mAlign; llvm::DIType* mDIType; llvm::DIType* mInstDIType; - llvm::Type* mLLVMType; - llvm::Type* mAlignLLVMType; - llvm::Type* mInstLLVMType; + BfIRTypeEx* mType; + BfIRTypeEx* mAlignType; + BfIRTypeEx* mInstType; public: BfIRTypeEntry() @@ -77,9 +102,9 @@ public: mAlign = -1; mDIType = NULL; mInstDIType = NULL; - mLLVMType = NULL; - mAlignLLVMType = NULL; - mInstLLVMType = NULL; + mType = NULL; + mAlignType = NULL; + mInstType = NULL; } }; @@ -112,6 +137,7 @@ public: llvm::LLVMContext* mLLVMContext; llvm::Module* mLLVMModule; llvm::Function* mActiveFunction; + BfIRTypeEx* mActiveFunctionType; llvm::IRBuilder<>* mIRBuilder; llvm::AttributeList* mAttrSet; llvm::DIBuilder* mDIBuilder; @@ -129,42 +155,57 @@ public: int mConstValIdx; int mCmdCount; + int mCurLine; Dictionary mResults; Dictionary mTypes; Dictionary mIntrinsicMap; + Dictionary mTypeCodeTypeExMap; + Dictionary mLLVMTypeExMap; + Dictionary mPointerTypeExMap; Dictionary mIntrinsicReverseMap; Array mConfigConsts32; Array mConfigConsts64; - Dictionary mReflectDataMap; - Dictionary mAlignedTypeToNormalType; - Dictionary mTypeToTypeIdMap; + Dictionary mReflectDataMap; + Dictionary mAlignedTypeToNormalType; + Dictionary mTypeToTypeIdMap; HashSet mLockedBlocks; OwnedArray mIntrinsicData; Dictionary mFunctionsUsingSimd; + Array mIRTypeExs; + BfIRTypedValue mLastFuncCalled; public: void InitTarget(); void FixValues(llvm::StructType* structType, llvm::SmallVector& values); void FixIndexer(llvm::Value*& val); + void FixTypedValue(BfIRTypedValue& typedValue); BfTypeCode GetTypeCode(llvm::Type* type, bool isSigned); llvm::Type* GetLLVMType(BfTypeCode typeCode, bool& isSigned); + BfIRTypeEx* GetTypeEx(llvm::Type* llvmType); + BfIRTypeEx* CreateTypeEx(llvm::Type* llvmType); + BfIRTypeEx* GetTypeEx(BfTypeCode typeCode, bool& isSigned); + BfIRTypeEx* GetPointerTypeEx(BfIRTypeEx* typeEx); + BfIRTypeEx* GetTypeMember(BfIRTypeEx* typeEx, int idx); BfIRTypeEntry& GetTypeEntry(int typeId); - BfIRTypeEntry* GetTypeEntry(llvm::Type* type); + BfIRTypeEntry* GetTypeEntry(BfIRTypeEx* type); void SetResult(int id, llvm::Value* value); + void SetResult(int id, const BfIRTypedValue& value); void SetResultAligned(int id, llvm::Value* value); + void SetResultAligned(int id, const BfIRTypedValue& value); void SetResult(int id, llvm::Type* value); + void SetResult(int id, BfIRTypeEx* typeEx); void SetResult(int id, llvm::BasicBlock* value); void SetResult(int id, llvm::MDNode* value); void CreateMemSet(llvm::Value* addr, llvm::Value* val, llvm::Value* size, int alignment, bool isVolatile = false); void AddNop(); - llvm::Value* TryToVector(llvm::Value* value); - llvm::Value* TryToVector(llvm::Value* value, llvm::Type* elemType); - llvm::Type* GetElemType(llvm::Value* value); - bool TryMemCpy(llvm::Value* ptr, llvm::Value* val); - bool TryVectorCpy(llvm::Value* ptr, llvm::Value* val); - llvm::Type* GetSizeAlignedType(BfIRTypeEntry* typeEntry); - llvm::Value* GetAlignedPtr(llvm::Value* val); - llvm::Value* FixGEP(llvm::Value* fromValue, llvm::Value* result); + llvm::Value* TryToVector(const BfIRTypedValue& value); + bool TryMemCpy(const BfIRTypedValue& ptr, llvm::Value* val); + bool TryVectorCpy(const BfIRTypedValue& ptr, llvm::Value* val); + + llvm::Type* GetLLVMPointerElementType(BfIRTypeEx* typeEx); + + BfIRTypeEx* GetSizeAlignedType(BfIRTypeEntry* typeEntry); + BfIRTypedValue GetAlignedPtr(const BfIRTypedValue& val); llvm::Value* DoCheckedIntrinsic(llvm::Intrinsic::ID intrin, llvm::Value* lhs, llvm::Value* rhs, bool useAsm); public: @@ -186,11 +227,15 @@ public: void Read(bool& val); void Read(int8& val); void Read(BfIRTypeEntry*& type); + void Read(BfIRTypeEx*& typeEx, BfIRTypeEntry** outTypeEntry = NULL); void Read(llvm::Type*& llvmType, BfIRTypeEntry** outTypeEntry = NULL); void Read(llvm::FunctionType*& llvmType); + void ReadFunctionType(BfIRTypeEx*& typeEx); + void Read(BfIRTypedValue& llvmValue, BfIRCodeGenEntry** codeGenEntry = NULL, BfIRSizeAlignKind sizeAlignKind = BfIRSizeAlignKind_Original); void Read(llvm::Value*& llvmValue, BfIRCodeGenEntry** codeGenEntry = NULL, BfIRSizeAlignKind sizeAlignKind = BfIRSizeAlignKind_Original); - void Read(llvm::Constant*& llvmConstant, BfIRSizeAlignKind sizeAlignKind = BfIRSizeAlignKind_Original); + void Read(llvm::Constant*& llvmConstant, BfIRSizeAlignKind sizeAlignKind = BfIRSizeAlignKind_Original); void Read(llvm::Function*& llvmFunc); + void ReadFunction(BfIRTypedValue& typeEx); void Read(llvm::BasicBlock*& llvmBlock); void Read(llvm::MDNode*& llvmMD); void Read(llvm::Metadata*& llvmMD); @@ -237,6 +282,7 @@ public: String GetSimdTypeString(BfIRSimdType type); BfIRSimdType GetSimdTypeFromFunction(llvm::Function* function); + BfIRTypedValue GetTypedValue(int streamId); llvm::Value* GetLLVMValue(int streamId); llvm::Type* GetLLVMType(int streamId); llvm::BasicBlock* GetLLVMBlock(int streamId); diff --git a/IDEHelper/Compiler/BfModule.cpp b/IDEHelper/Compiler/BfModule.cpp index 1854d35e..0c62b779 100644 --- a/IDEHelper/Compiler/BfModule.cpp +++ b/IDEHelper/Compiler/BfModule.cpp @@ -29,6 +29,15 @@ #include #include +#pragma warning (disable:4267) +//#include "llvm/Support/Compiler.h" +//#include "llvm/IR/IRBuilder.h" +//#include "llvm/IR/Type.h" +#include "llvm/IR/DIBuilder.h" +//#include "llvm/IR/DebugInfo.h" +//#include "llvm/IR/Argument.h" +//#include "llvm/IR/Constants.h" + #pragma warning(pop) ////////////////////////////////////////////////////////////////////////// @@ -1249,8 +1258,8 @@ void BfModule::SetupIRBuilder(bool dbgVerifyCodeGen) // code as we walk the AST //mBfIRBuilder->mDbgVerifyCodeGen = true; if ( - (mModuleName == "-") - //|| (mModuleName == "BeefTest2_ClearColorValue") + (mModuleName == "BeefTest_LLVMType") + || (mModuleName == "System_ValueType") //|| (mModuleName == "Tests_FuncRefs") ) mBfIRBuilder->mDbgVerifyCodeGen = true; diff --git a/IDEHelper/Compiler/BfStmtEvaluator.cpp b/IDEHelper/Compiler/BfStmtEvaluator.cpp index 318f4dc8..02f8b657 100644 --- a/IDEHelper/Compiler/BfStmtEvaluator.cpp +++ b/IDEHelper/Compiler/BfStmtEvaluator.cpp @@ -27,6 +27,7 @@ #pragma warning(disable:4800) #pragma warning(disable:4996) +#include "llvm/IR/DIBuilder.h" #include "llvm/IR/Module.h" #include "llvm/IR/Constants.h" #include "llvm/IR/GlobalValue.h" diff --git a/IDEHelper/DebugManager.cpp b/IDEHelper/DebugManager.cpp index d15576d5..834b9ce4 100644 --- a/IDEHelper/DebugManager.cpp +++ b/IDEHelper/DebugManager.cpp @@ -585,10 +585,10 @@ void ShowMemoryUsage() return HeapAlloc(hHeap, dwFlags, dwBytes); }*/ -static void BfFatalErrorHandler(void *user_data, const std::string& reason, bool gen_crash_diag) +static void BfFatalErrorHandler(void *user_data, const char* reason, bool gen_crash_diag) { - BF_FATAL(reason.c_str()); - OutputDebugStrF("LLVM ERROR: %s\n", reason.c_str()); + BF_FATAL(reason); + OutputDebugStrF("LLVM ERROR: %s\n", reason); } #ifdef BF_PLATFORM_WINDOWS diff --git a/IDEHelper/IDEHelper.vcxproj b/IDEHelper/IDEHelper.vcxproj index 2a247b17..55f21aa3 100644 --- a/IDEHelper/IDEHelper.vcxproj +++ b/IDEHelper/IDEHelper.vcxproj @@ -140,6 +140,7 @@ ProgramDatabase false true + stdcpp17 Windows @@ -161,20 +162,21 @@ Level3 Disabled WIN32;_DEBUG;_WINDOWS;_USRDLL;IDEHELPER_EXPORTS;BFSYSLIB_DYNAMIC;%(PreprocessorDefinitions) - ../;../BeefySysLib/platform/win;../BeefySysLib/third_party;..\extern\llvm-project_13_0_1\llvm\include;..\extern\llvm_win64_13_0_1\include;..\extern\llvm-project_13_0_1\llvm\lib\Target;..\extern\llvm_win64_13_0_1\lib\Target\AArch64;..\extern\llvm_win64_13_0_1\lib\Target\X86;..\extern\llvm-project_13_0_1\llvm\tools\clang\include;..\extern\curl\builds\libcurl-vc15-x64-release-static-zlib-static-ipv6-sspi-winssl\include + ../;../BeefySysLib/platform/win;../BeefySysLib/third_party;..\extern\llvm-project_18_1_4\llvm\include;..\extern\llvm_win64_18_1_4\include;..\extern\llvm-project_18_1_4\llvm\lib\Target;..\extern\llvm_win64_18_1_4\lib\Target\AArch64;..\extern\llvm_win64_18_1_4\lib\Target\X86;..\extern\llvm-project_18_1_4\llvm\tools\clang\include;..\extern\curl\builds\libcurl-vc15-x64-release-static-zlib-static-ipv6-sspi-winssl\include false -D_SCL_SECURE_NO_WARNINGS %(AdditionalOptions) MultiThreadedDebug ProgramDatabase false true + stdcpp17 Windows DebugFull $(SolutionDir)\IDE\dist\$(TargetName).dll - rpcrt4.lib;cabinet.lib;winmm.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;libcurl_a.lib;wininet.lib;LLVMMCDisassembler.lib;LLVMSupport.lib;LLVMMC.lib;LLVMObject.lib;LLVMCore.lib;LLVMBitReader.lib;LLVMAsmParser.lib;LLVMMCParser.lib;LLVMCodeGen.lib;LLVMTarget.lib;LLVMScalarOpts.lib;LLVMInstCombine.lib;LLVMSelectionDAG.lib;LLVMProfileData.lib;LLVMAnalysis.lib;LLVMAsmPrinter.lib;LLVMBitWriter.lib;LLVMVectorize.lib;LLVMipo.lib;LLVMInstrumentation.lib;LLVMDebugInfoDWARF.lib;LLVMDebugInfoPDB.lib;LLVMDebugInfoCodeView.lib;LLVMGlobalISel.lib;LLVMBinaryFormat.lib;LLVMBitstreamReader.lib;LLVMLTO.lib;LLVMPasses.lib;LLVMLinker.lib;LLVMIRReader.lib;LLVMDemangle.lib;LLVMTransformUtils.lib;LLVMAggressiveInstCombine.lib;LLVMCFGuard.lib;LLVMTextAPI.lib;LLVMRemarks.lib;LLVMX86Info.lib;LLVMX86Desc.lib;LLVMX86CodeGen.lib;LLVMX86AsmParser.lib;LLVMX86Disassembler.lib;LLVMAArch64Info.lib;LLVMAArch64Utils.lib;LLVMAArch64Desc.lib;LLVMAArch64CodeGen.lib;LLVMAArch64AsmParser.lib;LLVMAArch64Disassembler.lib;LLVMARMInfo.lib;LLVMARMUtils.lib;LLVMARMDesc.lib;LLVMARMCodeGen.lib;LLVMARMAsmParser.lib;LLVMARMDisassembler.lib;LLVMWebAssemblyInfo.lib;LLVMWebAssemblyDesc.lib;LLVMWebAssemblyCodeGen.lib;LLVMWebAssemblyAsmParser.lib;LLVMWebAssemblyDisassembler.lib;LLVMWebAssemblyUtils.lib;%(AdditionalDependencies) - ..\extern\llvm_win64_13_0_1\Debug\lib; ..\extern\curl\builds\libcurl-vc15-x64-release-static-zlib-static-ipv6-sspi-winssl\lib;..\extern\curl\deps\lib;..\extern\jemalloc_win\x64\debug + rpcrt4.lib;cabinet.lib;winmm.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;libcurl_a.lib;wininet.lib;LLVMMCDisassembler.lib;LLVMSupport.lib;LLVMMC.lib;LLVMObject.lib;LLVMCore.lib;LLVMBitReader.lib;LLVMAsmParser.lib;LLVMMCParser.lib;LLVMCodeGen.lib;LLVMTarget.lib;LLVMScalarOpts.lib;LLVMInstCombine.lib;LLVMSelectionDAG.lib;LLVMProfileData.lib;LLVMAnalysis.lib;LLVMAsmPrinter.lib;LLVMBitWriter.lib;LLVMVectorize.lib;LLVMipo.lib;LLVMInstrumentation.lib;LLVMDebugInfoDWARF.lib;LLVMDebugInfoPDB.lib;LLVMDebugInfoCodeView.lib;LLVMGlobalISel.lib;LLVMBinaryFormat.lib;LLVMBitstreamReader.lib;LLVMLTO.lib;LLVMPasses.lib;LLVMLinker.lib;LLVMIRReader.lib;LLVMDemangle.lib;LLVMTransformUtils.lib;LLVMAggressiveInstCombine.lib;LLVMCFGuard.lib;LLVMTextAPI.lib;LLVMRemarks.lib;LLVMX86Info.lib;LLVMX86Desc.lib;LLVMX86CodeGen.lib;LLVMX86AsmParser.lib;LLVMX86Disassembler.lib;LLVMAArch64Info.lib;LLVMAArch64Utils.lib;LLVMAArch64Desc.lib;LLVMAArch64CodeGen.lib;LLVMAArch64Disassembler.lib;LLVMARMInfo.lib;LLVMARMUtils.lib;LLVMARMDesc.lib;LLVMARMCodeGen.lib;LLVMARMDisassembler.lib;LLVMWebAssemblyInfo.lib;LLVMWebAssemblyDesc.lib;LLVMWebAssemblyCodeGen.lib;LLVMWebAssemblyDisassembler.lib;LLVMWebAssemblyUtils.lib;LLVMTargetParser.lib;LLVMIRPrinter.lib;LLVMWebAssemblyAsmParser.lib;LLVMObjCARCOpts.lib;LLVMCodeGenTypes.lib;%(AdditionalDependencies) + ..\extern\llvm_win64_18_1_4\Debug\lib; ..\extern\curl\builds\libcurl-vc15-x64-release-static-zlib-static-ipv6-sspi-winssl\lib;..\extern\curl\deps\lib;..\extern\jemalloc_win\x64\debug false $(SolutionDir)\IDE\dist\$(TargetName).lib MSVCRT @@ -200,6 +202,7 @@ ../;../BeefySysLib/platform/win;../BeefySysLib/third_party;C:\llvm-3.8\llvm\include;C:\llvm-3.8\bin\include;C:\llvm-3.8\llvm\lib\Target;C:\llvm-3.8\bin\lib\Target\X86;C:\llvm-3.8\llvm\tools\clang\include MultiThreadedDLL true + stdcpp17 Windows @@ -222,10 +225,11 @@ true true zBP_DISABLED;WIN32;NDEBUG;_WINDOWS;_USRDLL;IDEHELPER_EXPORTS;BFSYSLIB_DYNAMIC;%(PreprocessorDefinitions) - ../;../BeefySysLib/platform/win;../BeefySysLib/third_party;..\extern\llvm-project_13_0_1\llvm\include;..\extern\llvm_win64_13_0_1\include;..\extern\llvm-project_13_0_1\llvm\lib\Target;..\extern\llvm_win64_13_0_1\lib\Target\X86;..\extern\llvm-project_13_0_1\llvm\tools\clang\include;..\extern\curl\builds\libcurl-vc15-x64-release-static-zlib-static-ipv6-sspi-winssl\include + ../;../BeefySysLib/platform/win;../BeefySysLib/third_party;..\extern\llvm-project_18_1_4\llvm\include;..\extern\llvm_win64_18_1_4\include;..\extern\llvm-project_18_1_4\llvm\lib\Target;..\extern\llvm_win64_18_1_4\lib\Target\X86;..\extern\llvm-project_18_1_4\llvm\tools\clang\include;..\extern\curl\builds\libcurl-vc15-x64-release-static-zlib-static-ipv6-sspi-winssl\include MultiThreaded false true + stdcpp17 Windows @@ -233,8 +237,8 @@ true true $(SolutionDir)\IDE\dist\$(TargetName).dll - ..\extern\llvm_win64_13_0_1\Release\lib; ..\extern\curl\builds\libcurl-vc15-x64-release-static-zlib-static-ipv6-sspi-winssl\lib;..\extern\curl\deps\lib;..\extern\jemalloc_win\x64\release - rpcrt4.lib;cabinet.lib;winmm.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;libcurl_a.lib;wininet.lib;LLVMMCDisassembler.lib;LLVMSupport.lib;LLVMMC.lib;LLVMObject.lib;LLVMCore.lib;LLVMBitReader.lib;LLVMAsmParser.lib;LLVMMCParser.lib;LLVMCodeGen.lib;LLVMTarget.lib;LLVMScalarOpts.lib;LLVMInstCombine.lib;LLVMSelectionDAG.lib;LLVMProfileData.lib;LLVMAnalysis.lib;LLVMAsmPrinter.lib;LLVMBitWriter.lib;LLVMVectorize.lib;LLVMipo.lib;LLVMInstrumentation.lib;LLVMDebugInfoDWARF.lib;LLVMDebugInfoPDB.lib;LLVMDebugInfoCodeView.lib;LLVMGlobalISel.lib;LLVMBinaryFormat.lib;LLVMBitstreamReader.lib;LLVMLTO.lib;LLVMPasses.lib;LLVMLinker.lib;LLVMIRReader.lib;LLVMDemangle.lib;LLVMTransformUtils.lib;LLVMAggressiveInstCombine.lib;LLVMCFGuard.lib;LLVMTextAPI.lib;LLVMRemarks.lib;LLVMX86Info.lib;LLVMX86Desc.lib;LLVMX86CodeGen.lib;LLVMX86AsmParser.lib;LLVMX86Disassembler.lib;LLVMAArch64Info.lib;LLVMAArch64Utils.lib;LLVMAArch64Desc.lib;LLVMAArch64CodeGen.lib;LLVMAArch64AsmParser.lib;LLVMAArch64Disassembler.lib;LLVMARMInfo.lib;LLVMARMUtils.lib;LLVMARMDesc.lib;LLVMARMCodeGen.lib;LLVMARMAsmParser.lib;LLVMARMDisassembler.lib;LLVMWebAssemblyInfo.lib;LLVMWebAssemblyDesc.lib;LLVMWebAssemblyCodeGen.lib;LLVMWebAssemblyAsmParser.lib;LLVMWebAssemblyDisassembler.lib;LLVMWebAssemblyUtils.lib;%(AdditionalDependencies) + ..\extern\llvm_win64_18_1_4\Release\lib; ..\extern\curl\builds\libcurl-vc15-x64-release-static-zlib-static-ipv6-sspi-winssl\lib;..\extern\curl\deps\lib;..\extern\jemalloc_win\x64\release + rpcrt4.lib;cabinet.lib;winmm.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;libcurl_a.lib;wininet.lib;LLVMMCDisassembler.lib;LLVMSupport.lib;LLVMMC.lib;LLVMObject.lib;LLVMCore.lib;LLVMBitReader.lib;LLVMAsmParser.lib;LLVMMCParser.lib;LLVMCodeGen.lib;LLVMTarget.lib;LLVMScalarOpts.lib;LLVMInstCombine.lib;LLVMSelectionDAG.lib;LLVMProfileData.lib;LLVMAnalysis.lib;LLVMAsmPrinter.lib;LLVMBitWriter.lib;LLVMVectorize.lib;LLVMipo.lib;LLVMInstrumentation.lib;LLVMDebugInfoDWARF.lib;LLVMDebugInfoPDB.lib;LLVMDebugInfoCodeView.lib;LLVMGlobalISel.lib;LLVMBinaryFormat.lib;LLVMBitstreamReader.lib;LLVMLTO.lib;LLVMPasses.lib;LLVMLinker.lib;LLVMIRReader.lib;LLVMDemangle.lib;LLVMTransformUtils.lib;LLVMAggressiveInstCombine.lib;LLVMCFGuard.lib;LLVMTextAPI.lib;LLVMRemarks.lib;LLVMX86Info.lib;LLVMX86Desc.lib;LLVMX86CodeGen.lib;LLVMX86AsmParser.lib;LLVMX86Disassembler.lib;LLVMAArch64Info.lib;LLVMAArch64Utils.lib;LLVMAArch64Desc.lib;LLVMAArch64CodeGen.lib;LLVMAArch64Disassembler.lib;LLVMARMInfo.lib;LLVMARMUtils.lib;LLVMARMDesc.lib;LLVMARMCodeGen.lib;LLVMARMDisassembler.lib;LLVMWebAssemblyInfo.lib;LLVMWebAssemblyDesc.lib;LLVMWebAssemblyCodeGen.lib;LLVMWebAssemblyDisassembler.lib;LLVMWebAssemblyUtils.lib;LLVMTargetParser.lib;LLVMIRPrinter.lib;LLVMWebAssemblyAsmParser.lib;LLVMObjCARCOpts.lib;LLVMCodeGenTypes.lib;%(AdditionalDependencies) false true $(SolutionDir)\IDE\dist\$(TargetName).lib @@ -255,6 +259,7 @@ WIN32;NDEBUG;_WINDOWS;_USRDLL;IDEHELPER_EXPORTS;BFSYSLIB_DYNAMIC;%(PreprocessorDefinitions) ../;../BeefySysLib/platform/win;../BeefySysLib/third_party;C:\llvm\llvm\include;C:\llvm\src\include;C:\llvm\llvm\lib\Target;C:\llvm\src\lib\Target\X86;C:\llvm\llvm\tools\clang\include MultiThreadedDLL + stdcpp17 Windows @@ -279,6 +284,7 @@ WIN32;NDEBUG;_WINDOWS;_USRDLL;IDEHELPER_EXPORTS;BFSYSLIB_DYNAMIC;%(PreprocessorDefinitions) ../;../BeefySysLib/platform/win;../BeefySysLib/third_party;C:\llvm\llvm\include;C:\llvm\src\include;C:\llvm\llvm\lib\Target;C:\llvm\src\lib\Target\X86;C:\llvm\llvm\tools\clang\include MultiThreadedDLL + stdcpp17 Windows diff --git a/IDEHelper/X64.cpp b/IDEHelper/X64.cpp index 4cced4ea..856d1849 100644 --- a/IDEHelper/X64.cpp +++ b/IDEHelper/X64.cpp @@ -14,7 +14,10 @@ #include "llvm/Support/SourceMgr.h" #include "llvm/MC/MCContext.h" #include "llvm/ADT/StringRef.h" -#include "llvm/Support/TargetRegistry.h" +#include "llvm/MC/TargetRegistry.h" +#include "llvm/MC/MCInstrInfo.h" +#include "llvm/MC/MCRegisterInfo.h" +#include "llvm/MC/MCSubtargetInfo.h" #include "llvm/IR/InlineAsm.h" //#include "llvm/Support/MemoryObject.h" #include "llvm/Target/TargetOptions.h" @@ -363,8 +366,8 @@ bool X64Instr::IsLoadAddress() const MCInstrDesc &instDesc = mX64->mInstrInfo->get(mMCInst.getOpcode()); if (instDesc.NumOperands >= 6) { - if ((instDesc.OpInfo[0].OperandType == MCOI::OPERAND_REGISTER) && - (instDesc.OpInfo[4].OperandType == MCOI::OPERAND_MEMORY)) + if ((instDesc.operands()[0].OperandType == MCOI::OPERAND_REGISTER) && + (instDesc.operands()[4].OperandType == MCOI::OPERAND_MEMORY)) return true; } @@ -724,7 +727,7 @@ uint64 X64Instr::GetTarget(Debugger* debugger, X64CPURegisters* registers) auto operand = mMCInst.getOperand(0); if (mMCInst.getNumOperands() > 4) { - if ((instDesc.OpInfo[0].OperandType == MCOI::OPERAND_REGISTER) && (instDesc.OpInfo[4].OperandType == MCOI::OPERAND_MEMORY)) + if ((instDesc.operands()[0].OperandType == MCOI::OPERAND_REGISTER) && (instDesc.operands()[4].OperandType == MCOI::OPERAND_MEMORY)) { opIdx = 4; operand = mMCInst.getOperand(opIdx); @@ -734,7 +737,7 @@ uint64 X64Instr::GetTarget(Debugger* debugger, X64CPURegisters* registers) if (operand.isImm()) { auto targetAddr = (uint64)operand.getImm(); - if (instDesc.OpInfo[opIdx].OperandType == MCOI::OPERAND_PCREL) + if (instDesc.operands()[opIdx].OperandType == MCOI::OPERAND_PCREL) targetAddr += mAddress + mSize; return targetAddr; } @@ -1109,8 +1112,8 @@ void X64CPU::GetClobbersForMnemonic(const StringImpl& mnemonic, int argCount, Ar if (!outMayClobberMem && desc.mayStore()) outMayClobberMem = true; - int numImplicits = desc.getNumImplicitDefs(); - auto impPtr = desc.getImplicitDefs(); + int numImplicits = (int)desc.implicit_defs().size(); + auto& impPtr = desc.implicit_defs(); for (int iImp = 0; iImpmInstrInfo->get(mMCInst.getOpcode()); if (instDesc.NumOperands >= 6) { - if ((instDesc.OpInfo[0].OperandType == MCOI::OPERAND_REGISTER) && - (instDesc.OpInfo[4].OperandType == MCOI::OPERAND_MEMORY)) + if ((instDesc.operands()[0].OperandType == MCOI::OPERAND_REGISTER) && + (instDesc.operands()[4].OperandType == MCOI::OPERAND_MEMORY)) return true; } @@ -384,7 +388,7 @@ uint32 X86Instr::GetTarget(Debugger* debugger, X86CPURegisters* registers) int opIdx = 0; auto operand = mMCInst.getOperand(0); - if ((mMCInst.getNumOperands() >= 5) && (instDesc.OpInfo[0].OperandType == MCOI::OPERAND_REGISTER) && (instDesc.OpInfo[4].OperandType == MCOI::OPERAND_MEMORY)) + if ((mMCInst.getNumOperands() >= 5) && (instDesc.operands()[0].OperandType == MCOI::OPERAND_REGISTER) && (instDesc.operands()[4].OperandType == MCOI::OPERAND_MEMORY)) { opIdx = 4; operand = mMCInst.getOperand(opIdx); @@ -396,7 +400,7 @@ uint32 X86Instr::GetTarget(Debugger* debugger, X86CPURegisters* registers) //TODO: LLVM3.8 - add changes to MCInst? /*if (instDesc.OpInfo[opIdx].OperandType == MCOI::OPERAND_PCREL) targetAddr += mMCInst.getPCAddr() + mMCInst.getInstLength();*/ - if (instDesc.OpInfo[opIdx].OperandType == MCOI::OPERAND_PCREL) + if (instDesc.operands()[opIdx].OperandType == MCOI::OPERAND_PCREL) targetAddr += mAddress + mSize; return targetAddr; } @@ -699,8 +703,8 @@ void X86CPU::GetClobbersForMnemonic(const StringImpl& mnemonic, int argCount, Ar if (!outMayClobberMem && desc.mayStore()) outMayClobberMem = true; - int numImplicits = desc.getNumImplicitDefs(); - auto impPtr = desc.getImplicitDefs(); + int numImplicits = (int)desc.implicit_defs().size(); + auto impPtr = desc.implicit_defs(); for (int iImp=0; iImp