Struct Program

pub struct Program(pub Vec<Token>);

Parsed program representation

The program is represented using Reverse Polish Notation, which is lends to easy iterative translation into CLIF as well as to simple optimizations.

Tuple Fields

0: Vec<Token>

Implementations

impl Program

pub fn new(tokens: Vec<Token>) -> Self

Constructs program directly from RPN

pub fn parse_from_infix(expr: &str) -> Result<Self, JitError>

Parses an infix notation into RPN

pub fn reorder_ops_deepen(&mut self)

Rewrites RPN into a deeper form that’s more optimizable

The optimizer isn’t able to optimize RPN like [.. 1 + 1 +]. This function will replace it with [.. 1 1 + +], which the optimizer will rewrite as [.. 2 +].

The resultant form has a deeper stack, meaning more variables need to be kept alive at the same time.

pub fn reorder_ops_flatten(&mut self)

Rewrites RPN into a form that requires a lower stack

a * (b / c) will produce RPN a b c / *, which keeps up to 3 variables alive at once. This optimization will rewrite it into RPN a b * c /, which does the same work despite using less memory.

Notably the constant folding algorithm in this library will fail to optimize this form.

pub fn fold_constants_step(&mut self, library: &Library) -> bool

Evaluate some constant expressions

Optimizes binary and unary operations:

• replace [const0, const1, op] with [op(const0, const1)]
• replace [const, op] with [op(const)]

Token::Noop is removed in the process. Only one pass over the code is made. Returns false if no further progress can be made.

Doesn’t support reordering of associative operations, so [var, const0, add, const1, add] is not replaced with [var, add(const0, const1), add] and so on.

pub fn optimize(&mut self, library: &Library)

Rewrites RPN into a form most suitable for codegen

Performs constant folding and minimizes stack usage of the resultant RPN.

For details, see:

• Self::reorder_ops_deepen
• Self::reorder_ops_flatten
• Self::fold_constants_step

Trait Implementations

impl Debug for Program

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Program

fn eq(&self, other: &Program) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Program

fn partial_cmp(&self, other: &Program) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Program