1
// LLVM ORC JIT 最小示例
2
#include "llvm/ExecutionEngine/Orc/LLJIT.h"
3
#include "llvm/IR/IRBuilder.h"
4
#include "llvm/IR/LLVMContext.h"
5
#include "llvm/IR/Module.h"
6

7
using namespace llvm;
8
using namespace llvm::orc;
9

10
int main() {
11
    // 1. 创建 JIT 实例
12
    auto JIT = LLJITBuilder().create();
13
    if (!JIT) {
14
        errs() << "Failed to create JIT: " << toString(JIT.takeError()) << "\n";
15
        return 1;
16
    }
17

18
    // 2. 创建 IR 模块
19
    LLVMContext Ctx;
20
    auto M = std::make_unique<Module>("jit_module", Ctx);
21
    M->setDataLayout((*JIT)->getDataLayout());
22

23
    // 3. 定义函数
24
    FunctionType *FT = FunctionType::get(
25
        Type::getInt32Ty(Ctx), {Type::getInt32Ty(Ctx)}, false);
26
    Function *F = Function::Create(FT, Function::ExternalLinkage, "add_one", M.get());
27

28
    // 4. 生成 IR
29
    BasicBlock *BB = BasicBlock::Create(Ctx, "entry", F);
30
    IRBuilder<> Builder(BB);
31
    Value *Arg = &*F->arg_begin();
32
    Value *One = ConstantInt::get(Type::getInt32Ty(Ctx), 1);
33
    Value *Result = Builder.CreateAdd(Arg, One, "result");
34
    Builder.CreateRet(Result);
35

36
    // 5. 添加模块到 JIT
37
    auto Err = (*JIT)->addIRModule(ThreadSafeModule(std::move(M), std::move(Ctx)));
38
    if (Err) {
39
        errs() << "Failed to add module: " << toString(std::move(Err)) << "\n";
40
        return 1;
41
    }
42

43
    // 6. 查找并执行函数
44
    auto Sym = (*JIT)->lookup("add_one");
45
    if (!Sym) {
46
        errs() << "Function not found\n";
47
        return 1;
48
    }
49

50
    auto *Fn = Sym->toPtr<int(int)>();
51
    int result = Fn(41);
52
    outs() << "add_one(41) = " << result << "\n";  // 输出 42
53

54
    return 0;
55
}

1
# 编译桩的伪代码
2
def make_stub(func_name):
3
    """为未编译的函数创建编译桩"""
4
    def stub(*args):
5
        # 1. 触发编译
6
        compiled_code = jit_compile(func_name)
7

8
        # 2. 更新函数指针（后续调用直接跳到编译后的代码）
9
        update_function_pointer(func_name, compiled_code)
10

11
        # 3. 执行编译后的代码
12
        return compiled_code(*args)
13

14
    return stub

1
# 无内联缓存：每次调用都查找方法
2
def call_method(obj, method_name, *args):
3
    method = obj.__class__.lookup(method_name)  # O(n) 查找
4
    return method(obj, *args)
5

6
# 有内联缓存：缓存上次查找结果
7
class InlineCache:
8
    def __init__(self):
9
        self.cached_class = None
10
        self.cached_method = None
11

12
    def call(self, obj, method_name, *args):
13
        obj_class = obj.__class__
14

15
        if obj_class == self.cached_class:
16
            # 缓存命中：直接调用
17
            return self.cached_method(obj, *args)
18
        else:
19
            # 缓存未命中：查找并更新缓存
20
            method = obj_class.lookup(method_name)
21
            self.cached_class = obj_class
22
            self.cached_method = method
23
            return method(obj, *args)

1
// Java 虚调用
2
animal.speak();  // 可能是 Dog.speak() 或 Cat.speak()
3

4
// 内联缓存发现 95% 的时候是 Dog
5
// 去虚化 + 守卫条件：
6
if (animal instanceof Dog) {
7
    Dog.speak(animal);  // 直接调用，可内联
8
} else {
9
    animal.speak();     // 回退到虚调用
10
}

1
class DeoptimizationManager:
2
    """去优化管理器"""
3

4
    def __init__(self):
5
        self.guard_count = 0
6
        self.deopt_count = 0
7

8
    def insert_guard(self, condition, fallback_interp_state):
9
        """插入守卫条件"""
10
        self.guard_count += 1
11
        guard_id = self.guard_count
12

13
        def guarded_execute(*args):
14
            if condition(*args):
15
                # 守卫通过：执行优化路径
16
                return optimized_code(*args)
17
            else:
18
                # 守卫失败：去优化
19
                self.deopt_count += 1
20
                return self.deoptimize(guard_id, fallback_interp_state, args)
21

22
        return guarded_execute
23

24
    def deoptimize(self, guard_id, interp_state, args):
25
        """去优化：回到解释器"""
26
        # 1. 恢复解释器状态
27
        # 2. 从正确的位置继续执行
28
        # 3. 可能重新编译（不包含失败的假设）
29
        return interpret(interp_state, args)

1
// 运行时生成一个 N 次多项式求值函数
2
// f(x) = c0 + c1*x + c2*x^2 + ... + cn*x^n
3
std::unique_ptr<Module> buildPolynomial(LLVMContext &Ctx,
4
                                         const std::vector<double> &coeffs) {
5
    auto M = std::make_unique<Module>("poly", Ctx);
6

7
    // 声明函数: double poly(double x)
8
    FunctionType *FT = FunctionType::get(
9
        Type::getDoubleTy(Ctx), {Type::getDoubleTy(Ctx)}, false);
10
    Function *F = Function::Create(FT, Function::ExternalLinkage, "poly", M.get());
11

12
    BasicBlock *BB = BasicBlock::Create(Ctx, "entry", F);
13
    IRBuilder<> Builder(BB);
14

15
    Value *X = &*F->arg_begin();
16
    Value *Result = ConstantFP::get(Ctx, APFloat(coeffs[0]));
17

18
    // Horner 法则: c0 + x*(c1 + x*(c2 + ...))
19
    for (size_t i = 1; i < coeffs.size(); i++) {
20
        Value *C = ConstantFP::get(Ctx, APFloat(coeffs[i]));
21
        Value *Sum = Builder.CreateFAdd(C, Result, "sum");
22
        Result = Builder.CreateFMul(X, Sum, "prod");
23
    }
24

25
    Builder.CreateRet(Result);
26
    return M;
27
}

1
# 编译 ORC JIT 示例
2
clang++ -g orc_jit.cpp $(llvm-config --cxxflags --ldflags --libs core orcjit native) -o orc_jit
3
./orc_jit

1
# 启用 JIT 日志
2
java -XX:+PrintCompilation -XX:+UnlockDiagnosticVMOptions -XX:+PrintInlining MyApp
3

4
# 查看分层编译
5
java -XX:+PrintCompilation -XX:TieredStopAtLevel=1 MyApp  # 只用 C1
6
java -XX:+PrintCompilation -XX:-TieredCompilation MyApp    # 只用 C2

1
# 启用 V8 JIT 日志
2
node --trace-opt --trace-deopt script.js
3

4
# 查看优化/去优化
5
node --prof script.js
6
node --prof-process isolate-*.log