Struct Block

pub struct Block<'c>(/* private fields */);

Implementations

impl<'c> Block<'c>

pub fn append(func: Function<'c>) -> Self

Examples found in repository

examples/compile.rs (line 21)

fn main() {
  let ctxt = Ctxt::new();

  {
    let s32_ty = Type::int(&ctxt, 32);
    let fun_ty = ty::Function::new(vec![], s32_ty);
    let foo = Function::new(&ctxt, "foo", fun_ty.clone());
    let foo_start = Block::append(foo);
    let foo_ret = foo_start.build_const_int(s32_ty, 0);
    foo_start.build_return(foo_ret);

    let main = Function::new(&ctxt, "main", fun_ty);
    let main_start = Block::append(main); // the first block added is the entry
                                          // block
    let main_end = Block::append(main);
    let main_ret = main_start.build_call(foo, &[]);
    main_start.build_branch(main_end);
    main_end.build_call(foo, &[]); // useless, but you can still do
    main_end.build_return(main_ret);
  }

  println!("{}", ctxt);
}

pub fn build_const_int(self, ty: Type<'c>, value: u64) -> Value<'c>

Examples found in repository

examples/compile.rs (line 22)

fn main() {
  let ctxt = Ctxt::new();

  {
    let s32_ty = Type::int(&ctxt, 32);
    let fun_ty = ty::Function::new(vec![], s32_ty);
    let foo = Function::new(&ctxt, "foo", fun_ty.clone());
    let foo_start = Block::append(foo);
    let foo_ret = foo_start.build_const_int(s32_ty, 0);
    foo_start.build_return(foo_ret);

    let main = Function::new(&ctxt, "main", fun_ty);
    let main_start = Block::append(main); // the first block added is the entry
                                          // block
    let main_end = Block::append(main);
    let main_ret = main_start.build_call(foo, &[]);
    main_start.build_branch(main_end);
    main_end.build_call(foo, &[]); // useless, but you can still do
    main_end.build_return(main_ret);
  }

  println!("{}", ctxt);
}

pub fn build_call(self, func: Function<'c>, args: &[Value<'c>]) -> Value<'c>

Examples found in repository

examples/compile.rs (line 29)

fn main() {
  let ctxt = Ctxt::new();

  {
    let s32_ty = Type::int(&ctxt, 32);
    let fun_ty = ty::Function::new(vec![], s32_ty);
    let foo = Function::new(&ctxt, "foo", fun_ty.clone());
    let foo_start = Block::append(foo);
    let foo_ret = foo_start.build_const_int(s32_ty, 0);
    foo_start.build_return(foo_ret);

    let main = Function::new(&ctxt, "main", fun_ty);
    let main_start = Block::append(main); // the first block added is the entry
                                          // block
    let main_end = Block::append(main);
    let main_ret = main_start.build_call(foo, &[]);
    main_start.build_branch(main_end);
    main_end.build_call(foo, &[]); // useless, but you can still do
    main_end.build_return(main_ret);
  }

  println!("{}", ctxt);
}

pub fn build_mul(self, lhs: Value<'c>, rhs: Value<'c>) -> Value<'c>

pub fn build_udiv(self, lhs: Value<'c>, rhs: Value<'c>) -> Value<'c>

pub fn build_sdiv(self, lhs: Value<'c>, rhs: Value<'c>) -> Value<'c>

pub fn build_urem(self, lhs: Value<'c>, rhs: Value<'c>) -> Value<'c>

pub fn build_srem(self, lhs: Value<'c>, rhs: Value<'c>) -> Value<'c>

pub fn build_add(self, lhs: Value<'c>, rhs: Value<'c>) -> Value<'c>

pub fn build_sub(self, lhs: Value<'c>, rhs: Value<'c>) -> Value<'c>

pub fn build_shl(self, lhs: Value<'c>, rhs: Value<'c>) -> Value<'c>

pub fn build_zshr(self, lhs: Value<'c>, rhs: Value<'c>) -> Value<'c>

pub fn build_sshr(self, lhs: Value<'c>, rhs: Value<'c>) -> Value<'c>

pub fn build_and(self, lhs: Value<'c>, rhs: Value<'c>) -> Value<'c>

pub fn build_xor(self, lhs: Value<'c>, rhs: Value<'c>) -> Value<'c>

pub fn build_or(self, lhs: Value<'c>, rhs: Value<'c>) -> Value<'c>

pub fn build_return(self, value: Value<'c>)

Examples found in repository

examples/compile.rs (line 23)

fn main() {
  let ctxt = Ctxt::new();

  {
    let s32_ty = Type::int(&ctxt, 32);
    let fun_ty = ty::Function::new(vec![], s32_ty);
    let foo = Function::new(&ctxt, "foo", fun_ty.clone());
    let foo_start = Block::append(foo);
    let foo_ret = foo_start.build_const_int(s32_ty, 0);
    foo_start.build_return(foo_ret);

    let main = Function::new(&ctxt, "main", fun_ty);
    let main_start = Block::append(main); // the first block added is the entry
                                          // block
    let main_end = Block::append(main);
    let main_ret = main_start.build_call(foo, &[]);
    main_start.build_branch(main_end);
    main_end.build_call(foo, &[]); // useless, but you can still do
    main_end.build_return(main_ret);
  }

  println!("{}", ctxt);
}

pub fn build_branch(self, blk: Block<'c>)

Examples found in repository

examples/compile.rs (line 30)

fn main() {
  let ctxt = Ctxt::new();

  {
    let s32_ty = Type::int(&ctxt, 32);
    let fun_ty = ty::Function::new(vec![], s32_ty);
    let foo = Function::new(&ctxt, "foo", fun_ty.clone());
    let foo_start = Block::append(foo);
    let foo_ret = foo_start.build_const_int(s32_ty, 0);
    foo_start.build_return(foo_ret);

    let main = Function::new(&ctxt, "main", fun_ty);
    let main_start = Block::append(main); // the first block added is the entry
                                          // block
    let main_end = Block::append(main);
    let main_ret = main_start.build_call(foo, &[]);
    main_start.build_branch(main_end);
    main_end.build_call(foo, &[]); // useless, but you can still do
    main_end.build_return(main_ret);
  }

  println!("{}", ctxt);
}

Trait Implementations

impl<'c> Clone for Block<'c>

fn clone(&self) -> Block<'c>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'c> Copy for Block<'c>