https://github.com/zshipko/llama

Rust LLVM bindings
https://github.com/zshipko/llama

Last synced: about 2 months ago
JSON representation

Rust LLVM bindings

• Host: GitHub
• URL: https://github.com/zshipko/llama
• Owner: zshipko
• License: isc
• Archived: true
• Created: 2020-03-11T22:50:20.000Z (over 4 years ago)
• Default Branch: master
• Last Pushed: 2023-01-31T13:03:03.000Z (almost 2 years ago)
• Last Synced: 2024-09-21T05:03:31.561Z (2 months ago)
• Language: Rust
• Homepage:
• Size: 4.43 MB
• Stars: 32
• Watchers: 5
• Forks: 2
• Open Issues: 2
• Metadata Files:
  • Readme: README.md
  • License: LICENSE.md

Awesome Lists containing this project

README

        
# llama

A friendly LLVM library for Rust.

Goals:

- Support the latest `llvm-sys` release (as of LLVM 14 and llama 0.14.0 the version numbers match)

- Provide an improved interface, while still remaining as close as possible to the LLVM C API.

Due to the size of the LLVM API there is bound to be missing, broken or incomplete functionality in `llama`, please create an issue if something you need isn't implemented.

**NOTE**: `llama` will let you generate invalid IR, take a look at [inkwell](https://github.com/TheDan64/inkwell) for LLVM bindings with a focus on type-safety

## Documentation

- [llama](https://zshipko.github.io/llama/llama) 

- [llama-build](https://zshipko.github.io/llama/llama_build) 

## Examples

Inkwell's example using `llama`:

```rust

use llama::*;

// Convenience type alias for the `sum` function.

//

// Calling this is innately `unsafe` because there's no guarantee it doesn't

// do `unsafe` operations internally.

type SumFunc = unsafe extern "C" fn(u64, u64, u64) -> u64;

fn compile_sum(jit: &mut Jit) -> Result {

    let i64 = Type::i64(jit.context())?;

    let sum_t = FuncType::new(i64, [i64, i64, i64])?;

    jit.declare_function("sum", sum_t, |build, f| {

        let params = f.params();

        let x = params[0];

        let y = params[1];

        let z = params[2];

        let sum = build.add(x, y, "sum")?;

        let sum = build.add(sum, z, "sum")?;

        build.ret(sum)

    })?;

    unsafe { jit.engine().function("sum") }

}

fn main() -> Result<(), Error> {

    let mut jit = Jit::new("sum", None)?;

    let sum = compile_sum(&mut jit)?;

    let x = 1u64;

    let y = 2u64;

    let z = 3u64;

    unsafe {

        println!("{} + {} + {} = {}", x, y, z, sum(x, y, z));

        assert_eq!(sum(x, y, z), x + y + z);

    }

    Ok(())

}

```