[examples] Add an example of how to use JITLink and small-code-model with LLJIT.

JITLink is LLVM's newer jit-linker. It is an alternative to (and hopefully
eventually a replacement for) LLVM's older jit-linker, RuntimeDyld. Unlike
RuntimeDyld which requries JIT'd code to be complied with the large code
model, JITlink can link code compiled with the small code model, which is
the native code model for a number of targets (including all supported MachO
targets).

This example shows how to:

-- Create a JITLink InProcessMemoryManager
-- Set the code model to small
-- Use a JITLink backed ObjectLinkingLayer as the linking layer for LLJIT
   (rather than the default RTDyldObjectLinkingLayer).

Note: This example will only work on platforms supported by JITLink. As of
this commit that's MachO/x86-64 and MachO/arm64.

llvm-svn: 375266

llvm/examples/LLJITExamples/CMakeLists.txt

@@ -1 +1,2 @@
 add_subdirectory(LLJITWithObjectCache)
+add_subdirectory(LLJITWithJITLink)

llvm/examples/LLJITExamples/LLJITWithJITLink/CMakeLists.txt

@@ -0,0 +1,11 @@
+set(LLVM_LINK_COMPONENTS
+  Core
+  IRReader
+  OrcJIT
+  Support
+  nativecodegen
+  )
+
+add_llvm_example(LLJITWithJITLink
+  LLJITWithJITLink.cpp
+  )

llvm/examples/LLJITExamples/LLJITWithJITLink/LLJITWithJITLink.cpp

@@ -0,0 +1,70 @@
+//===-- LLJITWithJITLink.cpp - Configure LLJIT to use ObjectLinkingLayer --===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file shows how to switch LLJIT to use ObjectLinkingLayer (which is
+// backed by JITLink) rather than RTDyldObjectLinkingLayer (which is backed by
+// RuntimeDyld). Using JITLink as the underlying allocator enables use of
+// small code model in JIT'd code.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h"
+#include "llvm/ExecutionEngine/Orc/LLJIT.h"
+#include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
+#include "llvm/Support/InitLLVM.h"
+#include "llvm/Support/TargetSelect.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include "../ExampleModules.h"
+
+using namespace llvm;
+using namespace llvm::orc;
+
+ExitOnError ExitOnErr;
+
+int main(int argc, char *argv[]) {
+  // Initialize LLVM.
+  InitLLVM X(argc, argv);
+
+  InitializeNativeTarget();
+  InitializeNativeTargetAsmPrinter();
+
+  cl::ParseCommandLineOptions(argc, argv, "HowToUseLLJIT");
+  ExitOnErr.setBanner(std::string(argv[0]) + ": ");
+
+  // Declare an in-process JITLink memory manager.
+  jitlink::InProcessMemoryManager MemMgr;
+
+  // Detect the host and set code model to small.
+  auto JTMB = ExitOnErr(JITTargetMachineBuilder::detectHost());
+  JTMB.setCodeModel(CodeModel::Small);
+
+  // Create an LLJIT instance with a custom CompileFunction.
+  auto J =
+      ExitOnErr(LLJITBuilder()
+                    .setJITTargetMachineBuilder(std::move(JTMB))
+                    .setObjectLinkingLayerCreator([&](ExecutionSession &ES,
+                                                      const Triple &TT) {
+                      return std::make_unique<ObjectLinkingLayer>(ES, MemMgr);
+                    })
+                    .create());
+
+  auto M = ExitOnErr(parseExampleModule(Add1Example, "add1"));
+
+  ExitOnErr(J->addIRModule(std::move(M)));
+
+  // Look up the JIT'd function, cast it to a function pointer, then call it.
+  auto Add1Sym = ExitOnErr(J->lookup("add1"));
+  int (*Add1)(int) = (int (*)(int))Add1Sym.getAddress();
+
+  int Result = Add1(42);
+  outs() << "add1(42) = " << Result << "\n";
+
+  return 0;
+}