feat: basic code generation

DairoGrey · DairoGrey · commit 58cb3992e144 · 2023-05-10T15:35:52.000+03:00
feat: add packed flag to StructType
feat: add CallingConv to Function
diff --git a/include/Util/ErrMsg.h b/include/Util/ErrMsg.h
@@ -3,7 +3,7 @@
 namespace ErrMsg {
     namespace Class {
         namespace APInt {
-            constexpr const char *constructor = "APInt.constructor needs to be called with new (numBits: number, value: number, isSigned?: boolean)";
+            constexpr const char *constructor = "APInt.constructor needs to be called with new (numBits: number, value: number | bigint, isSigned?: boolean)";
         }
         namespace APFloat {
             constexpr const char *constructor = "APFloat.constructor needs to be called with new (value: number)";
@@ -579,6 +579,19 @@ namespace ErrMsg {
         }
         namespace TargetMachine {
             constexpr const char *constructor = "TargetMachine.constructor needs to be called with new (external: Napi::External<llvm::TargetMachine>)";
+            constexpr const char *emitToFile = "TargetMachine.emitToFile needs to be called with (module: Module, path: string, format: CodeGenFileType)";
+            constexpr const char *emitToBuffer = "TargetMachine.emitToBuffer needs to be called with (module: Module, format: CodeGenFileType)";
+            constexpr const char *addPassesToEmitFile = "Cannot register passes to emit file. Check registered ASM printers, targets and relevant stuff";
+        }
+        namespace ModulePassManager {
+            constexpr const char *constructor = "ModulePassManager.constructor needs to be called with new (optLevel: OptimizationLevel)";
+            constexpr const char *createFunctionPassManager = "ModulePassManager.createFunctionPassManager needs to be called with new (ltoPhase: ThinOrFullLTOPhase)";
+            constexpr const char *addFunctionPasses = "ModulePassManager.addFunctionPasses needs to be called with new (fpm: FunctionPassManager)";
+            constexpr const char *run = "ModulePassManager.run needs to be called with new (module: Module)";
+        }
+        namespace FunctionPassManager {
+            constexpr const char *constructor = "ModulePassManager.constructor needs to be called with new (external: Napi::External<llvm::TargetMachine>)";
+
         }
     }
     namespace Namespace::Intrinsic {
diff --git a/llvm-bindings.d.ts b/llvm-bindings.d.ts
@@ -1,6 +1,6 @@
 declare namespace llvm {
     class APInt {
-        public constructor(numBits: number, value: number, isSigned?: boolean);
+        public constructor(numBits: number, value: number | bigint, isSigned?: boolean);
     }
 
     class APFloat {
diff --git a/src/ADT/APInt.cpp b/src/ADT/APInt.cpp
@@ -20,11 +20,14 @@ llvm::APInt &APInt::Extract(const Napi::Value &value) {
 APInt::APInt(const Napi::CallbackInfo &info) : ObjectWrap(info) {
     Napi::Env env = info.Env();
     unsigned argsLen = info.Length();
-    if (!info.IsConstructCall() || argsLen < 2 || !info[0].IsNumber() || !info[1].IsNumber() || argsLen >= 3 && !info[2].IsBoolean()) {
+    if (!info.IsConstructCall() || argsLen < 2 || !info[0].IsNumber() || !(info[1].IsNumber() || info[1].IsBigInt()) || argsLen >= 3 && !info[2].IsBoolean()) {
         throw Napi::TypeError::New(env, ErrMsg::Class::APInt::constructor);
     }
     unsigned numBits = info[0].As<Napi::Number>();
-    uint64_t val = info[1].As<Napi::Number>().Int64Value();
+    bool lossless = true;
+    uint64_t val = info[1].IsNumber()
+        ? info[1].As<Napi::Number>().Int64Value()
+        : info[1].As<Napi::BigInt>().Int64Value(&lossless);
     bool isSigned = false;
     if (argsLen >= 3) {
         isSigned = info[2].As<Napi::Boolean>();
diff --git a/src/IR/PassManager.cpp b/src/IR/PassManager.cpp
@@ -5,6 +5,7 @@
 
 #include "llvm/Pass.h"
 #include "llvm/Passes/PassBuilder.h"
+#include "llvm/CodeGen/CodeGenPassBuilder.h"
 #include "llvm/Transforms/Scalar/SROA.h"
 #include "llvm/Transforms/Scalar/EarlyCSE.h"
 #include "llvm/Transforms/InstCombine/InstCombine.h"
@@ -52,30 +53,40 @@ llvm::OptimizationLevel mapToLLVM(OptimizationLevel::Level opt) {
 
 ModulePassManager::ModulePassManager(const Napi::CallbackInfo &info) : ObjectWrap(info) {
     Napi::Env env = info.Env();
-
-    level = mapToLLVM((OptimizationLevel::Level) info[0].As<Napi::Number>().Uint32Value());
-
-    passBuilder = new llvm::PassBuilder();
-
-    moduleAnalysisManager = new llvm::ModuleAnalysisManager();
-    cgsccAnalysisManager = new llvm::CGSCCAnalysisManager();
-    functionAnalysisManager = new llvm::FunctionAnalysisManager();
-    loopAnalysisManager = new llvm::LoopAnalysisManager ();
-
-    passBuilder->registerModuleAnalyses(*moduleAnalysisManager);
-    passBuilder->registerCGSCCAnalyses(*cgsccAnalysisManager);
-    passBuilder->registerFunctionAnalyses(*functionAnalysisManager);
-    passBuilder->registerLoopAnalyses(*loopAnalysisManager);
-    passBuilder->crossRegisterProxies(
-        *loopAnalysisManager,
-        *functionAnalysisManager,
-        *cgsccAnalysisManager,
-        *moduleAnalysisManager
-    );
-
-    passManager = new llvm::ModulePassManager(
-        passBuilder->buildPerModuleDefaultPipeline(level)
-    );
+    if (info.IsConstructCall() && info.Length() == 1 && info[0].IsNumber()) {
+        level = mapToLLVM((OptimizationLevel::Level) info[0].As<Napi::Number>().Uint32Value());
+
+        passBuilder = new llvm::PassBuilder();
+
+        moduleAnalysisManager = new llvm::ModuleAnalysisManager();
+        cgsccAnalysisManager = new llvm::CGSCCAnalysisManager();
+        functionAnalysisManager = new llvm::FunctionAnalysisManager();
+        loopAnalysisManager = new llvm::LoopAnalysisManager ();
+
+        passBuilder->registerModuleAnalyses(*moduleAnalysisManager);
+        passBuilder->registerCGSCCAnalyses(*cgsccAnalysisManager);
+        passBuilder->registerFunctionAnalyses(*functionAnalysisManager);
+        passBuilder->registerLoopAnalyses(*loopAnalysisManager);
+        passBuilder->crossRegisterProxies(
+            *loopAnalysisManager,
+            *functionAnalysisManager,
+            *cgsccAnalysisManager,
+            *moduleAnalysisManager
+        );
+
+        if (level == llvm::OptimizationLevel::O0) {
+            passManager = new llvm::ModulePassManager(
+                passBuilder->buildO0DefaultPipeline(level)
+            );
+            return;
+        }
+
+        passManager = new llvm::ModulePassManager(
+            passBuilder->buildPerModuleDefaultPipeline(level)
+        );
+        return;
+    }
+    throw Napi::TypeError::New(env, ErrMsg::Class::ModulePassManager::constructor);
 }
 
 llvm::ModulePassManager *ModulePassManager::getLLVMPrimitive() {
@@ -84,6 +95,11 @@ llvm::ModulePassManager *ModulePassManager::getLLVMPrimitive() {
 
 Napi::Value ModulePassManager::createFunctionPassManager(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
+    unsigned argsLen = info.Length();
+
+    if (argsLen != 1 || !info[0].IsNumber()) {
+        throw Napi::TypeError::New(env, ErrMsg::Class::ModulePassManager::createFunctionPassManager);
+    }
 
     auto lto = (llvm::ThinOrFullLTOPhase) info[0].As<Napi::Number>().Uint32Value();
 
@@ -103,14 +119,14 @@ void ModulePassManager::addFunctionPasses(const Napi::CallbackInfo &info) {
     Napi::Env env = info.Env();
     auto argsLen = info.Length();
 
-    if (argsLen != 1) {
-        throw Napi::TypeError::New(env, "(fpm: FunctionPassManager)");
+    if (argsLen != 1 || !FunctionPassManager::IsClassOf(info[0])) {
+        throw Napi::TypeError::New(env, ErrMsg::Class::ModulePassManager::addFunctionPasses);
     }
 
     auto fpm = FunctionPassManager::Extract(info[0]);
 
     if (!fpm) {
-        throw Napi::TypeError::New(env, "(fpm: FunctionPassManager)");
+        throw Napi::TypeError::New(env, ErrMsg::Class::ModulePassManager::addFunctionPasses);
     }
 
     passManager->addPass(llvm::createModuleToFunctionPassAdaptor(std::move(*fpm)));
@@ -125,11 +141,15 @@ void ModulePassManager::run(const Napi::CallbackInfo &info) {
     auto argsLen = info.Length();
 
     if (argsLen != 1 || !Module::IsClassOf(info[0])) {
-        throw Napi::TypeError::New(env, "(module: Module)");
+        throw Napi::TypeError::New(env, ErrMsg::Class::ModulePassManager::run);
     }
 
     auto module = Module::Extract(info[0]);
 
+    if (!module) {
+        throw Napi::TypeError::New(env, ErrMsg::Class::ModulePassManager::run);
+    }
+
     passManager->run(*module, *moduleAnalysisManager);
 }
 
@@ -167,8 +187,13 @@ llvm::FunctionPassManager *FunctionPassManager::Extract(const Napi::Value &value
 }
 
 FunctionPassManager::FunctionPassManager(const Napi::CallbackInfo &info) : ObjectWrap(info) {
-    auto external = info[0].As<Napi::External<llvm::FunctionPassManager>>();
-    passManager = external.Data();
+    Napi::Env env = info.Env();
+    if (info.IsConstructCall() && info.Length() == 1 && info[0].IsExternal()) {
+        auto external = info[0].As<Napi::External<llvm::FunctionPassManager>>();
+        passManager = external.Data();
+        return;
+    }
+    throw Napi::TypeError::New(env, ErrMsg::Class::FunctionPassManager::constructor);
 }
 
 llvm::FunctionPassManager *FunctionPassManager::getLLVMPrimitive() {
diff --git a/src/Target/TargetMachine.cpp b/src/Target/TargetMachine.cpp
@@ -46,6 +46,11 @@ Napi::Value TargetMachine::createDataLayout(const Napi::CallbackInfo &info) {
 
 void TargetMachine::emitToFile(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
+    unsigned argsLen = info.Length();
+
+    if (argsLen != 3 || !Module::IsClassOf(info[0]) || !info[1].IsString() || !info[2].IsNumber()) {
+        throw Napi::TypeError::New(env, ErrMsg::Class::TargetMachine::emitToFile);
+    }
 
     auto fileName = info[1].As<Napi::String>().Utf8Value();
     std::error_code ec;
@@ -57,7 +62,7 @@ void TargetMachine::emitToFile(const Napi::CallbackInfo& info) {
     llvm::legacy::PassManager pm{};
 
     if (const_cast<llvm::TargetMachine*>(targetMachine)->addPassesToEmitFile(pm, dest, nullptr, type)) {
-        throw Napi::TypeError::New(env, "cannot add emit pass");
+        throw Napi::Error::New(env, ErrMsg::Class::TargetMachine::addPassesToEmitFile);
     }
 
     pm.run(*module);
@@ -66,6 +71,11 @@ void TargetMachine::emitToFile(const Napi::CallbackInfo& info) {
 
 Napi::Value TargetMachine::emitToBuffer(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
+    unsigned argsLen = info.Length();
+
+    if (argsLen != 2 || !Module::IsClassOf(info[0]) || !info[1].IsNumber()) {
+        throw Napi::TypeError::New(env, ErrMsg::Class::TargetMachine::emitToBuffer);
+    }
 
     llvm::SmallVector<char> buffer;
     llvm::raw_svector_ostream dest(buffer);
@@ -76,7 +86,7 @@ Napi::Value TargetMachine::emitToBuffer(const Napi::CallbackInfo& info) {
     llvm::legacy::PassManager pm{};
 
     if (const_cast<llvm::TargetMachine*>(targetMachine)->addPassesToEmitFile(pm, dest, nullptr, type)) {
-        throw Napi::TypeError::New(env, "cannot add emit pass");
+        throw Napi::Error::New(env, ErrMsg::Class::TargetMachine::addPassesToEmitFile);
     }
 
     pm.run(*module);

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`declare namespace llvm {`
`2`	`2`	`class APInt {`
`3`		`- public constructor(numBits: number, value: number, isSigned?: boolean);`
	`3`	`+ public constructor(numBits: number, value: number \| bigint, isSigned?: boolean);`
`4`	`4`	`}`
`5`	`5`
`6`	`6`	`class APFloat {`