1//===- ExecutionEngine.cpp - C API for MLIR JIT ---------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "mlir-c/ExecutionEngine.h"
10#include "mlir/CAPI/ExecutionEngine.h"
11#include "mlir/CAPI/IR.h"
12#include "mlir/CAPI/Support.h"
13#include "mlir/ExecutionEngine/OptUtils.h"
14#include "mlir/Target/LLVMIR/Dialect/Builtin/BuiltinToLLVMIRTranslation.h"
15#include "mlir/Target/LLVMIR/Dialect/LLVMIR/LLVMToLLVMIRTranslation.h"
16#include "mlir/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.h"
17#include "llvm/ExecutionEngine/Orc/Mangling.h"
18#include "llvm/Support/CommandLine.h"
19#include "llvm/Support/TargetSelect.h"
20
21using namespace mlir;
22
23extern "C" MlirExecutionEngine
24mlirExecutionEngineCreate(MlirModule op, int optLevel, int numPaths,
25 const MlirStringRef *sharedLibPaths,
26 bool enableObjectDump, bool enablePIC) {
27 static bool initOnce = [] {
28 llvm::InitializeNativeTarget();
29 llvm::InitializeNativeTargetAsmParser(); // needed for inline_asm
30 llvm::InitializeNativeTargetAsmPrinter();
31 return true;
32 }();
33 (void)initOnce;
34
35 auto &ctx = *unwrap(c: op)->getContext();
36 mlir::registerBuiltinDialectTranslation(context&: ctx);
37 mlir::registerLLVMDialectTranslation(context&: ctx);
38 mlir::registerOpenMPDialectTranslation(context&: ctx);
39
40 auto tmBuilderOrError = llvm::orc::JITTargetMachineBuilder::detectHost();
41 if (!tmBuilderOrError) {
42 consumeError(Err: tmBuilderOrError.takeError());
43 return MlirExecutionEngine{.ptr: nullptr};
44 }
45 if (enablePIC)
46 tmBuilderOrError->setRelocationModel(llvm::Reloc::PIC_);
47 tmBuilderOrError->getOptions().MCOptions.LibraryOptions =
48 &llvm::cl::getCAPILibraryOptions();
49 auto tmOrError = tmBuilderOrError->createTargetMachine();
50 if (!tmOrError) {
51 consumeError(Err: tmOrError.takeError());
52 return MlirExecutionEngine{.ptr: nullptr};
53 }
54
55 SmallVector<StringRef> libPaths;
56 for (unsigned i = 0; i < static_cast<unsigned>(numPaths); ++i)
57 libPaths.push_back(Elt: sharedLibPaths[i].data);
58
59 // Create a transformer to run all LLVM optimization passes at the
60 // specified optimization level.
61 auto transformer = mlir::makeOptimizingTransformer(
62 optLevel, /*sizeLevel=*/0, /*targetMachine=*/tmOrError->get());
63 ExecutionEngineOptions jitOptions;
64 jitOptions.libraryOptions = &llvm::cl::getCAPILibraryOptions();
65 jitOptions.transformer = transformer;
66 jitOptions.jitCodeGenOptLevel = static_cast<llvm::CodeGenOptLevel>(optLevel);
67 jitOptions.sharedLibPaths = libPaths;
68 jitOptions.enableObjectDump = enableObjectDump;
69 auto jitOrError = ExecutionEngine::create(op: unwrap(c: op), options: jitOptions,
70 tm: std::move(tmOrError.get()));
71 if (!jitOrError) {
72 consumeError(Err: jitOrError.takeError());
73 return MlirExecutionEngine{.ptr: nullptr};
74 }
75 return wrap(cpp: jitOrError->release());
76}
77
78extern "C" void mlirExecutionEngineInitialize(MlirExecutionEngine jit) {
79 unwrap(c: jit)->initialize();
80}
81
82extern "C" void mlirExecutionEngineDestroy(MlirExecutionEngine jit) {
83 delete (unwrap(c: jit));
84}
85
86extern "C" MlirLogicalResult
87mlirExecutionEngineInvokePacked(MlirExecutionEngine jit, MlirStringRef name,
88 void **arguments) {
89 const std::string ifaceName = ("_mlir_ciface_" + unwrap(ref: name)).str();
90 llvm::Error error = unwrap(c: jit)->invokePacked(
91 name: ifaceName, args: MutableArrayRef<void *>{arguments, (size_t)0});
92 if (error)
93 return wrap(res: failure());
94 return wrap(res: success());
95}
96
97extern "C" void *mlirExecutionEngineLookupPacked(MlirExecutionEngine jit,
98 MlirStringRef name) {
99 auto optionalFPtr =
100 llvm::expectedToOptional(E: unwrap(c: jit)->lookupPacked(name: unwrap(ref: name)));
101 if (!optionalFPtr)
102 return nullptr;
103 return reinterpret_cast<void *>(*optionalFPtr);
104}
105
106extern "C" void *mlirExecutionEngineLookup(MlirExecutionEngine jit,
107 MlirStringRef name) {
108 auto optionalFPtr =
109 llvm::expectedToOptional(E: unwrap(c: jit)->lookup(name: unwrap(ref: name)));
110 if (!optionalFPtr)
111 return nullptr;
112 return *optionalFPtr;
113}
114
115extern "C" void mlirExecutionEngineRegisterSymbol(MlirExecutionEngine jit,
116 MlirStringRef name,
117 void *sym) {
118 unwrap(c: jit)->registerSymbols(symbolMap: [&](llvm::orc::MangleAndInterner interner) {
119 llvm::orc::SymbolMap symbolMap;
120 symbolMap[interner(unwrap(ref: name))] = {llvm::orc::ExecutorAddr::fromPtr(Ptr: sym),
121 llvm::JITSymbolFlags::Exported};
122 return symbolMap;
123 });
124}
125
126extern "C" void mlirExecutionEngineDumpToObjectFile(MlirExecutionEngine jit,
127 MlirStringRef name) {
128 unwrap(c: jit)->dumpToObjectFile(filename: unwrap(ref: name));
129}
130