Struct Compiler

pub struct Compiler<'a> { /* private fields */ }

Implementations

impl<'a> Compiler<'a>

pub fn create(types: &'a TypeDatabase) -> Self

Create a new compiler instance.

Arguments

• types - The BTF type library to use when resolving types.

Example

use bpf_script::compiler::Compiler;
use bpf_script::types::TypeDatabase;

let mut database = TypeDatabase::default();
let mut compiler = Compiler::create(&database);

Examples found in repository

examples/print-instructions.rs (line 35)

fn main() {
    let prog = r#"
            fn(vec: &iovec)
              vec_copy: iovec = 0
              vec_copy.iov_base = vec.iov_base
              vec_copy.iov_len = vec.iov_len
              return 50
        "#;

    let mut database = TypeDatabase::default();

    let u64id = database
        .add_integer(Some("__u64"), 8, false)
        .expect("Failed to add type.");

    let iov_base = Field {
        offset: 0,
        type_id: u64id,
    };

    let iov_len = Field {
        offset: 64,
        type_id: u64id,
    };

    database
        .add_struct(
            Some("iovec"),
            &[("iov_base", iov_base), ("iov_len", iov_len)],
        )
        .expect("Failed to add type.");
    let mut compiler = Compiler::create(&database);
    compiler.compile(prog).unwrap();

    for ins in compiler.get_instructions() {
        println!("{}", ins);
    }
}

pub fn capture(&mut self, name: &str, value: i64)

Used to capture variables from the outer scope into the BPF program being compiled. This is mostly used to capture map identifers to pass to BPF helpers and for other integer values that need to be captured. In the future, this will be extended to capture arbitrary types making sharing between Rust and BPF more seamless.

Arguments

name - The name of the variable when referenced from the script. value - The value of the variable.

Example

use bpf_script::compiler::Compiler;
use bpf_script::types::TypeDatabase;

let mut database = TypeDatabase::default();
let mut compiler = Compiler::create(&database);
compiler.capture("outer", 0xdeadbeef);
compiler.compile(r#"
    fn()
        return outer
"#).expect("Failed to compile.");

pub fn compile(&mut self, script_text: &str) -> InternalResult<()>

Compile a given script.

Arguments

• script_text - The script to compile, as a string.

Example

use bpf_script::compiler::Compiler;
use bpf_script::types::TypeDatabase;

let mut database = TypeDatabase::default();
database.add_integer(Some("u32"), 4, false);
let mut compiler = Compiler::create(&database);
compiler.compile(r#"
    fn(a: u32)
        return a
"#).expect("Failed to compile.");

Examples found in repository

examples/print-instructions.rs (line 36)

fn main() {
    let prog = r#"
            fn(vec: &iovec)
              vec_copy: iovec = 0
              vec_copy.iov_base = vec.iov_base
              vec_copy.iov_len = vec.iov_len
              return 50
        "#;

    let mut database = TypeDatabase::default();

    let u64id = database
        .add_integer(Some("__u64"), 8, false)
        .expect("Failed to add type.");

    let iov_base = Field {
        offset: 0,
        type_id: u64id,
    };

    let iov_len = Field {
        offset: 64,
        type_id: u64id,
    };

    database
        .add_struct(
            Some("iovec"),
            &[("iov_base", iov_base), ("iov_len", iov_len)],
        )
        .expect("Failed to add type.");
    let mut compiler = Compiler::create(&database);
    compiler.compile(prog).unwrap();

    for ins in compiler.get_instructions() {
        println!("{}", ins);
    }
}

pub fn get_instructions(&self) -> &[Instruction]

Returns the internally held instructions after compile has been called.

Example

use bpf_script::compiler::Compiler;
use bpf_script::types::TypeDatabase;

let mut database = TypeDatabase::default();
database.add_integer(Some("u32"), 4, false);
let mut compiler = Compiler::create(&database);
compiler.compile(r#"
    fn(a: u32)
        return a
"#).expect("Failed to compile.");
for ins in compiler.get_instructions() {
    println!("{}", ins);
}

Examples found in repository

examples/print-instructions.rs (line 38)

fn main() {
    let prog = r#"
            fn(vec: &iovec)
              vec_copy: iovec = 0
              vec_copy.iov_base = vec.iov_base
              vec_copy.iov_len = vec.iov_len
              return 50
        "#;

    let mut database = TypeDatabase::default();

    let u64id = database
        .add_integer(Some("__u64"), 8, false)
        .expect("Failed to add type.");

    let iov_base = Field {
        offset: 0,
        type_id: u64id,
    };

    let iov_len = Field {
        offset: 64,
        type_id: u64id,
    };

    database
        .add_struct(
            Some("iovec"),
            &[("iov_base", iov_base), ("iov_len", iov_len)],
        )
        .expect("Failed to add type.");
    let mut compiler = Compiler::create(&database);
    compiler.compile(prog).unwrap();

    for ins in compiler.get_instructions() {
        println!("{}", ins);
    }
}

pub fn get_bytecode(&self) -> Vec<u64>

Returns the bytecode of a program after compile has been called. These are the raw instructions that make up a BPF program that can be passed directly to the kernel.

Example

use bpf_script::compiler::Compiler;
use bpf_script::types::TypeDatabase;

let mut database = TypeDatabase::default();
database.add_integer(Some("u32"), 4, false);
let mut compiler = Compiler::create(&database);
compiler.compile(r#"
    fn(a: u32)
        return a
"#).expect("Failed to compile.");
for ins in compiler.get_bytecode() {
    println!("{}", ins);
}