@designliquido/llvm-bindings 0.1.0

package/include/ADT/APInt.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <napi.h>
+#include <llvm/ADT/APInt.h>
+
+class APInt : public Napi::ObjectWrap<APInt> {
+public:
+    static inline Napi::FunctionReference constructor; // NOLINT;
+
+    static void Init(Napi::Env env, Napi::Object &exports);
+
+    static bool IsClassOf(const Napi::Value &value);
+
+    static llvm::APInt &Extract(const Napi::Value &value);
+
+    explicit APInt(const Napi::CallbackInfo &info);
+
+    llvm::APInt &getLLVMPrimitive();
+
+private:
+    llvm::APInt *apInt = nullptr;
+};

package/include/ADT/index.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <napi.h>
+#include "ADT/APInt.h"
+#include "ADT/APFloat.h"
+
+void InitADT(Napi::Env env, Napi::Object &exports);

package/include/BinaryFormat/Dwarf.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <napi.h>
+#include <llvm/BinaryFormat/Dwarf.h>
+
+namespace dwarf {
+    void Init(Napi::Env env, Napi::Object &exports);
+}

package/include/BinaryFormat/index.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include <napi.h>
+#include "BinaryFormat/Dwarf.h"
+
+void InitBinaryFormat(Napi::Env env, Napi::Object &exports);

package/include/Bitcode/BitcodeWriter.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include <napi.h>
+#include <llvm/Bitcode/BitcodeWriter.h>
+
+void InitBitcodeWriter(Napi::Env env, Napi::Object &exports);

package/include/Bitcode/index.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include <napi.h>
+#include "Bitcode/BitcodeWriter.h"
+
+void InitBitCode(Napi::Env env, Napi::Object &exports);

package/include/Config/index.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include <napi.h>
+#include "Config/llvm-config.h"
+
+void InitConfig(Napi::Env env, Napi::Object &exports);

package/include/Config/llvm-config.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include <napi.h>
+#include <llvm/Config/llvm-config.h>
+
+void InitLLVMConfig(Napi::Env env, Napi::Object &exports);

package/include/IR/Argument.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <napi.h>
+#include <llvm/IR/Argument.h>
+
+class Argument : public Napi::ObjectWrap<Argument> {
+public:
+    static inline Napi::FunctionReference constructor; // NOLINT
+
+    static void Init(Napi::Env env, Napi::Object &exports);
+
+    static Napi::Object New(Napi::Env env, llvm::Argument *argument);
+
+    static bool IsClassOf(const Napi::Value &value);
+
+    static llvm::Argument *Extract(const Napi::Value &value);
+
+    explicit Argument(const Napi::CallbackInfo &info);
+
+    llvm::Argument *getLLVMPrimitive();
+
+private:
+    llvm::Argument *argument = nullptr;
+
+    Napi::Value getParent(const Napi::CallbackInfo &info);
+
+    Napi::Value getArgNo(const Napi::CallbackInfo &info);
+
+    Napi::Value getType(const Napi::CallbackInfo &info);
+
+    void setName(const Napi::CallbackInfo &info);
+};

package/include/IR/Attributes.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <napi.h>
+#include <llvm/IR/Attributes.h>
+
+class Attribute : public Napi::ObjectWrap<Attribute> {
+public:
+    static inline Napi::FunctionReference constructor; // NOLINT
+
+    static void Init(Napi::Env env, Napi::Object &exports);
+
+    static Napi::Object New(Napi::Env env, llvm::AttributeImpl *_attrImpl);
+
+    static bool IsClassOf(const Napi::Value &value);
+
+    static llvm::Attribute Extract(const Napi::Value &value);
+
+    explicit Attribute(const Napi::CallbackInfo &info);
+
+    llvm::Attribute getLLVMPrimitive();
+
+private:
+    llvm::AttributeImpl *attrImpl = nullptr;
+
+    static Napi::Value get(const Napi::CallbackInfo &info);
+};

package/include/IR/BasicBlock.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <napi.h>
+#include <llvm/IR/BasicBlock.h>
+
+class BasicBlock : public Napi::ObjectWrap<BasicBlock> {
+public:
+    static inline Napi::FunctionReference constructor; // NOLINT
+
+    static void Init(Napi::Env env, Napi::Object &exports);
+
+    static Napi::Object New(Napi::Env env, llvm::BasicBlock *basicBlock);
+
+    static bool IsClassOf(const Napi::Value &value);
+
+    static llvm::BasicBlock *Extract(const Napi::Value &value);
+
+    explicit BasicBlock(const Napi::CallbackInfo &info);
+
+    llvm::BasicBlock *getLLVMPrimitive();
+
+private:
+    llvm::BasicBlock *basicBlock = nullptr;
+
+    static Napi::Value Create(const Napi::CallbackInfo &info);
+
+    Napi::Value getParent(const Napi::CallbackInfo &info);
+
+    Napi::Value getModule(const Napi::CallbackInfo &info);
+
+    Napi::Value getTerminator(const Napi::CallbackInfo &info);
+
+    Napi::Value getFirstNonPHI(const Napi::CallbackInfo &info);
+
+    void insertInto(const Napi::CallbackInfo &info);
+
+    void removeFromParent(const Napi::CallbackInfo &info);
+
+    void eraseFromParent(const Napi::CallbackInfo &info);
+
+    Napi::Value useEmpty(const Napi::CallbackInfo &info);
+
+    Napi::Value getType(const Napi::CallbackInfo &info);
+
+    void deleteSelf(const Napi::CallbackInfo &info);
+};

package/include/IR/Constant.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <napi.h>
+#include <llvm/IR/Constant.h>
+
+class Constant : public Napi::ObjectWrap<Constant> {
+public:
+    static inline Napi::FunctionReference constructor; // NOLINT
+
+    static void Init(Napi::Env env, Napi::Object &exports);
+
+    static Napi::Object New(Napi::Env env, llvm::Constant *constant);
+
+    static bool IsClassOf(const Napi::Value &value);
+
+    static llvm::Constant *Extract(const Napi::Value &value);
+
+    explicit Constant(const Napi::CallbackInfo &info);
+
+    llvm::Constant *getLLVMPrimitive();
+
+private:
+    llvm::Constant *constant = nullptr;
+
+    static Napi::Value getNullValue(const Napi::CallbackInfo &info);
+
+    static Napi::Value getAllOnesValue(const Napi::CallbackInfo &info);
+
+    Napi::Value isNullValue(const Napi::CallbackInfo &info);
+
+    Napi::Value isOneValue(const Napi::CallbackInfo &info);
+
+    Napi::Value isAllOnesValue(const Napi::CallbackInfo &info);
+
+    Napi::Value getType(const Napi::CallbackInfo &info);
+};

package/include/IR/Constants.h

@@ -0,0 +1,200 @@
+#pragma once
+
+#include <napi.h>
+#include <llvm/IR/Constants.h>
+
+class ConstantInt : public Napi::ObjectWrap<ConstantInt> {
+public:
+    static inline Napi::FunctionReference constructor; // NOLINT
+
+    static void Init(Napi::Env env, Napi::Object &exports);
+
+    static Napi::Object New(Napi::Env env, llvm::ConstantInt *constantInt);
+
+    static bool IsClassOf(const Napi::Value &value);
+
+    static llvm::ConstantInt *Extract(const Napi::Value &value);
+
+    explicit ConstantInt(const Napi::CallbackInfo &info);
+
+    llvm::ConstantInt *getLLVMPrimitive();
+
+private:
+    llvm::ConstantInt *constantInt = nullptr;
+
+    static Napi::Value get(const Napi::CallbackInfo &info);
+
+    Napi::Value getType(const Napi::CallbackInfo &info);
+};
+
+class ConstantFP : public Napi::ObjectWrap<ConstantFP> {
+public:
+    static inline Napi::FunctionReference constructor; // NOLINT
+
+    static void Init(Napi::Env env, Napi::Object &exports);
+
+    static Napi::Object New(Napi::Env env, llvm::ConstantFP *constantFP);
+
+    static bool IsClassOf(const Napi::Value &value);
+
+    static llvm::ConstantFP *Extract(const Napi::Value &value);
+
+    explicit ConstantFP(const Napi::CallbackInfo &info);
+
+    llvm::ConstantFP *getLLVMPrimitive();
+
+private:
+    llvm::ConstantFP *constantFP = nullptr;
+
+    static Napi::Value get(const Napi::CallbackInfo &info);
+
+    static Napi::Value getNaN(const Napi::CallbackInfo &info);
+
+    Napi::Value getType(const Napi::CallbackInfo &info);
+};
+
+class ConstantArray : public Napi::ObjectWrap<ConstantArray> {
+public:
+    static inline Napi::FunctionReference constructor; // NOLINT
+
+    static void Init(Napi::Env env, Napi::Object &exports);
+
+    static Napi::Object New(Napi::Env env, llvm::ConstantArray *constantArray);
+
+    static bool IsClassOf(const Napi::Value &value);
+
+    static llvm::ConstantArray *Extract(const Napi::Value &value);
+
+    explicit ConstantArray(const Napi::CallbackInfo &info);
+
+    llvm::ConstantArray *getLLVMPrimitive();
+
+private:
+    llvm::ConstantArray *constantArray = nullptr;
+
+    static Napi::Value get(const Napi::CallbackInfo &info);
+
+    Napi::Value getType(const Napi::CallbackInfo &info);
+};
+
+class ConstantStruct : public Napi::ObjectWrap<ConstantStruct> {
+public:
+    static inline Napi::FunctionReference constructor; // NOLINT
+
+    static void Init(Napi::Env env, Napi::Object &exports);
+
+    static Napi::Object New(Napi::Env env, llvm::ConstantStruct *constantStruct);
+
+    static bool IsClassOf(const Napi::Value &value);
+
+    static llvm::ConstantStruct *Extract(const Napi::Value &value);
+
+    explicit ConstantStruct(const Napi::CallbackInfo &info);
+
+    llvm::ConstantStruct *getLLVMPrimitive();
+
+private:
+    llvm::ConstantStruct *constantStruct = nullptr;
+
+    static Napi::Value get(const Napi::CallbackInfo &info);
+
+    Napi::Value getType(const Napi::CallbackInfo &info);
+};
+
+class ConstantPointerNull : public Napi::ObjectWrap<ConstantPointerNull> {
+public:
+    static inline Napi::FunctionReference constructor; // NOLINT
+
+    static void Init(Napi::Env env, Napi::Object &exports);
+
+    static Napi::Object New(Napi::Env env, llvm::ConstantPointerNull *constantPointerNull);
+
+    static bool IsClassOf(const Napi::Value &value);
+
+    static llvm::ConstantPointerNull *Extract(const Napi::Value &value);
+
+    explicit ConstantPointerNull(const Napi::CallbackInfo &info);
+
+    llvm::ConstantPointerNull *getLLVMPrimitive();
+
+private:
+    llvm::ConstantPointerNull *constantPointerNull = nullptr;
+
+    static Napi::Value get(const Napi::CallbackInfo &info);
+
+    Napi::Value getType(const Napi::CallbackInfo &info);
+};
+
+class ConstantDataArray : public Napi::ObjectWrap<ConstantDataArray> {
+public:
+    static inline Napi::FunctionReference constructor; // NOLINT
+
+    static void Init(Napi::Env env, Napi::Object &exports);
+
+    static Napi::Object New(Napi::Env env, llvm::ConstantDataArray *constantDataArray);
+
+    static bool IsClassOf(const Napi::Value &value);
+
+    static llvm::ConstantDataArray *Extract(const Napi::Value &value);
+
+    explicit ConstantDataArray(const Napi::CallbackInfo &info);
+
+    llvm::ConstantDataArray *getLLVMPrimitive();
+
+private:
+    llvm::ConstantDataArray *constantDataArray = nullptr;
+
+    static Napi::Value get(const Napi::CallbackInfo &info);
+
+    static Napi::Value getString(const Napi::CallbackInfo &info);
+
+    Napi::Value getType(const Napi::CallbackInfo &info);
+};
+
+class ConstantExpr : public Napi::ObjectWrap<ConstantExpr> {
+public:
+    static inline Napi::FunctionReference constructor; // NOLINT
+
+    static void Init(Napi::Env env, Napi::Object &exports);
+
+    static Napi::Object New(Napi::Env env, llvm::ConstantExpr *constantExpr);
+
+    static bool IsClassOf(const Napi::Value &value);
+
+    static llvm::ConstantExpr *Extract(const Napi::Value &value);
+
+    explicit ConstantExpr(const Napi::CallbackInfo &info);
+
+    llvm::ConstantExpr *getLLVMPrimitive();
+
+private:
+    llvm::ConstantExpr *constantExpr = nullptr;
+
+    static Napi::Value getBitCast(const Napi::CallbackInfo &info);
+
+    Napi::Value getType(const Napi::CallbackInfo &info);
+};
+
+class UndefValue : public Napi::ObjectWrap<UndefValue> {
+public:
+    static inline Napi::FunctionReference constructor; // NOLINT
+
+    static void Init(Napi::Env env, Napi::Object &exports);
+
+    static Napi::Object New(Napi::Env env, llvm::UndefValue *undefValue);
+
+    static bool IsClassOf(const Napi::Value &value);
+
+    static llvm::UndefValue *Extract(const Napi::Value &value);
+
+    explicit UndefValue(const Napi::CallbackInfo &info);
+
+    llvm::UndefValue *getLLVMPrimitive();
+
+private:
+    llvm::UndefValue *undefValue = nullptr;
+
+    static Napi::Value get(const Napi::CallbackInfo &info);
+
+    Napi::Value getType(const Napi::CallbackInfo &info);
+};

package/include/IR/DIBuilder.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <napi.h>
+#include <llvm/IR/DIBuilder.h>
+
+class DIBuilder : public Napi::ObjectWrap<DIBuilder> {
+public:
+    static inline Napi::FunctionReference constructor; // NOLINT
+
+    static void Init(Napi::Env env, Napi::Object &exports);
+
+    static Napi::Value New(Napi::Env env, llvm::DIBuilder *builder);
+
+    static bool IsClassOf(const Napi::Value &value);
+
+    static llvm::DIBuilder *Extract(const Napi::Value &value);
+
+    explicit DIBuilder(const Napi::CallbackInfo &info);
+
+    llvm::DIBuilder *getLLVMPrimitive();
+
+private:
+    llvm::DIBuilder *builder = nullptr;
+
+    Napi::Value createFile(const Napi::CallbackInfo &info);
+
+    Napi::Value createCompileUnit(const Napi::CallbackInfo &info);
+
+    Napi::Value createFunction(const Napi::CallbackInfo &info);
+
+    Napi::Value createLexicalBlock(const Napi::CallbackInfo &info);
+
+    Napi::Value createBasicType(const Napi::CallbackInfo &info);
+
+    Napi::Value getOrCreateTypeArray(const Napi::CallbackInfo &info);
+
+    Napi::Value createSubroutineType(const Napi::CallbackInfo &info);
+
+    Napi::Value createExpression(const Napi::CallbackInfo &info);
+
+    Napi::Value createParameterVariable(const Napi::CallbackInfo &info);
+
+    Napi::Value createAutoVariable(const Napi::CallbackInfo &info);
+
+    Napi::Value createGlobalVariableExpression(const Napi::CallbackInfo &info);
+
+    Napi::Value insertDeclare(const Napi::CallbackInfo &info);
+
+    Napi::Value insertDbgValueIntrinsic(const Napi::CallbackInfo &info);
+
+    void finalizeSubprogram(const Napi::CallbackInfo &info);
+
+    void finalize(const Napi::CallbackInfo &info);
+};

package/include/IR/DataLayout.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <napi.h>
+#include <llvm/IR/DataLayout.h>
+
+class DataLayout : public Napi::ObjectWrap<DataLayout> {
+public:
+    static inline Napi::FunctionReference constructor; // NOLINT
+
+    static void Init(Napi::Env env, Napi::Object &exports);
+
+    static Napi::Object New(Napi::Env env, llvm::DataLayout *dl);
+
+    static bool IsClassOf(const Napi::Value &value);
+
+    static llvm::DataLayout &Extract(const Napi::Value &value);
+
+    explicit DataLayout(const Napi::CallbackInfo &info);
+
+    llvm::DataLayout &getLLVMPrimitive();
+
+private:
+    llvm::DataLayout *dataLayout = nullptr;
+
+    Napi::Value getStringRepresentation(const Napi::CallbackInfo &info);
+
+    Napi::Value getTypeAllocSize(const Napi::CallbackInfo &info);
+};