如何愉快的运行一个MLIR程序

1
module {
2
  // 加法函数：返回 a + b
3
  func.func @add(%0: i32, %1: i32) -> i32 {
4
    %c = arith.addi %0, %1 : i32
5
    return %c : i32
6
  }
7

8
  // 减法函数：返回 a - b
9
  func.func @sub(%0: i32, %1: i32) -> i32 {
10
    %c = arith.subi %0, %1 : i32
11
    return %c : i32
12
  }
13

14
  // 乘法函数：返回 a * b
15
  func.func @mul(%0: i32, %1: i32) -> i32 {
16
    %c = arith.muli %0, %1 : i32
17
    return %c : i32
18
  }
19

20
  // 除法函数：返回 a / b（假设b不为0）
21
  func.func @div(%0: i32, %1: i32) -> i32 {
22
    %c = arith.divsi %0, %1 : i32
23
    return %c : i32
24
  }
25
}

1
#include "llvm/IR/LLVMContext.h"
2
#include "llvm/IR/LegacyPassManager.h"
3
#include "llvm/IR/Module.h"
4
#include "llvm/IRReader/IRReader.h"
5
#include "llvm/Support/SourceMgr.h"
6
#include "llvm/Support/raw_ostream.h"
7
#include "llvm/Support/InitLLVM.h"
8
#include "llvm/Support/TargetSelect.h"
9
#include "llvm/Support/FileSystem.h"
10
#include "llvm/Target/TargetMachine.h"
11
#include "llvm/Target/TargetOptions.h"
12
#include "llvm/TargetParser/Host.h"
13
#include "llvm/MC/TargetRegistry.h"
14

15
using namespace llvm;
16

17
int main(int argc, char **argv) {
18
    InitLLVM X(argc, argv);
19
    InitializeNativeTarget();
20
    InitializeNativeTargetAsmParser();
21
    InitializeNativeTargetAsmPrinter();
22

23
  // 创建LLVM上下文和源管理器
24
    LLVMContext Context;
25
    SMDiagnostic Err;
26

27
  // 从文件中读取LLVM IR
28
    // std::string InputFilename = argv[1];
29
    std::unique_ptr<Module> TheModule = parseIRFile("input.ll", Err, Context);
30
    if (!TheModule) {
31
        errs() << "Error loading file: " << Err.getMessage() << "\n";
32
        return 1;
33
    }
34

35
  // 获取目标三元组（Target Triple）
36
    auto TargetTriple = sys::getDefaultTargetTriple();
37
    TheModule->setTargetTriple(TargetTriple);
38

39
    std::string Error;
40
    auto Target = TargetRegistry::lookupTarget(TargetTriple, Error);
41

42
    if (!Target) {
43
        errs() << Error;
44
        return 1;
45
    }
46

47
    // 配置目标机器
48
    auto CPU = "generic";
49
    auto Features = "";
50
    TargetOptions opt;
51
    auto TheTargetMachine = Target->createTargetMachine(
52
        TargetTriple, CPU, Features, opt, Reloc::PIC_);
53

54
    // 设置模块的数据布局
55
    TheModule->setDataLayout(TheTargetMachine->createDataLayout());
56

57
    // 打开输出文件
58
    std::string OutputFilename = "output.o";
59
    std::error_code EC;
60
    raw_fd_ostream dest(OutputFilename, EC, sys::fs::OF_None);
61

62
    if (EC) {
63
        errs() << "Could not open file: " << EC.message();
64
        return 1;
65
    }
66

67
  // 创建PassManager并生成目标文件
68
    legacy::PassManager pass;
69
    auto FileType = CodeGenFileType::ObjectFile;
70

71
    if (TheTargetMachine->addPassesToEmitFile(pass, dest, nullptr, FileType)) {
72
        errs() << "TheTargetMachine can't emit a file of this type";
73
        return 1;
74
    }
75

76
    // 运行PassManager并生成目标文件
77
    pass.run(*TheModule);
78
    dest.flush();
79

80
    outs() << "Wrote " << OutputFilename << "\n";
81

82
    return 0;
83
}

1
; ModuleID = 'LLVMDialectModule'
2
source_filename = "LLVMDialectModule"
3

4
define i32 @add(i32 %0, i32 %1) {
5
  %3 = add i32 %0, %1
6
  ret i32 %3
7
}
8

9
define i32 @sub(i32 %0, i32 %1) {
10
  %3 = sub i32 %0, %1
11
  ret i32 %3
12
}
13

14
define i32 @mul(i32 %0, i32 %1) {
15
  %3 = mul i32 %0, %1
16
  ret i32 %3
17
}
18

19
define i32 @div(i32 %0, i32 %1) {
20
  %3 = sdiv i32 %0, %1
21
  ret i32 %3
22
}
23

24
!llvm.module.flags = !{!0}
25

26
!0 = !{i32 2, !"Debug Info Version", i32 3}

1
#include<stdio.h>
2
#include "mlir.h"
3

4
int main(){
5
    int a = 2;
6
    int b = 4;
7
    printf("add: %d\n",add(b,a));
8
    printf("sub: %d\n",sub(b,a));
9
    printf("mul: %d\n",mul(b,a));
10
    printf("div: %d\n",div(b,a));
11
    return 0;
12
}

1
extern int add(int a,int b);
2

3
extern int sub(int a,int b);
4

5
extern int mul(int a,int b);
6

7
extern int div(int a,int b);

1
#include <stdio.h>
2
#include <dlfcn.h>  // 包含动态加载库相关的头文件
3

4
int main() {
5
    void *handle = dlopen("./libmylibrary.so", RTLD_LAZY);
6
    if (!handle) {
7
        fprintf(stderr, "Error loading library: %s\n", dlerror());
8
        return -1;
9
    }
10

11
    dlerror();
12

13
    int (*add)(int, int) = (int (*)(int, int)) dlsym(handle, "add");
14
    int (*sub)(int, int) = (int (*)(int, int)) dlsym(handle, "sub");
15
    int (*mul)(int, int) = (int (*)(int, int)) dlsym(handle, "mul");
16
    int (*div)(int, int) = (int (*)(int, int)) dlsym(handle, "div");
17

18
    char *error = dlerror();
19
    if (error != NULL) {
20
        fprintf(stderr, "Error finding symbol: %s\n", error);
21
        dlclose(handle);
22
        return -1;
23
    }
24

25
    int a = 3;
26
    int b = 6;
27
    printf("add: %d\n",add(b,a));
28
    printf("sub: %d\n",sub(b,a));
29
    printf("mul: %d\n",mul(b,a));
30
    printf("div: %d\n",div(b,a));
31

32
    dlclose(handle);
33

34
    return 0;
35
}

1
#include "llvm/IR/LLVMContext.h"
2
#include "llvm/IR/Module.h"
3
#include "llvm/IRReader/IRReader.h"
4
#include "llvm/Support/SourceMgr.h"
5
#include "llvm/Support/raw_ostream.h"
6
#include "llvm/ExecutionEngine/Orc/LLJIT.h"
7
#include "llvm/Support/InitLLVM.h"
8
#include "llvm/Support/TargetSelect.h"
9
// #include "llvm/Bitcode/BitcodeReader.h"
10

11
using namespace llvm;
12
using namespace llvm::orc;
13

14
ExitOnError ExitOnErr;
15

16
int main(int argc, char *argv[]) {
17
    // 初始化LLVM
18
    InitLLVM X(argc, argv);
19
    InitializeNativeTarget();
20
    InitializeNativeTargetAsmPrinter();
21

22
    // 创建LLVM上下文
23
    LLVMContext Context;
24
    SMDiagnostic Err;
25

26
    // 从.ll文件加载LLVM IR模块
27
    std::unique_ptr<Module> M = parseIRFile("output.ll", Err, Context);
28
    if (!M) {
29
        errs() << "Error loading file: " << Err.getMessage() << "\n";
30
        return 1;
31
    }
32

33
     //从.bc文件加载LLVM IR模块
34
    // ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getFile("output.bc");
35
    // if (std::error_code EC = MBOrErr.getError()) {
36
    //     errs() << "Error reading file: " << EC.message() << "\n";
37
    //     return 1;
38
    // }
39

40
    // Expected<std::unique_ptr<Module>> MOrErr = parseBitcodeFile(MBOrErr.get()->getMemBufferRef(), Context);
41
    // if (!MOrErr) {
42
    //     errs() << "Error parsing bitcode: " << toString(MOrErr.takeError()) << "\n";
43
    //     return 1;
44
    // }
45
    // std::unique_ptr<Module> M = std::move(MOrErr.get());
46

47
    // 创建JIT实例
48
    auto J = ExitOnErr(LLJITBuilder().create());
49

50
    // 将模块添加到JIT
51
    ExitOnErr(J->addIRModule(ThreadSafeModule(std::move(M), std::make_unique<LLVMContext>())));
52

53
    // 查找并执行函数
54
    auto AddSymbol = ExitOnErr(J->lookup("add"));
55
    auto *Add = AddSymbol.toPtr<int(int, int)>();
56

57
    auto SubSymbol = ExitOnErr(J->lookup("sub"));
58
    auto *Sub = SubSymbol.toPtr<int(int, int)>();
59

60
    auto MulSymbol = ExitOnErr(J->lookup("mul"));
61
    auto *Mul = MulSymbol.toPtr<int(int, int)>();
62

63
    auto DivSymbol = ExitOnErr(J->lookup("div"));
64
    auto *Div = DivSymbol.toPtr<int(int, int)>();
65

66
    int a = 2;
67
    int b = 4;
68
    outs() << "add: " << Add(b, a) << "\n";
69
    outs() << "sub: " << Sub(b, a) << "\n";
70
    outs() << "mul: " << Mul(b, a) << "\n";
71
    outs() << "div: " << Div(b, a) << "\n";
72
    return 0;
73
}

1
#include "llvm/ExecutionEngine/Orc/LLJIT.h"
2
#include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
3
#include "llvm/Support/DynamicLibrary.h"
4
#include "llvm/Support/Error.h"
5
#include "llvm/Support/TargetSelect.h"
6
#include "llvm/Support/raw_ostream.h"
7
#include <memory>
8
#include <string>
9
#include <vector>
10

11
using namespace llvm;
12
using namespace llvm::orc;
13

14
class JITLoader {
15
public:
16
    JITLoader() {
17
        // 初始化本地目标
18
        InitializeNativeTarget();
19
        InitializeNativeTargetAsmPrinter();
20
    }
21

22
    Expected<std::unique_ptr<LLJIT>> createJIT() {
23
        auto Builder = LLJITBuilder();
24
        return Builder.create();
25
    }
26

27
    Error loadLibrary(LLJIT &JIT, const std::string &LibPath) {
28
        // 加载动态库
29
        std::string ErrMsg;
30
        if (sys::DynamicLibrary::LoadLibraryPermanently(LibPath.c_str(), &ErrMsg)) {
31
            return createStringError(inconvertibleErrorCode(),
32
                                   "Failed to load library: " + ErrMsg);
33
        }
34

35
        // 添加动态库到搜索路径
36
        JIT.getMainJITDylib().addGenerator(
37
            cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
38
                JIT.getDataLayout().getGlobalPrefix())));
39

40
        return Error::success();
41
    }
42

43
    Expected<JITEvaluatedSymbol> lookupSymbol(LLJIT &JIT, const std::string &Name) {
44
        // 打印正在查找的符号
45
        outs() << "Looking for symbol: " << Name << "\n";
46

47
        // 查找符号
48
        if (auto Addr = JIT.lookup(Name)) {
49
            return JITEvaluatedSymbol(Addr->getValue(),
50
                                    JITSymbolFlags::Exported);
51
        }
52

53
        return createStringError(inconvertibleErrorCode(),
54
                               "Symbol not found: " + Name);
55
    }
56
};
57

58
// 函数类型定义
59
using MathFunc = int(*)(int,int);
60

61
// 测试函数
62
void testMathFunction(LLJIT &JIT, JITLoader &Loader,
63
                     const std::string &FuncName,
64
                     int a, int b) {
65
    if (auto Symbol = Loader.lookupSymbol(JIT, FuncName)) {
66
        auto Func = (MathFunc)(Symbol->getAddress());
67
        outs() << FuncName << "(" << a << ", " << b << ") = "
68
               << Func(a, b) << "\n";
69
    } else {
70
        errs() << "Failed to find " << FuncName << ": "
71
               << toString(Symbol.takeError()) << "\n";
72
    }
73
}
74

75
int main(int argc, char *argv[]) {
76
    // 检查命令行参数
77
    if (argc < 2) {
78
        errs() << "Usage: " << argv[0] << " <path-to-libmath_ops.so>\n";
79
        return 1;
80
    }
81

82
    JITLoader Loader;
83

84
    // 创建 JIT 实例
85
    auto JIT = Loader.createJIT();
86
    if (!JIT) {
87
        errs() << "Failed to create JIT: "
88
               << toString(JIT.takeError()) << "\n";
89
        return 1;
90
    }
91

92
    // 加载动态库
93
    if (auto Err = Loader.loadLibrary(**JIT, argv[1])) {
94
        errs() << "Failed to load library: "
95
               << toString(std::move(Err)) << "\n";
96
        return 1;
97
    }
98

99
    // 打印库信息
100
    outs() << "Successfully loaded library: " << argv[1] << "\n";
101

102
    // 测试所有数学函数
103
    std::vector<std::string> mathFuncs = {"add", "sub", "mul", "div"};
104
    std::vector<std::pair<int, int>> testCases = {
105
        {10, 5},
106
        {20, 4},
107
        {15, 3}
108
    };
109

110
    for (const auto &func : mathFuncs) {
111
        outs() << "\nTesting " << func << ":\n";
112
        for (const auto &[a, b] : testCases) {
113
            testMathFunction(**JIT, Loader, func, a, b);
114
        }
115
    }
116

117
    return 0;
118
}

1
#include "llvm/ExecutionEngine/Orc/LLJIT.h"
2
#include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
3
#include "llvm/Support/DynamicLibrary.h"
4
#include "llvm/Support/Error.h"
5
#include "llvm/Support/TargetSelect.h"
6
#include "llvm/Support/raw_ostream.h"
7
#include <memory>
8
#include <string>
9
#include <vector>
10

11
using namespace llvm;
12
using namespace llvm::orc;
13

14
using MathFunc = int(*)(int,int);
15

16
int main(int argc, char *argv[]) {
17
    llvm::ExitOnError ExitOnErr;
18
    InitializeNativeTarget();
19
    InitializeNativeTargetAsmPrinter();
20
    auto JIT =  ExitOnErr(LLJITBuilder().create());
21

22
    std::string ErrMsg;
23
    if (sys::DynamicLibrary::LoadLibraryPermanently("./libmylibrary.so", &ErrMsg)) {
24
        outs() << "Failed to load library: " + ErrMsg << "\n";
25
    }
26

27
    // 添加动态库到搜索路径
28
    JIT->getMainJITDylib().addGenerator(
29
        cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
30
            JIT->getDataLayout().getGlobalPrefix())));
31

32
    // 查找并执行函数
33
    auto AddSymbol = JITEvaluatedSymbol(JIT->lookup("add")->getValue(), JITSymbolFlags::Exported);
34
    auto Add = (MathFunc)(AddSymbol.getAddress());
35

36
    auto SubSymbol = JITEvaluatedSymbol(JIT->lookup("sub")->getValue(), JITSymbolFlags::Exported);
37
    auto Sub = (MathFunc)(SubSymbol.getAddress());
38

39
    auto MulSymbol = JITEvaluatedSymbol(JIT->lookup("mul")->getValue(), JITSymbolFlags::Exported);
40
    auto Mul = (MathFunc)(MulSymbol.getAddress());
41

42
    auto DivSymbol = JITEvaluatedSymbol(JIT->lookup("div")->getValue(), JITSymbolFlags::Exported);
43
    auto Div = (MathFunc)(DivSymbol.getAddress());
44

45
    int a = 2;
46
    int b = 4;
47
    outs() << "add: " << Add(b, a) << "\n";
48
    outs() << "sub: " << Sub(b, a) << "\n";
49
    outs() << "mul: " << Mul(b, a) << "\n";
50
    outs() << "div: " << Div(b, a) << "\n";
51

52
    return 0;
53
}

1
#include "mlir/ExecutionEngine/ExecutionEngine.h"
2
#include "mlir/ExecutionEngine/OptUtils.h"
3
#include "mlir/Support/FileUtilities.h"
4
#include "mlir/IR/MLIRContext.h"
5
#include "mlir/IR/Builders.h"
6
#include "mlir/Parser/Parser.h"
7
#include "llvm/Support/SourceMgr.h"
8
#include <iostream>
9

10
using namespace mlir;
11

12
int my_add(int a, int b) {
13
    return a + b;
14
}
15

16
int main() {
17
    MLIRContext context;
18

19
    // 1. 解析 MLIR 模块
20
    std::string mlirCode = R"(
21
      module {
22
        func.func @jit_add(i32, i32) -> i32 {
23
          %3 = call @my_add(%0, %1) : (i32, i32) -> i32
24
          return %3 : i32
25
        }
26
      }
27
    )";
28

29
    llvm::SourceMgr sourceMgr;
30
    auto module = parseSourceString<ModuleOp>(mlirCode, &context);
31
    if (!module) {
32
        std::cerr << "Failed to parse MLIR module\n";
33
        return 1;
34
    }
35

36
    // 2. 创建 ExecutionEngine
37
    auto optPipeline = makeOptimizingTransformer(3, 0, nullptr);
38
    auto engine = ExecutionEngine::create(*module, optPipeline);
39
    if (!engine) {
40
        std::cerr << "Failed to create ExecutionEngine\n";
41
        return 1;
42
    }
43

44
    // 3. 注册外部 C 函数
45
    engine->registerSymbol("my_add", reinterpret_cast<void *>(&my_add));
46

47
    // 4. 调用 MLIR JIT 编译的函数
48
    int result;
49
    if (engine->invoke("jit_add", &result, 2, 3)) {
50
        std::cerr << "JIT invocation failed!\n";
51
        return 1;
52
    }
53

54
    std::cout << "JIT Result: " << result << std::endl; // 输出: 5
55
    return 0;
56
}

1
void registerSymbol(LLJIT &jit, const std::string &name, void *funcPtr) {
2
    auto &JD = jit.getMainJITDylib();
3
    MangleAndInterner Mangle(jit.getExecutionSession(), jit.getDataLayout());
4

5
    SymbolMap Symbols;
6
    // Use the ExecutorSymbolDef constructor instead of setting fields directly
7
    ExecutorAddr Addr = ExecutorAddr(pointerToJITTargetAddress(funcPtr));
8
    Symbols[Mangle(name)] = ExecutorSymbolDef(Addr, JITSymbolFlags::Exported);
9

10
    if (auto Err = JD.define(absoluteSymbols(std::move(Symbols)))) {
11
        llvm::errs() << "Failed to register symbol: " << toString(std::move(Err)) << "\n";
12
        exit(1);
13
    }
14
}
15

16
int main(int argc, char *argv[]) {
17
    // Initialize LLVM correctly with references
18
    InitLLVM X(argc, argv);
19

20
    llvm::InitializeNativeTarget();
21
    llvm::InitializeNativeTargetAsmPrinter();
22

23
    auto JITOrErr = LLJITBuilder().create();
24
    if (!JITOrErr) {
25
        llvm::errs() << "Failed to create LLJIT: " << toString(JITOrErr.takeError()) << "\n";
26
        return 1;
27
    }
28
    auto JIT = std::move(*JITOrErr);
29

30
    // Register external C function
31
    registerSymbol(*JIT, "my_add", (void *)&my_add);
32

33
    // Call JIT-compiled my_add
34
    auto Sym = JIT->lookup("my_add");
35
    if (!Sym) {
36
        llvm::errs() << "Function not found: " << toString(Sym.takeError()) << "\n";
37
        return 1;
38
    }
39

40
    auto FuncAddr = Sym->getValue();
41
    auto *FuncPtr = (int (*)(int, int))(uintptr_t)FuncAddr;
42
    std::cout << "JIT Result: " << FuncPtr(2, 3) << std::endl;
43
    return 0;
44
}

1
template <typename RetT, typename... ArgTs>
2
void registerTypedSymbol(LLJIT &jit, const std::string &name, RetT (*funcPtr)(ArgTs...)) {
3
    auto &JD = jit.getMainJITDylib();
4
    MangleAndInterner Mangle(jit.getExecutionSession(), jit.getDataLayout());
5

6
    SymbolMap Symbols;
7
    ExecutorAddr Addr = ExecutorAddr(pointerToJITTargetAddress((void*)funcPtr));
8
    Symbols[Mangle(name)] = ExecutorSymbolDef(Addr, JITSymbolFlags::Exported);
9

10
    if (auto Err = JD.define(absoluteSymbols(std::move(Symbols)))) {
11
        llvm::errs() << "Failed to register symbol: " << toString(std::move(Err)) << "\n";
12
        exit(1);
13
    }
14
}
15

16
int main(int argc, char *argv[]) {
17
    // Initialize LLVM correctly with references
18
    InitLLVM X(argc, argv);
19

20
    llvm::InitializeNativeTarget();
21
    llvm::InitializeNativeTargetAsmPrinter();
22

23
    auto JITOrErr = LLJITBuilder().create();
24
    if (!JITOrErr) {
25
        llvm::errs() << "Failed to create LLJIT: " << toString(JITOrErr.takeError()) << "\n";
26
        return 1;
27
    }
28
    auto JIT = std::move(*JITOrErr);
29

30
    // Register external C function
31
    registerTypedSymbol(*JIT, "my_add", &my_add);
32

33
    // Call JIT-compiled my_add
34
    auto Sym = JIT->lookup("my_add");
35
    if (!Sym) {
36
        llvm::errs() << "Function not found: " << toString(Sym.takeError()) << "\n";
37
        return 1;
38
    }
39

40
    auto FuncAddr = Sym->getValue();
41
    auto *FuncPtr = reinterpret_cast<int (*)(int, int)>(static_cast<uintptr_t>(FuncAddr));
42
    std::cout << "JIT Result: " << FuncPtr(2, 3) << std::endl;
43
    return 0;
44
}

1
[build-dependencies]

1
use std::env;
2
use std::path::PathBuf;
3

4
fn main() {
5
    let src_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap()).join("src");
6
    println!("cargo:rustc-link-search=native={}", src_dir.display());
7
}

1
├── Cargo.lock
2
├── Cargo.toml
3
├── build.rs
4
├── src
5
│   ├── libmylibrary.a
6
│   └── main.rs

1
export LD_LIBRARY_PATH=$(pwd)/src:$LD_LIBRARY_PATH

1
#[link(name = "mylibrary")]
2
extern "C" {
3
    fn add(a: i32, b: i32) -> i32;
4
    fn sub(a: i32, b: i32) -> i32;
5
    fn mul(a: i32, b: i32) -> i32;
6
    fn div(a: i32, b: i32) -> i32;
7
}

1
#include <cstdint>
2
#include <cstdio>
3

4
extern "C" {
5
    int32_t addInteger(int32_t a, int32_t b) {
6
        const int32_t result = a + b;
7
        printf("Result:%d\n",result);
8
        return result;
9
    }
10
}

1
module {
2
  llvm.func @addInteger(i32, i32) -> i32
3

4
  func.func @main() -> i32 {
5
    %2 = arith.constant 10 : i32
6
    %3 = arith.constant 20 : i32
7
    %4 = llvm.call @addInteger(%2, %3) : (i32, i32) -> i32
8

9
    %ret = arith.constant 0 : i32
10
    return %ret : i32
11
  }
12
}

1
Result:30

1
int arith_work() {
2
    mlir::MLIRContext context;
3

4
    // Register dialects
5
    context.loadDialect<mlir::func::FuncDialect>();
6
    context.loadDialect<mlir::arith::ArithDialect>();
7
    context.loadDialect<mlir::LLVM::LLVMDialect>();
8

9
    mlir::OpBuilder builder(&context);
10
    mlir::OwningOpRef<mlir::ModuleOp> module = mlir::ModuleOp::create(builder.getUnknownLoc());
11

12
    // Create function returning i32
13
    auto i32Type = builder.getI32Type();
14
    auto addIntegerType = mlir::LLVM::LLVMFunctionType::get(i32Type, {i32Type, i32Type}, false);
15

16
    auto addInteger = builder.create<mlir::LLVM::LLVMFuncOp>(
17
        builder.getUnknownLoc(),
18
        "addInteger",
19
        addIntegerType
20
    );
21

22
    auto mainType = builder.getFunctionType({}, {i32Type});
23
    auto mainFunc = builder.create<mlir::func::FuncOp>(
24
        builder.getUnknownLoc(),
25
        "main",
26
        mainType
27
    );
28

29
    auto entryBlock = mainFunc.addEntryBlock();
30
    builder.setInsertionPointToStart(entryBlock);
31

32
    auto ten = builder.create<mlir::arith::ConstantOp>(
33
        builder.getUnknownLoc(),
34
        builder.getI32IntegerAttr(10)
35
    );
36
    auto twenty = builder.create<mlir::arith::ConstantOp>(
37
        builder.getUnknownLoc(),
38
        builder.getI32IntegerAttr(20)
39
    );
40

41
    auto callResult = builder.create<mlir::LLVM::CallOp>(
42
        builder.getUnknownLoc(),
43
        i32Type,
44
        "addInteger",
45
        mlir::ValueRange{ten, twenty}
46
    );
47

48

49
    auto retVal = builder.create<mlir::arith::ConstantOp>(
50
        builder.getUnknownLoc(),
51
        builder.getI32IntegerAttr(0)
52
    );
53
    builder.create<mlir::func::ReturnOp>(
54
      builder.getUnknownLoc(),
55
      mlir::ValueRange{retVal});
56

57
    module->push_back(addInteger);
58
    module->push_back(mainFunc);
59

60
    module->print(llvm::outs());
61
    return 0;
62
}