feature(IR): Add support for float constants

Author: Micha Reiser

llvm-node.d.ts

@@ -175,22 +175,23 @@ declare namespace llvm {
 
   class ConstantFP extends Constant {
     static get(context: LLVMContext, value: number): ConstantFP;
+    static get(type: Type, value: string): Constant;
 
     static getZeroValueForNegation(type: Type): Constant;
 
     static getNegativeZero(type: Type): Constant;
 
     static getNaN(type: Type): Constant;
 
-    static getInfinity(type: Type, negative?: boolean/* = false */): Constant;
+    static getInfinity(type: Type, negative?: boolean /* = false */): Constant;
 
     private constructor();
 
     readonly value: number;
   }
 
   class ConstantInt extends Constant {
-    static get(context: LLVMContext, value: number|string, numBits?: number, signed?: boolean): ConstantInt;
+    static get(context: LLVMContext, value: number | string, numBits?: number, signed?: boolean): ConstantInt;
 
     static getFalse(context: LLVMContext): ConstantInt;
 

src/ir/constant-fp.cc

@@ -6,6 +6,9 @@
 #include "llvm-context.h"
 #include "type.h"
 
+#include "../util/string.h"
+
+
 NAN_MODULE_INIT(ConstantFPWrapper::Init) {
         auto constantFp = Nan::GetFunction(Nan::New(constantFpTemplate())).ToLocalChecked();
         Nan::Set(target, Nan::New("ConstantFP").ToLocalChecked(), constantFp);
@@ -28,16 +31,22 @@ NAN_METHOD(ConstantFPWrapper::New) {
 }
 
 NAN_METHOD(ConstantFPWrapper::get) {
-        if (info.Length() != 2 || !LLVMContextWrapper::isInstance(info[0]) || !info[1]->IsNumber()) {
-            return Nan::ThrowTypeError("get needs to be called with: context: LLVMContext, value: number");
-        }
-
+    if (info.Length() == 2 && LLVMContextWrapper::isInstance(info[0]) && info[1]->IsNumber()) {
         auto& context = LLVMContextWrapper::FromValue(info[0])->getContext();
         double number = Nan::To<double>(info[1]).FromJust();
 
-        auto* constant = llvm::ConstantFP::get(context, llvm::APFloat { number } );
+        auto* constant = llvm::ConstantFP::get(context, llvm::APFloat { number });
 
-        info.GetReturnValue().Set(ConstantFPWrapper::of(constant));
+        return info.GetReturnValue().Set(ConstantFPWrapper::of(constant));    
+    } else if (info.Length() == 2 && TypeWrapper::isInstance(info[0]) && info[1]->IsString()) {
+        auto type = TypeWrapper::FromValue(info[0])->getType();
+        auto number = ToString(info[1]);
+        auto constant = llvm::ConstantFP::get(type, number);
+
+        return info.GetReturnValue().Set(ConstantWrapper::of(constant));
+    }
+
+    return Nan::ThrowTypeError("get called with illegal arguments");
 }
 
 NAN_METHOD(ConstantFPWrapper::getNaN) {
@@ -95,10 +104,15 @@ NAN_METHOD(ConstantFPWrapper::getNegativeZero) {
 }
 
 NAN_GETTER(ConstantFPWrapper::getValueAPF) {
-        auto* wrapper = ConstantFPWrapper::FromValue(info.Holder());
-        auto value = wrapper->getConstantFP()->getValueAPF();
+    auto* wrapper = ConstantFPWrapper::FromValue(info.Holder());
+    auto fp = wrapper->getConstantFP();
+    auto value = fp->getValueAPF();
 
+    if (fp->getType()->isFloatTy()) {
+        info.GetReturnValue().Set(Nan::New(value.convertToFloat()));
+    } else {
         info.GetReturnValue().Set(Nan::New(value.convertToDouble()));
+    }
 }
 
 llvm::ConstantFP *ConstantFPWrapper::getConstantFP() {

test/ir/constant-fp.spec.ts

@@ -22,21 +22,29 @@ describe("ir/constant-fp", () => {
 
   describe("get", () => {
     const untypedGet = llvm.ConstantFP.get as any;
-    it("creates a new float constant", () => {
+    it("creates a new double constant", () => {
       const value = llvm.ConstantFP.get(context, 10);
 
       expect(value.value).toBe(10);
     });
 
+    it("creates a new fp of the given type", () => {
+      const floatType = llvm.Type.getFloatTy(context);
+
+      const value = llvm.ConstantFP.get(floatType, "3");
+
+      expect(value.type).toEqual(floatType);
+      expect(value).toBeInstanceOf(llvm.ConstantFP);
+      expect((value as llvm.ConstantFP).value).toBe(3);
+    });
+
     it("throws if not called with a context as first argument", () => {
-      expect(() => untypedGet()).toThrowError("get needs to be called with: context: LLVMContext, value: number");
-      expect(() => untypedGet({}).toThrowError("get needs to be called with: context: LLVMContext, value: number"));
+      expect(() => untypedGet()).toThrowError("get called with illegal arguments");
+      expect(() => untypedGet({}).toThrowError("get called with illegal arguments"));
     });
 
     it("throws if not called with a number as second argument", () => {
-      expect(() => untypedGet(context, "test")).toThrowError(
-        "get needs to be called with: context: LLVMContext, value: number"
-      );
+      expect(() => untypedGet(context, "test")).toThrowError("get called with illegal arguments");
     });
   });
 
@@ -86,5 +94,11 @@ describe("ir/constant-fp", () => {
 
       expect(value.value).toBe(10);
     });
+
+    it("returns NaN for a NaN value", () => {
+      const value = llvm.ConstantFP.get(context, NaN);
+
+      expect(value.value).toBeNaN();
+    });
   });
 });