glove

Types

Block

Function block with a label

pub type Block {
  Block(label: String, statements: List(Statement))
}

Constructors

Block(label: String, statements: List(Statement))

Comp

</>

QBE Comparison Operators

pub type Comp {
  Slt
  Sle
  Sgt
  Sge
  Eq
  Ne
}

Constructors

```
Slt
```
Less Than
```
Sle
```
Less or Equal
```
Sgt
```
Greater than
```
Sge
```
Greater or equal
```
Eq
```
Equal
```
Ne
```
Not equal

DataDef

</>

QBE data definition

pub type DataDef {
  DataDef(
    linkage: Linkage,
    name: String,
    align: Option(Int),
    items: List(#(Type, DataItem)),
  )
}

Constructors

DataDef(
  linkage: Linkage,
  name: String,
  align: Option(Int),
  items: List(#(Type, DataItem)),
)

DataItem

</>

QBE Data definition item

pub type DataItem {
  Symbol(String, Option(Int))
  Str(String)
  Constant(Int)
}

Constructors

```
Symbol(String, Option(Int))
```
Symbol and offset
```
Str(String)
```
String
```
Constant(Int)
```
Integer

Function

</>

QBE Function

pub type Function {
  Function(
    linkage: Linkage,
    name: String,
    arguments: List(#(Type, Value)),
    return_ty: Option(Type),
    blocks: List(Block),
  )
}

Constructors

Function(
  linkage: Linkage,
  name: String,
  arguments: List(#(Type, Value)),
  return_ty: Option(Type),
  blocks: List(Block),
)

Inst

</>

QBE instruction

pub type Inst {
  Add(Value, Value)
  Sub(Value, Value)
  Mul(Value, Value)
  Div(Value, Value)
  Rem(Value, Value)
  Comp(Type, Comp, Value, Value)
  And(Value, Value)
  Or(Value, Value)
  Copy(Value)
  Ret(Option(Value))
  Jnz(Value, String, String)
  Jmp(String)
  Call(Value, List(#(Type, Value)))
  Alloc4(Int)
  Alloc8(Int)
  Alloc16(Int)
  Store(Type, Value, Value)
  Load(Type, Value)
  Blit(Value, Value, Int)
}

Constructors

```
Add(Value, Value)
```
Adds values
```
Sub(Value, Value)
```
Substracts value(b) from value(a)
```
Mul(Value, Value)
```
Multiplies values
```
Div(Value, Value)
```
Divides value(a) by value(b)
```
Rem(Value, Value)
```
Returns a remaider from division
```
Comp(Type, Comp, Value, Value)
```
Perform a Comparison
```
And(Value, Value)
```
Bitwise AND
```
Or(Value, Value)
```
Bitwise OR
```
Copy(Value)
```
Copies either temporary or literal value
```
Ret(Option(Value))
```
Return from a function, optionally with a value
```
Jnz(Value, String, String)
```
Jumps to first label if a value is nonzero or to the second one otherwise
```
Jmp(String)
```
Unconditionally jumps to a label
```
Call(Value, List(#(Type, Value)))
```
Calls a function
```
Alloc4(Int)
```
Allocates a 4-byte aligned area on the stack
```
Alloc8(Int)
```
Allocates a 8-byte aligned area on the stack
```
Alloc16(Int)
```
Allocates a 16-byte aligned area on the stack
```
Store(Type, Value, Value)
```
Stores a value into memory pointed to by destination. (type, destination, value)
```
Load(Type, Value)
```
Loads a value from memory pointed to by source (type, source)
```
Blit(Value, Value, Int)
```
(source, destination, n)

Copy n bytes from the source address to the destination address.

n must be a constant value.

Minimum supported QBE version 1.1

Linkage

</>

Linkage of a function or data defintion (e.g. section and private/public status)

pub type Linkage {
  Linkage(
    exported: Bool,
    section: Option(String),
    secflags: Option(String),
  )
}

Constructors

Linkage(
  exported: Bool,
  section: Option(String),
  secflags: Option(String),
)

Module

</>

A complete IL file

pub type Module {
  Module(
    functions: List(Function),
    types: List(TypeDef),
    data: List(DataDef),
  )
}

Constructors

Module(
  functions: List(Function),
  types: List(TypeDef),
  data: List(DataDef),
)

Statement

</>

IR Statement

pub type Statement {
  Assign(Value, Type, Inst)
  Volatile(Inst)
}

Constructors

```
Assign(Value, Type, Inst)
```
```
Volatile(Inst)
```

Type

</>

QBE Types

pub type Type {
  Word
  Long
  Single
  Double
  Byte
  Halfword
  Aggregate(TypeDef)
}

Constructors

```
Word
```
Base Types
```
Long
```
```
Single
```
```
Double
```
```
Byte
```
Extended Types
```
Halfword
```
```
Aggregate(TypeDef)
```

TypeDef

</>

QBE aggregate type definition

pub type TypeDef {
  TypeDef(
    name: String,
    align: Option(Int),
    items: List(#(Type, Int)),
  )
}

Constructors

TypeDef(
  name: String,
  align: Option(Int),
  items: List(#(Type, Int)),
)

Value

</>

QBE Value for instructions

pub type Value {
  Temporary(name: String)
  Global(name: String)
  Const(value: Int)
}

Constructors

```
Temporary(name: String)
```
%-temporary
```
Global(name: String)
```
$-global
```
Const(value: Int)
```
Constant

Functions

add_block

</>

pub fn add_block(label: String) -> Block

Adds a new empty block with a specified label and returns a reference to it

add_data

</>

pub fn add_data(module: Module, data_def: DataDef) -> Module

Add Data to module

add_function

</>

pub fn add_function(module: Module, function: Function) -> Module

Add function to module

add_inst

</>

pub fn add_inst(block: Block, inst: Inst) -> Block

Adds a new instruction to the block

add_type

</>

pub fn add_type(module: Module, type_def: TypeDef) -> Module

Add type to module

assign_inst

</>

pub fn assign_inst(
  block: Block,
  val: Value,
  typ: Type,
  inst: Inst,
) -> Block

Adds a new instruction assigned to a temporary

display_arguments

</>

pub fn display_arguments(
  arguments: List(#(Type, Value)),
) -> String

Display functions Arguments

display_block

</>

pub fn display_block(block: Block) -> String

Display function for block

display_blocks

</>

pub fn display_blocks(blocks: List(Block)) -> String

Display blocks

display_data_def

</>

pub fn display_data_def(def: DataDef) -> String

Display function for Datadef

display_data_item

</>

pub fn display_data_item(item: DataItem) -> String

Display function for DataItem

display_function

</>

pub fn display_function(func: Function) -> String

Display function for functions

display_inst

</>

pub fn display_inst(inst: Inst) -> String

Display function for Instructions

display_linkage

</>

pub fn display_linkage(linkage: Linkage) -> String

Display function for Linkage

display_module

</>

pub fn display_module(module: Module) -> String

Display function for Module

display_statement

</>

pub fn display_statement(stmt: Statement) -> String

Display function for Statement

display_type

</>

pub fn display_type(ty: Type) -> String

Display Type function

display_type_def

</>

pub fn display_type_def(def: TypeDef) -> String

Display function for TypeDef

display_value

</>

pub fn display_value(value: Value) -> String

Display Value function

into_abi

</>

pub fn into_abi(self: Type) -> Type

Aggregate type with a specified name Returns a C ABI type. Extended types are converted to closest base types

into_base

</>

pub fn into_base(self: Type) -> Type

Returns the closest base type

jumps

</>

pub fn jumps(block: Block) -> Bool

Returns true if the block’s last instruction is a jump

last_block

</>

pub fn last_block(blocks: List(Block)) -> Option(Block)

Returns a reference to the last block

new_datadef

</>

pub fn new_datadef() -> DataDef

new_function

</>

pub fn new_function() -> Function

Instantiates an empty function and returns it

new_module

</>

pub fn new_module() -> Module

Creates a new module

private

</>

pub fn private() -> Linkage

Returns the default configuration for private linkage

private_with_section

</>

pub fn private_with_section(section: String) -> Linkage

Returns the configuration for private linkage with a provided section

public

</>

pub fn public() -> Linkage

Returns the default configuration for public linkage

public_with_section

</>

pub fn public_with_section(section: String) -> Linkage

Returns the configuration for public linkage with a provided section

size

</>

pub fn size(self: Type) -> Int

Returns byte size for values of the type