Rust LLVM绑定库inkwell的使用：安全高效地进行编译器前端开发和代码生成

Inkwell是一个Rust库，它安全地包装了llvm-sys，可以帮助你开发自己的编程语言。它提供了比底层LLVM C API更加强类型的接口，使得某些类型的错误可以在编译时被发现，而不是在LLVM运行时。

特点

• 安全地包装LLVM C API
• 提供强类型接口
• 目标是使LLVM更安全且更易于使用
• 支持LLVM 8-18版本

要求

• Rust 1.56+
• 支持LLVM 8-18中的一个版本

使用方式

在Cargo.toml中添加依赖，并指定对应的LLVM版本特性标志：

[dependencies]
inkwell = { version = "0.6.0", features = ["llvm18-1"] }

支持的版本对应特性标志为llvmM-0，其中M是LLVM的主版本号。

完整示例：使用inkwell实现简单的计算器

以下是一个完整的示例，展示了如何使用inkwell创建一个简单的计算器，支持加减乘除运算：

use inkwell::builder::Builder;
use inkwell::context::Context;
use inkwell::execution_engine::{ExecutionEngine, JitFunction};
use inkwell::module::Module;
use inkwell::OptimizationLevel;
use inkwell::types::BasicType;

use std::error::Error;

// 定义计算器函数类型
type CalculatorFunc = unsafe extern "C" fn(f64, f64) -> f64;

struct CalculatorGenerator<'ctx> {
    context: &'ctx Context,
    module: Module<'ctx>,
    builder: Builder<'ctx>,
    execution_engine: ExecutionEngine<'ctx>,
}

impl<'ctx> CalculatorGenerator<'ctx> {
    // 生成加法函数
    fn generate_add(&self) -> Option<JitFunction<CalculatorFunc>> {
        let f64_type = self.context.f64_type();
        let fn_type = f64_type.fn_type(&[f64_type.into(), f64_type.into()], false);
        let function = self.module.add_function("add", fn_type, None);
        let basic_block = self.context.append_basic_block(function, "entry");

        self.builder.position_at_end(basic_block);

        let x = function.get_nth_param(0)?.into_float_value();
        let y = function.get_nth_param(1)?.into_float_value();

        let sum = self.builder.build_float_add(x, y, "sum").unwrap();
        self.builder.build_return(Some(&sum)).unwrap();

        unsafe { self.execution_engine.get_function("add").ok() }
    }

    // 生成减法函数
    fn generate_sub(&self) -> Option<JitFunction<CalculatorFunc>> {
        let f64_type = self.context.f64_type();
        let fn_type = f64_type.fn_type(&[f64_type.into(), f64_type.into()], false);
        let function = self.module.add_function("sub", fn_type, None);
        let basic_block = self.context.append_basic_block(function, "entry");

        self.builder.position_at_end(basic_block);

        let x = function.get_nth_param(0)?.into_float_value();
        let y = function.get_nth_param(1)?.into_float_value();

        let diff = self.builder.build_float_sub(x, y, "diff").unwrap();
        self.builder.build_return(Some(&diff)).unwrap();

        unsafe { self.execution_engine.get_function("sub").ok() }
    }

    // 生成乘法函数
    fn generate_mul(&self) -> Option<JitFunction<CalculatorFunc>> {
        let f64_type = self.context.f64_type();
        let fn_type = f64_type.fn_type(&[f64_type.into(), f64_type.into()], false);
        let function = self.module.add_function("mul", fn_type, None);
        let basic_block = self.context.append_basic_block(function, "entry");

        self.builder.position_at_end(basic_block);

        let x = function.get_nth_param(0)?.into_float_value();
        let y = function.get_nth_param(1)?.into_float_value();

        let product = self.builder.build_float_mul(x, y, "product").unwrap();
        self.builder.build_return(Some(&product)).unwrap();

        unsafe { self.execution_engine.get_function("mul").ok() }
    }

    // 生成除法函数
    fn generate_div(&self) -> Option<JitFunction<CalculatorFunc>> {
        let f64_type = self.context.f64_type();
        let fn_type = f64_type.fn_type(&[f64_type.into(), f64_type.into()], false);
        let function = self.module.add_function("div", fn_type, None);
        let basic_block = self.context.append_basic_block(function, "entry");

        self.builder.position_at_end(basic_block);

        let x = function.get_nth_param(0)?.into_float_value();
        let y = function.get_nth_param(1)?.into_float_value();

        let quotient = self.builder.build_float_div(x, y, "quotient").unwrap();
        self.builder.build_return(Some(&quotient)).unwrap();

        unsafe { self.execution_engine.get_function("div").ok() }
    }
}

fn main() -> Result<(), Box<dyn Error>> {
    // 初始化LLVM环境
    let context = Context::create();
    let module = context.create_module("calculator");
    let execution_engine = module.create_jit_execution_engine(OptimizationLevel::Aggressive)?;
    let generator = CalculatorGenerator {
        context: &context,
        module,
        builder: context.create_builder(),
        execution_engine,
    };

    // 生成各种运算函数
    let add = generator.generate_add().ok_or("无法生成加法函数")?;
    let sub = generator.generate_sub().ok_or("无法生成减法函数")?;
    let mul = generator.generate_mul().ok_or("无法生成乘法函数")?;
    let div = generator.generate_div().ok_or("无法生成除法函数")?;

    // 测试计算器功能
    let a = 10.0;
    let b = 2.5;

    unsafe {
        println!("加法结果: {} + {} = {}", a, b, add.call(a, b));
        println!("减法结果: {} - {} = {}", a, b, sub.call(a, b));
        println!("乘法结果: {} * {} = {}", a, b, mul.call(a, b));
        println!("除法结果: {} / {} = {}", a, b, div.call(a, b));
    }

    Ok(())
}

这个完整示例展示了inkwell的更多功能：

1. 创建多个函数并分别生成IR
2. 实现浮点数的加减乘除运算
3. 使用不同的优化级别
4. 组织代码结构使其更易于维护和扩展

替代方案

llvm-ir

贡献

查看项目的贡献指南参与贡献。