mooncakes.io

azhzx/qbe/types does not have a README file

BlkId

type BlkId = Int

Addr

source

pub(all) struct Addr {
  offset : Con
  base : Ref
  index : Ref
  scale : Int
} derive(@moonbitlang/core/debug.Debug
Debug)

Addr::new

source

fn Addr::new() -> Addr

AliasInfo

source

pub(all) struct AliasInfo {
  kind : AliasType
  base : Ref
  label : Int
  offset : Int64
  slot : Int
} derive(@moonbitlang/core/debug.Debug
Debug)

AliasInfo::default

source

fn AliasInfo::default() -> AliasInfo

AliasType

source

pub(all) enum AliasType {
  ABot
  ALoc
  ACon
  AEsc
  ASym
  AUnk
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

AliasType::astack

source

#as_free_fn(astack, deprecated="use `AliasType::astack` instead")
fn AliasType::astack(self : AliasType) -> Bool

BSet

source

pub(all) struct BSet {
  nt : Int
  bits : Array[UInt64]
} derive(@moonbitlang/core/debug.Debug
Debug)

BSet::clr

source

fn BSet::clr(self : BSet, elt : Int) -> Unit

BSet::copy_from

source

fn BSet::copy_from(self : BSet, other : BSet) -> Unit

BSet::count

source

fn BSet::count(self : BSet) -> Int

BSet::diff

source

fn BSet::diff(self : BSet, other : BSet) -> Unit

BSet::each

source

fn BSet::each(self : BSet, f : (Int) -> Unit) -> Unit

BSet::each_from

source

fn BSet::each_from(self : BSet, start : Int, f : (Int) -> Unit) -> Unit

BSet::equal

source

fn BSet::equal(self : BSet, other : BSet) -> Bool

BSet::has

source

fn BSet::has(self : BSet, elt : Int) -> Bool

BSet::inter

source

fn BSet::inter(self : BSet, other : BSet) -> Unit

BSet::iter

source

fn BSet::iter(self : BSet, start : Int) -> Int

BSet::new

source

fn BSet::new(nt : Int) -> BSet

BSet::set

source

fn BSet::set(self : BSet, elt : Int) -> Unit

BSet::union

source

fn BSet::union(self : BSet, other : BSet) -> Bool

BSet::zero

source

fn BSet::zero(self : BSet) -> Unit

Blk

source

pub(all) struct Blk {
  id : Int
  name : String
  phi : Array[Phi]
  ins : Array[Ins]
  jmp : Jump
  pred : Array[Int]
  npred : Int
  idom : Int
  dom_link : Int
  dom_next : Int
  fron : Array[Int]
  rpo_id : Int
  loop_depth : Int
  nlive_w : Int
  nlive_d : Int
  in_set : BSet?
  out_set : BSet?
  gen_set : BSet?
  link : Int
  visit : Int
} derive(@moonbitlang/core/debug.Debug
Debug)

Blk::new

source

fn Blk::new(id : Int, name : String) -> Blk

Class

source

pub(all) enum Class {
  Kx
  Kw
  Kl
  Ks
  Kd
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Class - corresponds to enum Class in all.h

Class::base

source

#as_free_fn(kbase, deprecated="use `Class::base` instead")
fn Class::base(self : Class) -> Int

kbase - base class: 0 for int (w/l), 1 for float (s/d) (corresponds to C KBASE())

Class::code

source

#as_free_fn(kcode, deprecated="use `Class::code` instead")
fn Class::code(self : Class) -> Int

kcode - class to code: Kx->-1, Kw->0, Kl->1, Ks->2, Kd->3.

Class::from_code

source

#as_free_fn(class_from_code, deprecated="use `Class::from_code` instead")
fn Class::from_code(c : Int) -> Class

class_from_code - inverse of kcode: 0->Kw, 1->Kl, 2->Ks, 3->Kd, else Kx.

Class::wide

source

#as_free_fn(kwide, deprecated="use `Class::wide` instead")
fn Class::wide(self : Class) -> Int

kwide - 1 if wide (l/d), 0 otherwise (corresponds to C KWIDE())

Con

source

pub(all) struct Con {
  kind : ConType
  label : Int
  bits : ConBits
  flt : Int
  is_local : Bool
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Con::add

source

#as_free_fn(addcon, deprecated="use `Con::add` instead")
fn Con::add(self : Con, other : Con) -> Con

Con::addr

source

fn Con::addr(label : Int) -> Con

Con::double

source

fn Con::double(d : Double) -> Con

Con::int

source

fn Con::int(i : Int64) -> Con

Con::is_zero

source

fn Con::is_zero(self : Con, wide : Bool) -> Bool

Con::new

source

fn Con::new() -> Con

Con::raw_bits

source

#as_free_fn(con_raw_bits, deprecated="use `Con::raw_bits` instead")
fn Con::raw_bits(self : Con) -> Int64

Con::single

source

fn Con::single(s : Float) -> Con

ConBits

source

pub(all) struct ConBits {
  i : Int64
  d : Double
  s : Float
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

ConType

source

pub(all) enum ConType {
  CUndef
  CBits
  CAddr
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Dat

source

pub(all) struct Dat {
  kind : DatKind
  num : Int64
  fltd : Double
  flts : Float
  str : String
  ref_name : String
  ref_offset : Int64
  is_ref : Bool
  is_str : Bool
  is_export : Bool
} derive(@moonbitlang/core/debug.Debug
Debug)

Dat::align

source

fn Dat::align(a : Int64) -> Dat

Dat::byte

source

fn Dat::byte(b : Int64) -> Dat

Dat::end

source

fn Dat::end() -> Dat

Dat::name

source

fn Dat::name(name : String, is_export : Bool) -> Dat

Dat::ref_to

source

fn Dat::ref_to(name : String, offset : Int64) -> Dat

Dat::start

source

fn Dat::start() -> Dat

Dat::string

source

fn Dat::string(s : String) -> Dat

Dat::zero

source

fn Dat::zero(n : Int64) -> Dat

DatKind

source

pub(all) enum DatKind {
  DStart
  DEnd
  DName
  DAlign
  DB
  DH
  DW
  DL
  DZ
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Field

source

pub(all) struct Field {
  kind : FieldType
  len : Int
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Field::end

source

fn Field::end() -> Field

Field::new

source

fn Field::new(kind : FieldType, len : Int) -> Field

FieldType

source

pub(all) enum FieldType {
  FEnd
  Fb
  Fh
  Fw
  Fl
  Fs
  Fd
  FPad
  FTyp
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Fn

source

pub(all) struct Fn {
  name : String
  start_id : Int
  blks : Array[Blk]
  blk_names : Map[String, Int]
  tmps : Array[Tmp]
  cons : Array[Con]
  mems : Array[Addr]
  rpo : Array[Int]
  def_order : Array[Int]
  ret_ty : Int
  retr : Ref
  reg : UInt64
  slot : Int
  is_export : Bool
  is_vararg : Bool
  has_dynalloc : Bool
} derive(@moonbitlang/core/debug.Debug
Debug)

Fn::add_blk

source

fn Fn::add_blk(self : Fn, name : String) -> Int

Fn::add_con

source

fn Fn::add_con(self : Fn, con : Con) -> Int

Fn::add_tmp

source

fn Fn::add_tmp(self : Fn, name : String, cls : Class) -> Int

Fn::blk

source

fn Fn::blk(self : Fn, id : Int) -> Blk

Fn::con

source

fn Fn::con(self : Fn, id : Int) -> Con

Fn::find_blk

source

fn Fn::find_blk(self : Fn, name : String) -> Int

Fn::get_con

source

fn Fn::get_con(self : Fn, val : Int64) -> Int

Fn::get_con_by

source

fn Fn::get_con_by(self : Fn, con : Con) -> Int

Fn::init_regs

source

fn Fn::init_regs(self : Fn) -> Unit

Fn::init_regs_wasm

source

fn Fn::init_regs_wasm(self : Fn) -> Unit

Fn::nblk

source

fn Fn::nblk(self : Fn) -> Int

Fn::ncon

source

fn Fn::ncon(self : Fn) -> Int

Fn::new

source

fn Fn::new(name : String) -> Fn

Fn::new_tmp

source

fn Fn::new_tmp(self : Fn, prfx : String, cls : Class) -> Int

Fn::ntmp

source

fn Fn::ntmp(self : Fn) -> Int

Fn::tmp

source

fn Fn::tmp(self : Fn, id : Int) -> Tmp

FpBits

source

pub struct FpBits {
  b0 : Int64
  b1 : Int64
  size : Int
}

Ins

source

pub(all) struct Ins {
  op : Op
  cls : Class
  to : Ref
  arg1 : Ref
  arg2 : Ref
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Ins::new

source

fn Ins::new(op : Op, cls : Class, to : Ref, arg1 : Ref, arg2 : Ref) -> Ins

Ins::new_void

source

fn Ins::new_void(op : Op, cls : Class, arg1 : Ref, arg2 : Ref) -> Ins

Jump

source

pub(all) struct Jump {
  kind : JumpKind
  arg : Ref
  s1 : Int
  s2 : Int
} derive(@moonbitlang/core/debug.Debug
Debug)

Jump::full

source

fn Jump::full(kind : JumpKind, arg : Ref, s1 : Int, s2 : Int) -> Jump

Jump::new

source

fn Jump::new(kind : JumpKind) -> Jump

JumpKind

source

pub(all) enum JumpKind {
  Jxxx
  Jret0
  Jretw
  Jretl
  Jrets
  Jretd
  Jretc
  Jjmp
  Jjnz
  Jjfieq
  Jjfine
  Jjfisge
  Jjfisgt
  Jjfisle
  Jjfislt
  Jjfiuge
  Jjfiugt
  Jjfiule
  Jjfiult
  Jjffeq
  Jjffge
  Jjffgt
  Jjffle
  Jjfflt
  Jjffne
  Jjffo
  Jjffuo
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

JumpKind::from_index

source

#as_free_fn(jump_from_index, deprecated="use `JumpKind::from_index` instead")
fn JumpKind::from_index(i : Int) -> JumpKind

JumpKind::index

source

#as_free_fn(jump_index, deprecated="use `JumpKind::index` instead")
fn JumpKind::index(self : JumpKind) -> Int

JumpKind::is_ret

source

#as_free_fn(is_ret, deprecated="use `JumpKind::is_ret` instead")
fn JumpKind::is_ret(self : JumpKind) -> Bool

Op

source

pub(all) enum Op {
  Oxxx
  Add
  Sub
  Div
  Rem
  Udiv
  Urem
  Mul
  And
  Or
  Xor
  Sar
  Shr
  Shl
  Ceqw
  Cnew
  Csgew
  Csgtw
  Cslew
  Csltw
  Cugew
  Cugtw
  Culew
  Cultw
  Ceql
  Cnel
  Csgel
  Csgtl
  Cslel
  Csltl
  Cugel
  Cugtl
  Culel
  Cultl
  Ceqs
  Cges
  Cgts
  Cles
  Clts
  Cnes
  Cos
  Cuos
  Ceqd
  Cged
  Cgtd
  Cled
  Cltd
  Cned
  Cod
  Cuod
  Storeb
  Storeh
  Storew
  Storel
  Stores
  Stored
  Loadsb
  Loadub
  Loadsh
  Loaduh
  Loadsw
  Loaduw
  Load
  Extsb
  Extub
  Extsh
  Extuh
  Extsw
  Extuw
  Exts
  Truncd
  Stosi
  Dtosi
  Swtof
  Sltof
  Cast
  Alloc4
  Alloc8
  Alloc16
  Vaarg
  Vastart
  Copy
  Nop
  Addr
  Swap
  Sign
  Salloc
  Xidiv
  Xdiv
  Xcmp
  Xtest
  Acmp
  Acmn
  Afcmp
  Par
  Parc
  Pare
  Arg
  Argc
  Arge
  Call
  Vacall
  Flagieq
  Flagine
  Flagisge
  Flagisgt
  Flagisle
  Flagislt
  Flagiuge
  Flagiugt
  Flagiule
  Flagiult
  Flagfeq
  Flagfge
  Flagfgt
  Flagfle
  Flagflt
  Flagfne
  Flagfo
  Flagfuo
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Op::ext_width_idx

source

#as_free_fn(ext_width_idx, deprecated="use `Op::ext_width_idx` instead")
fn Op::ext_width_idx(self : Op) -> Int

Op::from_index

source

#as_free_fn(op_from_index, deprecated="use `Op::from_index` instead")
fn Op::from_index(i : Int) -> Op

Op::from_string

source

#as_free_fn(op_from_string, deprecated="use `Op::from_string` instead")
fn Op::from_string(s : String) -> Op

Op::index

source

#as_free_fn(op_index, deprecated="use `Op::index` instead")
fn Op::index(self : Op) -> Int

Op::is_arg

source

#as_free_fn(is_arg, deprecated="use `Op::is_arg` instead")
fn Op::is_arg(self : Op) -> Bool

Op::is_ext

source

#as_free_fn(is_ext, deprecated="use `Op::is_ext` instead")
fn Op::is_ext(self : Op) -> Bool

Op::is_load

source

#as_free_fn(is_load, deprecated="use `Op::is_load` instead")
fn Op::is_load(self : Op) -> Bool

Op::is_par

source

#as_free_fn(is_par, deprecated="use `Op::is_par` instead")
fn Op::is_par(self : Op) -> Bool

Op::is_store

source

#as_free_fn(is_store, deprecated="use `Op::is_store` instead")
fn Op::is_store(self : Op) -> Bool

Op::load_width_idx

source

#as_free_fn(load_width_idx, deprecated="use `Op::load_width_idx` instead")
fn Op::load_width_idx(self : Op) -> Int

Op::name

source

fn Op::name(self : Op) -> String

OpInfo

source

pub(all) struct OpInfo {
  name : String
  a0 : Array[Int]
  a1 : Array[Int]
  canfold : Bool
  nmem : Int
  zf : Int
  lf : Int
} derive(@moonbitlang/core/debug.Debug
Debug)

Phi

source

pub(all) struct Phi {
  cls : Class
  to : Ref
  args : Array[PhiArg]
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Phi::new

source

fn Phi::new(to : Ref, cls : Class) -> Phi

PhiArg

source

pub(all) struct PhiArg {
  value : Ref
  blk_id : Int
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Ref

source

pub(all) enum Ref {
  RNone
  RTmp(Int)
  RCon(Int)
  RType(Int)
  RSlot(Int)
  RCall(Int)
  RMem(Int)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

ADT replacing C bit-field (uint type:3; uint val:29)

Ref::argregs

source

#as_free_fn(argregs, deprecated="use `Ref::argregs` instead")
fn Ref::argregs(self : Ref) -> (UInt64, Int, Int)

Ref::call

source

fn Ref::call(i : Int) -> Ref

CALL(x) - call result reference

Ref::call_val

source

fn Ref::call_val(self : Ref) -> Int

call_val - extract call info index, -1 if not a call ref

Ref::con

source

fn Ref::con(i : Int) -> Ref

CON(x) - constant reference

Ref::con_val

source

fn Ref::con_val(self : Ref) -> Int

con_val - extract constant index, -1 if not a constant

Ref::eq

source

#as_free_fn(req, deprecated="use `Ref::eq` instead")
fn Ref::eq(self : Ref, other : Ref) -> Bool

req - reference equality (corresponds to C req())

Ref::is_con

source

fn Ref::is_con(self : Ref) -> Bool

is_con - check for constant reference

Ref::is_mem

source

fn Ref::is_mem(self : Ref) -> Bool

is_mem - check for memory reference

Ref::is_none

source

fn Ref::is_none(self : Ref) -> Bool

is_none - check for empty reference

Ref::is_slot

source

fn Ref::is_slot(self : Ref) -> Bool

is_slot - check for slot reference

Ref::is_tmp

source

fn Ref::is_tmp(self : Ref) -> Bool

is_tmp - check for temporary reference

Ref::mem

source

fn Ref::mem(i : Int) -> Ref

MEM(x) - memory address reference

Ref::mem_val

source

fn Ref::mem_val(self : Ref) -> Int

mem_val - extract memory index, -1 if not a memory ref

Ref::none

source

#as_free_fn(ref_none, deprecated="use `Ref::none` instead")
fn Ref::none() -> Ref

R - empty reference (corresponds to C macro R)

Ref::retregs

source

#as_free_fn(retregs, deprecated="use `Ref::retregs` instead")
fn Ref::retregs(self : Ref) -> (UInt64, Int, Int)

Ref::rv64_argregs

source

fn Ref::rv64_argregs(self : Ref) -> (UInt64, Int, Int)

Ref::rv64_retregs

source

fn Ref::rv64_retregs(self : Ref) -> (UInt64, Int, Int)

Ref::slot

source

fn Ref::slot(i : Int) -> Ref

SLOT(x) - stack slot reference (value masked to 29 bits, as C SLOT())

Ref::slot_val

source

fn Ref::slot_val(self : Ref) -> Int

slot_val - extract slot index, -1 if not a slot ref

Ref::tmp

source

fn Ref::tmp(i : Int) -> Ref

TMP(x) - temporary reference

Ref::tmp_val

source

fn Ref::tmp_val(self : Ref) -> Int

tmp_val - extract temporary index, -1 if not a temp

Ref::typ

source

fn Ref::typ(i : Int) -> Ref

TYPE(x) - type reference

Ref::typ_val

source

fn Ref::typ_val(self : Ref) -> Int

typ_val - extract type index, -1 if not a type ref

RegHint

source

pub(all) struct RegHint {
  r : Int
  w : Int
  m : UInt64
} derive(@moonbitlang/core/debug.Debug
Debug)

RegHint::default

source

fn RegHint::default() -> RegHint

TargetCfg

source

pub struct TargetCfg {
  gpr_base : Int
  fpr_base : Int
  ngpr : Int
  nfpr : Int
  fpr_class_base : Int
  post_call_gpr : Int
  post_call_fpr : Int
  rglob_mask : UInt64
  rsave : Array[Int]
  retregs : (Ref) -> (UInt64, Int, Int)
  argregs : (Ref) -> (UInt64, Int, Int)
}

Tmp

source

pub(all) struct Tmp {
  name : String
  uses : Array[Use]
  ndef : Int
  nuse : Int
  cost : Int
  slot : Int
  cls : Class
  hint : RegHint
  is_phi : Int
  alias_info : AliasInfo
  width : TmpWidth
  visit : Int
} derive(@moonbitlang/core/debug.Debug
Debug)

Tmp::new

source

fn Tmp::new(name : String, cls : Class) -> Tmp

TmpWidth

source

pub(all) enum TmpWidth {
  WFull
  Wsb
  Wub
  Wsh
  Wuh
  Wsw
  Wuw
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

TmpWidth::code

source

#as_free_fn(width_code, deprecated="use `TmpWidth::code` instead")
fn TmpWidth::code(self : TmpWidth) -> Int

TmpWidth::from_code

source

#as_free_fn(width_from_code, deprecated="use `TmpWidth::from_code` instead")
fn TmpWidth::from_code(c : Int) -> TmpWidth

Typ

source

pub(all) struct Typ {
  name : String
  dark : Int
  align : Int
  size : Int64
  nunion : Int
  fields : Array[Field]
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Typ::new

source

fn Typ::new(name : String) -> Typ

Use

source

pub(all) struct Use {
  kind : UseKind
  blk_id : Int
  ins_idx : Int
  arg_num : Int
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

UseKind

source

pub(all) enum UseKind {
  UXXX
  UPhi
  UIns
  UJmp
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

WasmType

source

pub enum WasmType {
  Wi32
  Wi64
  Wf32
  Wf64
  WVoid
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A0

source

let A0 : Int

A1

source

let A1 : Int

A2

source

let A2 : Int

A3

source

let A3 : Int

A4

source

let A4 : Int

A5

source

let A5 : Int

A6

source

let A6 : Int

A7

source

let A7 : Int

FA0

source

let FA0 : Int

FA1

source

let FA1 : Int

FA2

source

let FA2 : Int

FA3

source

let FA3 : Int

FA4

source

let FA4 : Int

FA5

source

let FA5 : Int

FA6

source

let FA6 : Int

FA7

source

let FA7 : Int

FP

source

let FP : Int

FS0

source

let FS0 : Int

FS1

source

let FS1 : Int

FS10

source

let FS10 : Int

FS11

source

let FS11 : Int

FS2

source

let FS2 : Int

FS3

source

let FS3 : Int

FS4

source

let FS4 : Int

FS5

source

let FS5 : Int

FS6

source

let FS6 : Int

FS7

source

let FS7 : Int

FS8

source

let FS8 : Int

FS9

source

let FS9 : Int

FT0

source

let FT0 : Int

FT1

source

let FT1 : Int

FT10

source

let FT10 : Int

FT11

source

let FT11 : Int

FT2

source

let FT2 : Int

FT3

source

let FT3 : Int

FT4

source

let FT4 : Int

FT5

source

let FT5 : Int

FT6

source

let FT6 : Int

FT7

source

let FT7 : Int

FT8

source

let FT8 : Int

FT9

source

let FT9 : Int

GP

source

let GP : Int

NCLR

source

let NCLR : Int

NFPR

source

let NFPR : Int

NFPS

source

let NFPS : Int

NGPR

source

let NGPR : Int

NGPS

source

let NGPS : Int

NRGLOB

source

let NRGLOB : Int

R10

source

let R10 : Int

R11

source

let R11 : Int

R12

source

let R12 : Int

R13

source

let R13 : Int

R14

source

let R14 : Int

R15

source

let R15 : Int

R8

source

let R8 : Int

R9

source

let R9 : Int

RA

source

let RA : Int

RAX

source

let RAX : Int

RBP

source

let RBP : Int

RBX

source

let RBX : Int

RCX

source

let RCX : Int

RDI

source

let RDI : Int

RDX

source

let RDX : Int

RSI

source

let RSI : Int

RSP

source

let RSP : Int

RXX

source

let RXX : Int

Rv64KmIsWide

source

let Rv64KmIsWide : Int

Rv64NCLR

source

let Rv64NCLR : Int

Rv64NFPR

source

let Rv64NFPR : Int

Rv64NFPS

source

let Rv64NFPS : Int

Rv64NGPR

source

let Rv64NGPR : Int

Rv64NGPS

source

let Rv64NGPS : Int

Rv64NRGLOB

source

let Rv64NRGLOB : Int

Rv64Tmp0

source

let Rv64Tmp0 : Int

S1

source

let S1 : Int

S10

source

let S10 : Int

S11

source

let S11 : Int

S2

source

let S2 : Int

S3

source

let S3 : Int

S4

source

let S4 : Int

S5

source

let S5 : Int

S6

source

let S6 : Int

S7

source

let S7 : Int

S8

source

let S8 : Int

S9

source

let S9 : Int

SP

source

let SP : Int

T0

source

let T0 : Int

T1

source

let T1 : Int

T2

source

let T2 : Int

T3

source

let T3 : Int

T4

source

let T4 : Int

T5

source

let T5 : Int

T6

source

let T6 : Int

TP

source

let TP : Int

Tmp0

source

let Tmp0 : Int

WASM_MEMORY_PAGES

source

let WASM_MEMORY_PAGES : Int

WASM_STACK_ALIGN

source

let WASM_STACK_ALIGN : Int

WASM_STACK_BASE

source

let WASM_STACK_BASE : Int

WasmKmIsWide

source

let WasmKmIsWide : Int

WasmNCLR

source

let WasmNCLR : Int

WasmNFPR

source

let WasmNFPR : Int

WasmNFPS

source

let WasmNFPS : Int

WasmNGPR

source

let WasmNGPR : Int

WasmNGPS

source

let WasmNGPS : Int

WasmNRGLOB

source

let WasmNRGLOB : Int

WasmTmp0

source

let WasmTmp0 : Int

XMM0

source

let XMM0 : Int

XMM1

source

let XMM1 : Int

XMM10

source

let XMM10 : Int

XMM11

source

let XMM11 : Int

XMM12

source

let XMM12 : Int

XMM13

source

let XMM13 : Int

XMM14

source

let XMM14 : Int

XMM15

source

let XMM15 : Int

XMM2

source

let XMM2 : Int

XMM3

source

let XMM3 : Int

XMM4

source

let XMM4 : Int

XMM5

source

let XMM5 : Int

XMM6

source

let XMM6 : Int

XMM7

source

let XMM7 : Int

XMM8

source

let XMM8 : Int

XMM9

source

let XMM9 : Int

class_to_wasm_type

source

fn class_to_wasm_type(cls : Class) -> WasmType

cmpneg

source

fn cmpneg(c : Int) -> Int

dumpts

source

fn dumpts(bs : BSet, tmps : Array[Tmp]) -> String

fp_stash_at

source

fn fp_stash_at(i : Int) -> FpBits

fp_stash_len

source

fn fp_stash_len() -> Int

fp_stash_reset

source

fn fp_stash_reset() -> Unit

gasstash

source

fn gasstash(bits0 : Int64, bits1 : Int64, size : Int) -> Int

init_amd64_target

source

fn init_amd64_target() -> Unit

init_rv64_target

source

fn init_rv64_target() -> Unit

op_info

source

fn op_info(o : Op) -> OpInfo

phicls

source

fn phicls(t : Int, tmps : Array[Tmp]) -> Int

rclob

source

let rclob : Array[Int]

rglob_mask

source

fn rglob_mask() -> UInt64

rsave

source

let rsave : Array[Int]

rv64_rclob

source

let rv64_rclob : Array[Int]

rv64_reg_name

source

fn rv64_reg_name(reg : Int) -> String

rv64_rglob_mask

source

fn rv64_rglob_mask() -> UInt64

rv64_rsave

source

let rv64_rsave : Array[Int]

target_argregs

source

fn target_argregs(r : Ref) -> (UInt64, Int, Int)

target_cfg

source

let target_cfg : TargetCfg

target_retregs

source

fn target_retregs(r : Ref) -> (UInt64, Int, Int)

wasm_load_op

source

fn wasm_load_op(cls : Class) -> String

wasm_rclob

source

let wasm_rclob : Array[Int]

wasm_rglob_mask

source

fn wasm_rglob_mask() -> UInt64

wasm_rsave

source

let wasm_rsave : Array[Int]

wasm_store_op

source

fn wasm_store_op(cls : Class) -> String

wasm_type_name

source

fn wasm_type_name(cls : Class) -> String

Source Files

Site source Report issue Packages Build queue Skills Statistics

#BlkId

#Addr

#Addr::new

#AliasInfo

#AliasInfo::default

#AliasType

#AliasType::astack

#BSet

#BSet::clr

#BSet::copy_from

#BSet::count

#BSet::diff

#BSet::each

#BSet::each_from

#BSet::equal

#BSet::has

#BSet::inter

#BSet::iter

#BSet::new

#BSet::set

#BSet::union

#BSet::zero

#Blk

#Blk::new

#Class

#Class::base

#Class::code

#Class::from_code

#Class::wide

#Con

#Con::add

#Con::addr

#Con::double

#Con::int

#Con::is_zero

#Con::new

#Con::raw_bits

#Con::single

#ConBits

#ConType

#Dat

#Dat::align

#Dat::byte

#Dat::end

#Dat::name

#Dat::ref_to

#Dat::start

#Dat::string

#Dat::zero

#DatKind

#Field

#Field::end

#Field::new

#FieldType

#Fn

#Fn::add_blk

#Fn::add_con

#Fn::add_tmp

#Fn::blk

#Fn::con

#Fn::find_blk

#Fn::get_con

#Fn::get_con_by

#Fn::init_regs

#Fn::init_regs_wasm

#Fn::nblk

#Fn::ncon

#Fn::new

#Fn::new_tmp

#Fn::ntmp

#Fn::tmp

#FpBits

#Ins

#Ins::new

#Ins::new_void

#Jump

#Jump::full

#Jump::new

#JumpKind

#JumpKind::from_index

BlkId

Addr

Addr::new

AliasInfo

AliasInfo::default

AliasType

AliasType::astack

BSet

BSet::clr

BSet::copy_from

BSet::count

BSet::diff

BSet::each

BSet::each_from

BSet::equal

BSet::has

BSet::inter

BSet::iter

BSet::new

BSet::set

BSet::union

BSet::zero

Blk

Blk::new

Class

Class::base

Class::code

Class::from_code

Class::wide

Con

Con::add

Con::addr

Con::double

Con::int

Con::is_zero

Con::new

Con::raw_bits

Con::single

ConBits

ConType

Dat

Dat::align

Dat::byte

Dat::end

Dat::name

Dat::ref_to

Dat::start

Dat::string

Dat::zero

DatKind

Field

Field::end

Field::new

FieldType

Fn

Fn::add_blk

Fn::add_con

Fn::add_tmp

Fn::blk

Fn::con

Fn::find_blk

Fn::get_con

Fn::get_con_by

Fn::init_regs

Fn::init_regs_wasm

Fn::nblk

Fn::ncon

Fn::new

Fn::new_tmp

Fn::ntmp

Fn::tmp

FpBits

Ins

Ins::new

Ins::new_void

Jump

Jump::full

Jump::new

JumpKind

JumpKind::from_index