Merge branch 'master' into constant-fp-get-type-overload

Author: Micha Reiser

.travis.yml

@@ -2,9 +2,7 @@ language: node_js
 node_js:
   - "11"
   - "10"
-  - "9"
   - "8"
-  - "7"
   - "6"
 cache: yarn
 env:
@@ -20,7 +18,7 @@ before_install:
   - wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key|sudo apt-key add -
   - echo $LLVM_DEB | sudo tee -a /etc/apt/sources.list
   - sudo apt-get update -qq
-  - sudo apt-get install libedit-dev llvm-$LLVM_VERSION llvm-$LLVM_VERSION-dev
+  - sudo apt-get install libedit-dev llvm-$LLVM_VERSION llvm-$LLVM_VERSION-dev clang-$LLVM_VERSION llvm-$LLVM_VERSION-tools
   - npm config set cmake_LLVM_DIR $(llvm-config-$LLVM_VERSION --cmakedir)
 deploy:
   provider: npm

llvm-node.d.ts

@@ -667,6 +667,11 @@ declare namespace llvm {
     private __marker: number;
   }
 
+  interface FunctionCallee {
+    callee: Value;
+    functionType: FunctionType;
+  }
+
   class Module {
     empty: boolean;
     readonly name: string;
@@ -683,7 +688,7 @@ declare namespace llvm {
 
     getFunction(name: string): Function | undefined;
 
-    getOrInsertFunction(name: string, functionType: FunctionType): Constant;
+    getOrInsertFunction(name: string, functionType: FunctionType): FunctionCallee;
 
     getGlobalVariable(name: string, allowInternal?: boolean): GlobalVariable;
 

src/ir/module.cc

@@ -93,7 +93,19 @@ NAN_METHOD(ModuleWrapper::getOrInsertFunction) {
     std::string name = ToString(info[0]);
     auto* fnType = FunctionTypeWrapper::FromValue(info[1])->getFunctionType();
 
-    info.GetReturnValue().Set(ConstantWrapper::of(module->getOrInsertFunction(name, fnType)));
+    auto functionCallee = Nan::New<v8::Object>();
+
+    #if LLVM_VERSION_MAJOR < 9
+        Nan::Set(functionCallee, Nan::New("callee").ToLocalChecked(), ConstantWrapper::of(module->getOrInsertFunction(name, fnType)));
+        Nan::Set(functionCallee, Nan::New("functionType").ToLocalChecked(), FunctionTypeWrapper::of(fnType));
+    #else 
+        auto llvmCallee = module->getOrInsertFunction(name, fnType);
+        Nan::Set(functionCallee, Nan::New("callee").ToLocalChecked(), ValueWrapper::of(llvmCallee.getCallee()));
+        Nan::Set(functionCallee, Nan::New("functionType").ToLocalChecked(), FunctionTypeWrapper::of(llvmCallee.getFunctionType()));
+    #endif
+    
+    Nan::EscapableHandleScope scope {};
+    info.GetReturnValue().Set(scope.Escape(functionCallee));
 }
 
 NAN_METHOD(ModuleWrapper::getGlobalVariable) {

test/ir/module.spec.ts

@@ -1,5 +1,5 @@
 import * as llvm from "../../";
-import { createModule, createBuilder, createBuilderWithBlock } from "../test-utils";
+import { createModule, createBuilder } from "../test-utils";
 
 describe("ir/module", () => {
   describe("constructor", () => {
@@ -141,30 +141,32 @@ describe("ir/module", () => {
   describe("getOrInsertFunction", () => {
     test("returns a new function if not yet existing in the module", () => {
       const { module, context } = createModule();
-
-      const fun = module.getOrInsertFunction(
-        "fib",
-        llvm.FunctionType.get(llvm.Type.getDoubleTy(context), [llvm.Type.getDoubleTy(context)], false)
+      const functionType = llvm.FunctionType.get(
+        llvm.Type.getDoubleTy(context),
+        [llvm.Type.getDoubleTy(context)],
+        false
       );
 
-      expect(fun).toBeDefined();
-      expect(module.getFunction("fib")).toEqual(fun);
+      const functionCallee = module.getOrInsertFunction("fib", functionType);
+
+      expect(functionCallee).toBeDefined();
+      expect(module.getFunction("fib")).toEqual(functionCallee.callee);
+      expect(functionCallee.functionType).toEqual(functionType);
     });
 
     test("returns the existing function if a function with the given name already exist", () => {
       const { module, context } = createModule();
 
-      const fun = llvm.Function.create(
-        llvm.FunctionType.get(llvm.Type.getDoubleTy(context), [], false),
-        llvm.LinkageTypes.ExternalLinkage,
-        "sin",
-        module
-      );
-      const queriedFn = module.getOrInsertFunction(
+      const functionType = llvm.FunctionType.get(llvm.Type.getDoubleTy(context), [], false);
+      const fun = llvm.Function.create(functionType, llvm.LinkageTypes.ExternalLinkage, "sin", module);
+
+      const functionCallee = module.getOrInsertFunction(
         "sin",
         llvm.FunctionType.get(llvm.Type.getDoubleTy(context), [], false)
       );
-      expect(queriedFn).toEqual(fun);
+
+      expect(functionCallee.callee).toEqual(fun);
+      expect(functionCallee.functionType).toEqual(functionType);
     });
   });
 
@@ -209,22 +211,22 @@ describe("ir/module", () => {
 
   describe("getTypeByName", () => {
     test("returns null if a type with the given name does not exist", () => {
-      const {module, context} = createModule();
+      const { module, context } = createModule();
 
       const type = module.getTypeByName("DoesNotExist");
 
       expect(type).toBeNull();
     });
 
     test("returns the type with the given name if it exists", () => {
-        const {module, context} = createModule();
-        const structType = llvm.StructType.create(context, "IntTuple");
-        structType.setBody([llvm.Type.getInt32Ty(context), llvm.Type.getInt32Ty(context)]);
+      const { module, context } = createModule();
+      const structType = llvm.StructType.create(context, "IntTuple");
+      structType.setBody([llvm.Type.getInt32Ty(context), llvm.Type.getInt32Ty(context)]);
 
-        const retrieved = module.getTypeByName("IntTuple");
+      const retrieved = module.getTypeByName("IntTuple");
 
-        expect(retrieved).toBeInstanceOf(llvm.StructType);
-        expect(retrieved).toEqual(structType);
+      expect(retrieved).toBeInstanceOf(llvm.StructType);
+      expect(retrieved).toEqual(structType);
     });
   });
 });