Add ConstantAggregateZero ConstantExpr and a few more methods

llvm-node.d.ts

@@ -98,6 +98,16 @@ declare namespace llvm {
     Protected
   }
 
+  enum AtomicOrdering {
+    NotAtomic,
+    Unordered,
+    Monotonic,
+    Acquire,
+    Release,
+    AcquireRelease,
+    SequentiallyConsistent
+  }
+
   class Value {
     static MaxAlignmentExponent: number;
     static MaximumAlignment: number;
@@ -173,6 +183,32 @@ declare namespace llvm {
     isAllOnesValue(): boolean;
   }
 
+  class ConstantAggregateZero extends Constant {
+      static get(type: Type): Constant;
+
+      private constructor();
+  }
+
+  class ConstantExpr extends Constant {
+    static getPointerCast(constant: Constant, type: Type): Constant;
+
+    static getIntegerCast(constant: Constant, type: Type): Constant;
+
+    static getFPCast(constant: Constant, type: Type): Constant;
+
+    static getBitCast(constant: Constant, type: Type): Constant;
+
+    static getGetElementPtr(type: Type, constant: Constant, idxList: Constant[], inBounds?: boolean): Constant;
+
+    static getOr(constant1: Constant, constant2: Constant): Constant;
+
+    static getPointerBitCastOrAddrSpaceCast(constant: Constant, type: Type): Constant;
+
+    static getAlignOf(type: Type): Constant;
+
+    static getSizeOf(type: Type): Constant;
+  }
+
   class ConstantFP extends Constant {
     static get(context: LLVMContext, value: number): ConstantFP;
     static get(type: Type, value: string): Constant;
@@ -367,7 +403,11 @@ declare namespace llvm {
 
     getTypeStoreSize(type: Type): number;
 
-    getIntPtrType(context: LLVMContext, as: number): Type;
+    getTypeAllocSize(type: Type): number;
+
+    getTypeAllocSizeInBits(type: Type): number;
+
+    getIntPtrType(context: LLVMContext, as: number): IntegerType;
   }
 
   class Type {
@@ -450,6 +490,7 @@ declare namespace llvm {
 
     isArrayTy(): boolean;
 
+    isFloatingPointTy(): boolean;
     isHalfTy(): boolean;
 
     isPointerTy(): this is PointerType;
@@ -458,6 +499,7 @@ declare namespace llvm {
 
     getPrimitiveSizeInBits(): number;
 
+
     toString(): string;
   }
 
@@ -536,6 +578,8 @@ declare namespace llvm {
 
     createAShr(lhs: Value, rhs: Value, name?: string): Value;
 
+    createAtomicRMW(op: AtomicRMWInst.BinOp, ptr: Value, value: Value, ordering: AtomicOrdering): Value;
+
     createBitCast(value: Value, destType: Type, name?: string): Value;
 
     createBr(basicBlock: BasicBlock): Value;
@@ -583,6 +627,7 @@ declare namespace llvm {
     createFSub(lhs: Value, rhs: Value, name?: string): Value;
 
     createFPToSI(value: Value, type: Type, name?: string): Value;
+    createFPToUI(value: Value, type: Type, name?: string): Value;
 
     createGlobalString(str: string, name?: string, addressSpace?: number): Value;
 
@@ -615,6 +660,8 @@ declare namespace llvm {
 
     createICmpULT(lhs: Value, rhs: Value, name?: string): Value;
 
+    createIsNull(ptr: Value, name?: string): Value;
+
     createLoad(ptr: Value, name?: string): Value;
 
     createLShr(lhs: Value, rhs: Value, name?: string): Value;
@@ -633,6 +680,8 @@ declare namespace llvm {
 
     createPtrToInt(value: Value, destType: Type, name?: string): Value;
 
+    createIntToPtr(value: Value, destType: Type, name?: string): Value;
+
     createRet(value: Value): Value;
 
     createRetVoid(): Value;
@@ -653,13 +702,36 @@ declare namespace llvm {
 
     createSRem(lhs: Value, rhs: Value, name?: string): Value;
 
-    CreateURem(lhs: Value, rhs: Value, name?: string): Value;
+    createUDiv(lhs: Value, rhs: Value, name?: string): Value;
+
+    createURem(lhs: Value, rhs: Value, name?: string): Value;
+
+    createUnreachable(): Value;
 
     createZExt(value: Value, destType: Type, name?: string): Value;
 
+    createZExtOrTrunc(value: Value, destType: Type, name?: string): Value;
+
+    createSExtOrTrunc(value: Value, destType: Type, name?: string): Value;
+
     getInsertBlock(): BasicBlock | undefined;
   }
 
+  namespace AtomicRMWInst {
+    enum BinOp {
+      Add,
+      Sub,
+      And,
+      Nand,
+      Or,
+      Xor,
+      Max,
+      Min,
+      UMax,
+      UMin
+    }
+  }
+
   class LLVMContext {
     constructor();
 

src/ir/atomic-rmw-inst.cc

@@ -0,0 +1,22 @@
+#include <llvm/IR/Instructions.h>
+#include "atomic-rmw-inst.h"
+
+NAN_MODULE_INIT(InitAtomicRMWInst) {
+    auto atomicRMWInst = Nan::New<v8::Object>();
+
+    auto binOp = Nan::New<v8::Object>();
+    Nan::Set(binOp, Nan::New("Add").ToLocalChecked(), Nan::New(static_cast<uint32_t>(llvm::AtomicRMWInst::BinOp::Add)));
+    Nan::Set(binOp, Nan::New("Sub").ToLocalChecked(), Nan::New(static_cast<uint32_t>(llvm::AtomicRMWInst::BinOp::Sub)));
+    Nan::Set(binOp, Nan::New("And").ToLocalChecked(), Nan::New(static_cast<uint32_t>(llvm::AtomicRMWInst::BinOp::And)));
+    Nan::Set(binOp, Nan::New("Nand").ToLocalChecked(), Nan::New(static_cast<uint32_t>(llvm::AtomicRMWInst::BinOp::Nand)));
+    Nan::Set(binOp, Nan::New("Or").ToLocalChecked(), Nan::New(static_cast<uint32_t>(llvm::AtomicRMWInst::BinOp::Or)));
+    Nan::Set(binOp, Nan::New("Xor").ToLocalChecked(), Nan::New(static_cast<uint32_t>(llvm::AtomicRMWInst::BinOp::Xor)));
+    Nan::Set(binOp, Nan::New("Max").ToLocalChecked(), Nan::New(static_cast<uint32_t>(llvm::AtomicRMWInst::BinOp::Max)));
+    Nan::Set(binOp, Nan::New("Min").ToLocalChecked(), Nan::New(static_cast<uint32_t>(llvm::AtomicRMWInst::BinOp::Min)));
+    Nan::Set(binOp, Nan::New("UMax").ToLocalChecked(), Nan::New(static_cast<uint32_t>(llvm::AtomicRMWInst::BinOp::UMax)));
+    Nan::Set(binOp, Nan::New("UMin").ToLocalChecked(), Nan::New(static_cast<uint32_t>(llvm::AtomicRMWInst::BinOp::UMin)));
+
+    Nan::Set(atomicRMWInst, Nan::New("BinOp").ToLocalChecked(), binOp);
+
+    Nan::Set(target, Nan::New("AtomicRMWInst").ToLocalChecked(), atomicRMWInst);
+}

src/ir/atomic-rmw-inst.h

@@ -0,0 +1,8 @@
+#ifndef LLVM_ATOMIC_RMW_INST_H
+#define LLVM_ATOMIC_RMW_INST_H
+
+#include <nan.h>
+
+NAN_MODULE_INIT(InitAtomicRMWInst);
+
+#endif //LLVM_ATOMIC_RMW_INST_H

src/ir/constant-aggregate-zero.cc

@@ -0,0 +1,67 @@
+#include "constant-aggregate-zero.h"
+#include "type.h"
+
+NAN_MODULE_INIT(ConstantAggregateZeroWrapper::Init) {
+    auto constantAggregateZero = Nan::GetFunction(Nan::New(constantAggregateZeroTemplate())).ToLocalChecked();
+
+    Nan::Set(target, Nan::New("ConstantAggregateZero").ToLocalChecked(), constantAggregateZero);
+}
+
+v8::Local<v8::Object> ConstantAggregateZeroWrapper::of(llvm::ConstantAggregateZero* constantAggregateZero) {
+    auto constructor = Nan::GetFunction(Nan::New(constantAggregateZeroTemplate())).ToLocalChecked();
+    v8::Local<v8::Value> args[1] = { Nan::New<v8::External> (constantAggregateZero) };
+
+    auto instance = Nan::NewInstance(constructor, 1, args).ToLocalChecked();
+
+    Nan::EscapableHandleScope escapableHandleScope {};
+    return escapableHandleScope.Escape(instance);
+}
+
+llvm::ConstantAggregateZero* ConstantAggregateZeroWrapper::getConstantAggregateZero() {
+    return static_cast<llvm::ConstantAggregateZero*>(getValue());
+}
+
+Nan::Persistent<v8::FunctionTemplate>& ConstantAggregateZeroWrapper::constantAggregateZeroTemplate() {
+    static Nan::Persistent<v8::FunctionTemplate> functionTemplate {};
+
+    if (functionTemplate.IsEmpty()) {
+        v8::Local<v8::FunctionTemplate> localTemplate = Nan::New<v8::FunctionTemplate>(ConstantAggregateZeroWrapper::New);
+        localTemplate->SetClassName(Nan::New("ConstantAggregateZero").ToLocalChecked());
+        localTemplate->InstanceTemplate()->SetInternalFieldCount(1);
+        localTemplate->Inherit(Nan::New(constantTemplate()));
+
+        Nan::SetMethod(localTemplate, "get", ConstantAggregateZeroWrapper::get);
+
+        functionTemplate.Reset(localTemplate);
+    }
+
+    return functionTemplate;
+}
+
+NAN_METHOD(ConstantAggregateZeroWrapper::New) {
+    if (!info.IsConstructCall()) {
+        return Nan::ThrowTypeError("ConstantAggregateZero constructor needs to be called with new");
+    }
+
+    if (!info[0]->IsExternal()) {
+        return Nan::ThrowTypeError("ConstantAggregateZero constructor needs to be called with: constantAggregateZero: External");
+    }
+
+    auto* constantAggregateZero = static_cast<llvm::ConstantAggregateZero*>(v8::External::Cast(*info[0])->Value());
+    auto* wrapper = new ConstantAggregateZeroWrapper { constantAggregateZero };
+    wrapper->Wrap(info.This());
+
+    info.GetReturnValue().Set(info.This());
+}
+
+
+NAN_METHOD(ConstantAggregateZeroWrapper::get) {
+    if (info.Length() != 1 || !TypeWrapper::isInstance(info[0])) {
+        return Nan::ThrowTypeError("get needs to be called with: type: Type");
+    }
+
+    auto* type = TypeWrapper::FromValue(info[0])->getType();
+    auto constantAggregateZero = llvm::ConstantAggregateZero::get(type);
+
+    info.GetReturnValue().Set(ConstantWrapper::of(constantAggregateZero));
+}

src/ir/constant-aggregate-zero.h

@@ -0,0 +1,25 @@
+#ifndef LLVM_NODE_CONSTANT_AGGREGATE_ZERO_H
+#define LLVM_NODE_CONSTANT_AGGREGATE_ZERO_H
+
+#include <nan.h>
+#include <llvm/IR/Constants.h>
+#include "constant.h"
+
+class ConstantAggregateZeroWrapper: public ConstantWrapper, public FromValueMixin<ConstantAggregateZeroWrapper> {
+public:
+    static NAN_MODULE_INIT(Init);
+    static v8::Local<v8::Object> of(llvm::ConstantAggregateZero* constantAggregateZero);
+    using FromValueMixin<ConstantAggregateZeroWrapper>::FromValue;
+    llvm::ConstantAggregateZero* getConstantAggregateZero();
+
+private:
+    explicit ConstantAggregateZeroWrapper(llvm::ConstantAggregateZero* constantAggregateZero) : ConstantWrapper { constantAggregateZero }
+    {}
+
+    static Nan::Persistent<v8::FunctionTemplate>& constantAggregateZeroTemplate();
+
+    static NAN_METHOD(New);
+    static NAN_METHOD(get);
+};
+
+#endif //LLVM_NODE_CONSTANT_AGGREGATE_ZERO_H