@designliquido/llvm-bindings 0.1.0

package/src/IR/Function.cpp

@@ -0,0 +1,279 @@
+#include "IR/index.h"
+#include "Util/index.h"
+
+void Function::Init(Napi::Env env, Napi::Object &exports) {
+    Napi::HandleScope scope(env);
+    Napi::Function func = DefineClass(env, "Function", {
+            StaticMethod("Create", &Function::Create),
+            InstanceMethod("arg_size", &Function::argSize),
+            InstanceMethod("getArg", &Function::getArg),
+            InstanceMethod("getReturnType", &Function::getReturnType),
+            InstanceMethod("addBasicBlock", &Function::addBasicBlock),
+            InstanceMethod("getEntryBlock", &Function::getEntryBlock),
+            InstanceMethod("getExitBlock", &Function::getExitBlock),
+            InstanceMethod("insertAfter", &Function::insertAfter),
+            InstanceMethod("deleteBody", &Function::deleteBody),
+            InstanceMethod("removeFromParent", &Function::removeFromParent),
+            InstanceMethod("eraseFromParent", &Function::eraseFromParent),
+            InstanceMethod("use_empty", &Function::useEmpty),
+            InstanceMethod("user_empty", &Function::userEmpty),
+            InstanceMethod("getNumUses", &Function::getNumUses),
+            InstanceMethod("removeDeadConstantUsers", &Function::removeDeadConstantUsers),
+            InstanceMethod("hasPersonalityFn", &Function::hasPersonalityFn),
+            InstanceMethod("setPersonalityFn", &Function::setPersonalityFn),
+            InstanceMethod("setDoesNotThrow", &Function::setDoesNotThrow),
+            InstanceMethod("setSubprogram", &Function::setSubprogram),
+            InstanceMethod("getSubprogram", &Function::getSubprogram),
+            InstanceMethod("getType", &Function::getType),
+            InstanceMethod("addFnAttr", &Function::addFnAttr),
+            InstanceMethod("addParamAttr", &Function::addParamAttr),
+            InstanceMethod("addRetAttr", &Function::addRetAttr)
+    });
+    constructor = Napi::Persistent(func);
+    constructor.SuppressDestruct();
+    Inherit(env, constructor.Value(), GlobalObject::constructor.Value());
+    exports.Set("Function", func);
+}
+
+Napi::Object Function::New(Napi::Env env, llvm::Function *function) {
+    return constructor.New({Napi::External<llvm::Function>::New(env, function)});
+}
+
+bool Function::IsClassOf(const Napi::Value &value) {
+    return value.IsNull() || value.As<Napi::Object>().InstanceOf(constructor.Value());
+}
+
+llvm::Function *Function::Extract(const Napi::Value &value) {
+    if (value.IsNull()) {
+        return nullptr;
+    }
+    return Unwrap(value.As<Napi::Object>())->getLLVMPrimitive();
+}
+
+Function::Function(const Napi::CallbackInfo &info) : ObjectWrap(info) {
+    Napi::Env env = info.Env();
+    if (!info.IsConstructCall() || info.Length() == 0 || !info[0].IsExternal()) {
+        throw Napi::TypeError::New(env, ErrMsg::Class::Function::Create);
+    }
+    auto external = info[0].As<Napi::External<llvm::Function>>();
+    function = external.Data();
+}
+
+Napi::Value Function::Create(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    unsigned argsLen = info.Length();
+    if (argsLen < 2 ||
+        !FunctionType::IsClassOf(info[0]) ||
+        !info[1].IsNumber() ||
+        argsLen >= 3 && !info[2].IsString() ||
+        argsLen >= 4 && !Module::IsClassOf(info[3])) {
+        throw Napi::TypeError::New(env, ErrMsg::Class::Function::Create);
+    }
+    llvm::FunctionType *funcType = FunctionType::Extract(info[0]);
+    llvm::GlobalValue::LinkageTypes linkage = static_cast<llvm::GlobalValue::LinkageTypes>(info[1].As<Napi::Number>().Uint32Value());
+    std::string name;
+    llvm::Module *module = nullptr;
+    if (argsLen >= 3) {
+        name = info[2].As<Napi::String>();
+    }
+    if (argsLen >= 4) {
+        module = Module::Extract(info[3]);
+    }
+    llvm::Function *function = llvm::Function::Create(funcType, linkage, static_cast<unsigned>(-1), name, module);
+    return Function::New(env, function);
+}
+
+llvm::Function *Function::getLLVMPrimitive() {
+    return function;
+}
+
+Napi::Value Function::argSize(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    return Napi::Number::New(env, double(function->arg_size()));
+}
+
+Napi::Value Function::getArg(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    if (info.Length() >= 1 && info[0].IsNumber()) {
+        llvm::Argument *arg = function->getArg(info[0].As<Napi::Number>());
+        return Argument::New(env, arg);
+    }
+    throw Napi::TypeError::New(env, ErrMsg::Class::Function::getArg);
+}
+
+Napi::Value Function::getReturnType(const Napi::CallbackInfo &info) {
+    return Type::New(info.Env(), function->getReturnType());
+}
+
+void Function::addBasicBlock(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    if (info.Length() == 0 || !BasicBlock::IsClassOf(info[0])) {
+        throw Napi::TypeError::New(env, ErrMsg::Class::Function::addBasicBlock);
+    }
+    llvm::BasicBlock *basicBlock = BasicBlock::Extract(info[0]);
+    function->getBasicBlockList().push_back(basicBlock);
+}
+
+Napi::Value Function::getEntryBlock(const Napi::CallbackInfo &info) {
+    return BasicBlock::New(info.Env(), &(function->getEntryBlock()));
+}
+
+Napi::Value Function::getExitBlock(const Napi::CallbackInfo &info) {
+    return BasicBlock::New(info.Env(), &(function->back()));
+}
+
+void Function::insertAfter(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    if (info.Length() < 2 || !BasicBlock::IsClassOf(info[0]) || !BasicBlock::IsClassOf(info[1])) {
+        throw Napi::TypeError::New(env, ErrMsg::Class::Function::insertAfter);
+    }
+    llvm::BasicBlock *where = BasicBlock::Extract(info[0]);
+    llvm::BasicBlock *bb = BasicBlock::Extract(info[1]);
+    function->getBasicBlockList().insertAfter(where->getIterator(), bb);
+}
+
+void Function::deleteBody(const Napi::CallbackInfo &info) {
+    function->deleteBody();
+}
+
+void Function::removeFromParent(const Napi::CallbackInfo &info) {
+    function->removeFromParent();
+}
+
+void Function::eraseFromParent(const Napi::CallbackInfo &info) {
+    function->eraseFromParent();
+}
+
+Napi::Value Function::useEmpty(const Napi::CallbackInfo &info) {
+    return Napi::Boolean::New(info.Env(), function->use_empty());
+}
+
+Napi::Value Function::userEmpty(const Napi::CallbackInfo &info) {
+    return Napi::Boolean::New(info.Env(), function->user_empty());
+}
+
+Napi::Value Function::getNumUses(const Napi::CallbackInfo &info) {
+    return Napi::Number::New(info.Env(), function->getNumUses());
+}
+
+void Function::removeDeadConstantUsers(const Napi::CallbackInfo &info) {
+    function->removeDeadConstantUsers();
+}
+
+Napi::Value Function::hasPersonalityFn(const Napi::CallbackInfo &info) {
+    return Napi::Boolean::New(info.Env(), function->hasPersonalityFn());
+}
+
+void Function::setPersonalityFn(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    if (info.Length() == 1 && Constant::IsClassOf(info[0])) {
+        llvm::Constant *fn = Constant::Extract(info[0]);
+        function->setPersonalityFn(fn);
+        return;
+    }
+    throw Napi::TypeError::New(env, ErrMsg::Class::Function::setPersonalityFn);
+}
+
+void Function::setDoesNotThrow(const Napi::CallbackInfo &info) {
+    function->setDoesNotThrow();
+}
+
+void Function::setSubprogram(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    if (info.Length() == 1 && DISubprogram::IsClassOf(info[0])) {
+        llvm::DISubprogram *subprogram = DISubprogram::Extract(info[0]);
+        function->setSubprogram(subprogram);
+        return;
+    }
+    throw Napi::TypeError::New(env, ErrMsg::Class::Function::setSubprogram);
+}
+
+Napi::Value Function::getSubprogram(const Napi::CallbackInfo &info) {
+    return DISubprogram::New(info.Env(), function->getSubprogram());
+}
+
+Napi::Value Function::getType(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    llvm::PointerType *type = function->getType();
+    return PointerType::New(env, type);
+}
+
+void Function::addFnAttr(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+
+    unsigned argsLen = info.Length();
+
+    if (argsLen >= 1 && argsLen <= 2) {
+        if (argsLen == 1 && info[0].IsNumber()) {
+            unsigned rawAttrKind = info[0].As<Napi::Number>();
+            if (rawAttrKind < llvm::Attribute::AttrKind::FirstEnumAttr ||
+                rawAttrKind > llvm::Attribute::AttrKind::LastEnumAttr) {
+                throw Napi::TypeError::New(env, ErrMsg::Class::Attribute::invalidAttrKind);
+            }
+            function->addFnAttr(static_cast<llvm::Attribute::AttrKind>(rawAttrKind));
+            return;
+        } else if (argsLen == 1 && Attribute::IsClassOf(info[0])) {
+            llvm::Attribute attr = Attribute::Extract(info[0]);
+            function->addFnAttr(attr);
+            return;
+        } else if (info[0].IsString()) {
+            std::string attrKind = info[0].As<Napi::String>();
+            if (argsLen == 1) {
+                function->addFnAttr(attrKind);
+                return;
+            } else if (argsLen == 2 && info[1].IsString()) {
+                std::string value = info[1].As<Napi::String>();
+                function->addFnAttr(attrKind, value);
+                return;
+            }
+        }
+    }
+
+    throw Napi::TypeError::New(env, ErrMsg::Class::Function::addFnAttr);
+}
+
+void Function::addParamAttr(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() == 2 && info[0].IsNumber()) {
+        unsigned argNo = info[0].As<Napi::Number>();
+
+        if (info[1].IsNumber()) {
+            unsigned rawAttrKind = info[1].As<Napi::Number>();
+            if (rawAttrKind < llvm::Attribute::AttrKind::FirstEnumAttr ||
+                rawAttrKind > llvm::Attribute::AttrKind::LastEnumAttr) {
+                throw Napi::TypeError::New(env, ErrMsg::Class::Attribute::invalidAttrKind);
+            }
+            function->addParamAttr(argNo, static_cast<llvm::Attribute::AttrKind>(rawAttrKind));
+            return;
+        } else if (Attribute::IsClassOf(info[1])) {
+            llvm::Attribute attr = Attribute::Extract(info[1]);
+            function->addParamAttr(argNo, attr);
+            return;
+        }
+    }
+
+    throw Napi::TypeError::New(env, ErrMsg::Class::Function::addParamAttr);
+}
+
+void Function::addRetAttr(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() == 1) {
+        if (info[0].IsNumber()) {
+            unsigned rawAttrKind = info[0].As<Napi::Number>();
+            if (rawAttrKind < llvm::Attribute::AttrKind::FirstEnumAttr ||
+                rawAttrKind > llvm::Attribute::AttrKind::LastEnumAttr) {
+                throw Napi::TypeError::New(env, ErrMsg::Class::Attribute::invalidAttrKind);
+            }
+            function->addRetAttr(static_cast<llvm::Attribute::AttrKind>(rawAttrKind));
+            return;
+        } else if (Attribute::IsClassOf(info[0])) {
+            llvm::Attribute attr = Attribute::Extract(info[0]);
+            function->addRetAttr(attr);
+            return;
+        }
+    }
+
+    throw Napi::TypeError::New(env, ErrMsg::Class::Function::addRetAttr);
+}

package/src/IR/GlobalObject.cpp

@@ -0,0 +1,59 @@
+#include "IR/index.h"
+#include "Util/index.h"
+
+void GlobalObject::Init(Napi::Env env, Napi::Object &exports) {
+    Napi::HandleScope scope(env);
+    Napi::Function func = DefineClass(env, "GlobalObject", {
+            InstanceMethod("getType", &GlobalObject::getType),
+            InstanceMethod("getValueType", &GlobalObject::getValueType)
+    });
+    constructor = Napi::Persistent(func);
+    constructor.SuppressDestruct();
+    Inherit(env, constructor.Value(), GlobalValue::constructor.Value());
+    exports.Set("GlobalObject", func);
+}
+
+Napi::Object GlobalObject::New(Napi::Env env, llvm::GlobalObject *globalObject) {
+    if (llvm::isa<llvm::Function>(globalObject)) {
+        return Function::New(env, llvm::cast<llvm::Function>(globalObject));
+    } else if (llvm::isa<llvm::GlobalVariable>(globalObject)) {
+        return GlobalVariable::New(env, llvm::cast<llvm::GlobalVariable>(globalObject));
+    }
+    return constructor.New({Napi::External<llvm::GlobalObject>::New(env, globalObject)});
+}
+
+bool GlobalObject::IsClassOf(const Napi::Value &value) {
+    return value.IsNull() || value.As<Napi::Object>().InstanceOf(constructor.Value());
+}
+
+llvm::GlobalObject *GlobalObject::Extract(const Napi::Value &value) {
+    if (value.IsNull()) {
+        return nullptr;
+    }
+    return Unwrap(value.As<Napi::Object>())->getLLVMPrimitive();
+}
+
+GlobalObject::GlobalObject(const Napi::CallbackInfo &info) : ObjectWrap(info) {
+    Napi::Env env = info.Env();
+    if (!info.IsConstructCall() || info.Length() == 0 || !info[0].IsExternal()) {
+        throw Napi::TypeError::New(env, ErrMsg::Class::GlobalObject::constructor);
+    }
+    auto external = info[0].As<Napi::External<llvm::GlobalObject>>();
+    globalObject = external.Data();
+}
+
+llvm::GlobalObject *GlobalObject::getLLVMPrimitive() {
+    return globalObject;
+}
+
+Napi::Value GlobalObject::getType(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    llvm::PointerType *type = globalObject->getType();
+    return PointerType::New(env, type);
+}
+
+Napi::Value GlobalObject::getValueType(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    llvm::Type *type = globalObject->getValueType();
+    return Type::New(env, type);
+}

package/src/IR/GlobalValue.cpp

@@ -0,0 +1,75 @@
+#include "IR/index.h"
+#include "Util/index.h"
+
+void GlobalValue::Init(Napi::Env env, Napi::Object &exports) {
+    Napi::HandleScope scope(env);
+    Napi::Object linkageTypes = Napi::Object::New(env);
+    linkageTypes.Set("ExternalLinkage", Napi::Number::New(env, llvm::GlobalValue::LinkageTypes::ExternalLinkage));
+    linkageTypes.Set("AvailableExternallyLinkage", Napi::Number::New(env, llvm::GlobalValue::LinkageTypes::AvailableExternallyLinkage));
+    linkageTypes.Set("LinkOnceAnyLinkage", Napi::Number::New(env, llvm::GlobalValue::LinkageTypes::LinkOnceAnyLinkage));
+    linkageTypes.Set("LinkOnceODRLinkage", Napi::Number::New(env, llvm::GlobalValue::LinkageTypes::LinkOnceODRLinkage));
+    linkageTypes.Set("WeakAnyLinkage", Napi::Number::New(env, llvm::GlobalValue::LinkageTypes::WeakAnyLinkage));
+    linkageTypes.Set("WeakODRLinkage", Napi::Number::New(env, llvm::GlobalValue::LinkageTypes::WeakODRLinkage));
+    linkageTypes.Set("AppendingLinkage", Napi::Number::New(env, llvm::GlobalValue::LinkageTypes::AppendingLinkage));
+    linkageTypes.Set("InternalLinkage", Napi::Number::New(env, llvm::GlobalValue::LinkageTypes::InternalLinkage));
+    linkageTypes.Set("PrivateLinkage", Napi::Number::New(env, llvm::GlobalValue::LinkageTypes::PrivateLinkage));
+    linkageTypes.Set("ExternalWeakLinkage", Napi::Number::New(env, llvm::GlobalValue::LinkageTypes::ExternalWeakLinkage));
+    linkageTypes.Set("CommonLinkage", Napi::Number::New(env, llvm::GlobalValue::LinkageTypes::CommonLinkage));
+    Napi::Object visibilityTypes = Napi::Object::New(env);
+    visibilityTypes.Set("DefaultVisibility", Napi::Number::New(env, llvm::GlobalValue::VisibilityTypes::DefaultVisibility));
+    visibilityTypes.Set("HiddenVisibility", Napi::Number::New(env, llvm::GlobalValue::VisibilityTypes::HiddenVisibility));
+    visibilityTypes.Set("ProtectedVisibility", Napi::Number::New(env, llvm::GlobalValue::VisibilityTypes::ProtectedVisibility));
+    Napi::Function func = DefineClass(env, "GlobalValue", {
+            StaticValue("LinkageTypes", linkageTypes),
+            StaticValue("VisibilityTypes", visibilityTypes),
+            InstanceMethod("getType", &GlobalValue::getType),
+            InstanceMethod("getValueType", &GlobalValue::getValueType)
+    });
+    constructor = Napi::Persistent(func);
+    constructor.SuppressDestruct();
+    Inherit(env, constructor.Value(), Constant::constructor.Value());
+    exports.Set("GlobalValue", func);
+}
+
+Napi::Object GlobalValue::New(Napi::Env env, llvm::GlobalValue *globalValue) {
+    if (llvm::isa<llvm::GlobalObject>(globalValue)) {
+        return GlobalObject::New(env, llvm::cast<llvm::GlobalObject>(globalValue));
+    }
+    return constructor.New({Napi::External<llvm::GlobalValue>::New(env, globalValue)});
+}
+
+bool GlobalValue::IsClassOf(const Napi::Value &value) {
+    return value.IsNull() || value.As<Napi::Object>().InstanceOf(constructor.Value());
+}
+
+llvm::GlobalValue *GlobalValue::Extract(const Napi::Value &value) {
+    if (value.IsNull()) {
+        return nullptr;
+    }
+    return Unwrap(value.As<Napi::Object>())->getLLVMPrimitive();
+}
+
+GlobalValue::GlobalValue(const Napi::CallbackInfo &info) : ObjectWrap(info) {
+    Napi::Env env = info.Env();
+    if (!info.IsConstructCall() || info.Length() == 0 || !info[0].IsExternal()) {
+        throw Napi::TypeError::New(env, ErrMsg::Class::GlobalValue::constructor);
+    }
+    auto external = info[0].As<Napi::External<llvm::GlobalValue>>();
+    globalValue = external.Data();
+}
+
+llvm::GlobalValue *GlobalValue::getLLVMPrimitive() {
+    return globalValue;
+}
+
+Napi::Value GlobalValue::getType(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    llvm::PointerType *type = globalValue->getType();
+    return PointerType::New(env, type);
+}
+
+Napi::Value GlobalValue::getValueType(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    llvm::Type *type = globalValue->getValueType();
+    return Type::New(env, type);
+}

package/src/IR/GlobalVariable.cpp

@@ -0,0 +1,122 @@
+#include "IR/index.h"
+#include "Util/index.h"
+
+void GlobalVariable::Init(Napi::Env env, Napi::Object &exports) {
+    Napi::HandleScope scope(env);
+    Napi::Function func = DefineClass(env, "GlobalVariable", {
+            InstanceMethod("getType", &GlobalVariable::getType),
+            InstanceMethod("getValueType", &GlobalVariable::getValueType),
+            InstanceMethod("setInitializer", &GlobalVariable::setInitializer),
+            InstanceMethod("removeFromParent", &GlobalVariable::removeFromParent),
+            InstanceMethod("eraseFromParent", &GlobalVariable::eraseFromParent),
+            InstanceMethod("addDebugInfo", &GlobalVariable::addDebugInfo)
+    });
+    constructor = Napi::Persistent(func);
+    constructor.SuppressDestruct();
+    Inherit(env, constructor.Value(), GlobalObject::constructor.Value());
+    exports.Set("GlobalVariable", func);
+}
+
+Napi::Object GlobalVariable::New(Napi::Env env, llvm::GlobalVariable *variable) {
+    return constructor.New({Napi::External<llvm::GlobalVariable>::New(env, variable)});
+}
+
+bool GlobalVariable::IsClassOf(const Napi::Value &value) {
+    return value.IsNull() || value.As<Napi::Object>().InstanceOf(constructor.Value());
+}
+
+llvm::GlobalVariable *GlobalVariable::Extract(const Napi::Value &value) {
+    if (value.IsNull()) {
+        return nullptr;
+    }
+    return Unwrap(value.As<Napi::Object>())->getLLVMPrimitive();
+}
+
+GlobalVariable::GlobalVariable(const Napi::CallbackInfo &info) : ObjectWrap(info) {
+    Napi::Env env = info.Env();
+    if (!info.IsConstructCall()) {
+        throw Napi::TypeError::New(env, ErrMsg::Class::GlobalVariable::constructor);
+    }
+    unsigned argsLen = info.Length();
+    if (argsLen >= 1 && info[0].IsExternal()) {
+        auto external = info[0].As<Napi::External<llvm::GlobalVariable>>();
+        globalVariable = external.Data();
+        return;
+    } else if (argsLen >= 3 &&
+               Type::IsClassOf(info[0]) &&
+               info[1].IsBoolean() &&
+               info[2].IsNumber()) {
+        if (argsLen == 3 ||
+            argsLen >= 4 && Constant::IsClassOf(info[3]) ||
+            argsLen >= 5 && info[4].IsString()) {
+            llvm::Type *type = Type::Extract(info[0]);
+            bool isConstant = info[1].As<Napi::Boolean>();
+            llvm::GlobalValue::LinkageTypes linkage = static_cast<llvm::GlobalValue::LinkageTypes>(info[2].As<Napi::Number>().Uint32Value());
+            llvm::Constant *initializer = argsLen >= 4 ? Constant::Extract(info[3]) : nullptr;
+            std::string name = argsLen >= 5 ? std::string(info[4].As<Napi::String>()) : "";
+            globalVariable = new llvm::GlobalVariable(type, isConstant, linkage, initializer, name);
+            return;
+        }
+    } else if (argsLen >= 5 &&
+               Module::IsClassOf(info[0]) &&
+               Type::IsClassOf(info[1]) &&
+               info[2].IsBoolean() &&
+               info[3].IsNumber() &&
+               Constant::IsClassOf(info[4])) {
+        if (argsLen == 5 || argsLen >= 6 && info[5].IsString()) {
+            llvm::Module *module = Module::Extract(info[0]);
+            llvm::Type *type = Type::Extract(info[1]);
+            bool isConstant = info[2].As<Napi::Boolean>();
+            llvm::GlobalValue::LinkageTypes linkage = static_cast<llvm::GlobalValue::LinkageTypes>(info[3].As<Napi::Number>().Uint32Value());
+            llvm::Constant *initializer = Constant::Extract(info[4]);
+            std::string name = argsLen >= 6 ? std::string(info[5].As<Napi::String>()) : "";
+            globalVariable = new llvm::GlobalVariable(*module, type, isConstant, linkage, initializer, name);
+            return;
+        }
+    }
+    throw Napi::TypeError::New(env, ErrMsg::Class::GlobalVariable::constructor);
+}
+
+llvm::GlobalVariable *GlobalVariable::getLLVMPrimitive() {
+    return globalVariable;
+}
+
+Napi::Value GlobalVariable::getType(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    llvm::PointerType *type = globalVariable->getType();
+    return PointerType::New(env, type);
+}
+
+Napi::Value GlobalVariable::getValueType(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    llvm::Type *type = globalVariable->getValueType();
+    return Type::New(env, type);
+}
+
+void GlobalVariable::setInitializer(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    if (info.Length() == 1 && Constant::IsClassOf(info[0])) {
+        llvm::Constant *initVal = Constant::Extract(info[0]);
+        globalVariable->setInitializer(initVal);
+        return;
+    }
+    throw Napi::TypeError::New(env, ErrMsg::Class::GlobalVariable::setInitializer);
+}
+
+void GlobalVariable::removeFromParent(const Napi::CallbackInfo &info) {
+    globalVariable->removeFromParent();
+}
+
+void GlobalVariable::eraseFromParent(const Napi::CallbackInfo &info) {
+    globalVariable->eraseFromParent();
+}
+
+void GlobalVariable::addDebugInfo(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    if (info.Length() == 1 && DIGlobalVariableExpression::IsClassOf(info[0])) {
+        llvm::DIGlobalVariableExpression *gv = DIGlobalVariableExpression::Extract(info[0]);
+        globalVariable->addDebugInfo(gv);
+        return;
+    }
+    throw Napi::TypeError::New(env, ErrMsg::Class::GlobalVariable::addDebugInfo);
+}