azhzx/qbe/types - mooncakes.io

README
U
Arm64BinModule
U
BSet
U
Blk
U
Class
U
Con
U
Dat
U
Fn
U
Ins
U
InterpValue
U
Jump
U
Op
U
Ref
U
Tmp
U
Typ
T
Target
V
compile
V
compile_arm64
V
compile_arm64_bin
V
compile_arm64_bin_module
V
compile_arm64_debug
V
compile_arm64_object
V
compile_debug
V
compile_la64
V
compile_la64_debug
V
compile_rv64
V
compile_rv64_debug
V
compile_target
V
compile_target_debug
V
compile_wasm
V
compile_wasm_debug
V
interpret

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

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

fn Class::base(self : Class) -> Int

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

Class::code

source

fn Class::code(self : Class) -> Int

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

Class::from_code

source

fn Class::from_code(c : Int) -> Class

Construct a class from its code: 0->Kw, 1->Kl, 2->Ks, 3->Kd, else Kx.

Class::wide

source

fn Class::wide(self : Class) -> Int

Return 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

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

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
  leaf : Bool
  salign : Int
} 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

fn JumpKind::from_index(i : Int) -> JumpKind

JumpKind::index

source

fn JumpKind::index(self : JumpKind) -> Int

JumpKind::is_ret

source

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
  Blit0
  Blit1
  Swap
  Sign
  Salloc
  Xidiv
  Xdiv
  Xcmp
  Xtest
  Acmp
  Acmn
  Afcmp
  Reqz
  Rnez
  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
  Sel0
  Sel1
  Xselieq
  Xseline
  Xselisge
  Xselisgt
  Xselisle
  Xselislt
  Xseliuge
  Xseliugt
  Xseliule
  Xseliult
  Xselfeq
  Xselfge
  Xselfgt
  Xselfle
  Xselflt
  Xselfne
  Xselfo
  Xselfuo
  Argv
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Op::ext_width_idx

source

fn Op::ext_width_idx(self : Op) -> Int

Op::from_index

source

fn Op::from_index(i : Int) -> Op

Op::from_string

source

fn Op::from_string(s : String) -> Op

Op::index

source

fn Op::index(self : Op) -> Int

Op::is_arg

source

fn Op::is_arg(self : Op) -> Bool

Op::is_ext

source

fn Op::is_ext(self : Op) -> Bool

Op::is_load

source

fn Op::is_load(self : Op) -> Bool

Op::is_par

source

fn Op::is_par(self : Op) -> Bool

Op::is_store

source

fn Op::is_store(self : Op) -> Bool

Op::load_width_idx

source

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)
  RInt(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

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

Ref::arm64_argregs

source

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

Ref::arm64_retregs

source

fn Ref::arm64_retregs(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

fn Ref::eq(self : Ref, other : Ref) -> Bool

Compare two references for 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_rint

source

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

is_rint - check for an integer literal 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::is_typ

source

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

is_typ - check for a type reference

Ref::la64_argregs

source

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

Ref::la64_retregs

source

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

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

fn Ref::none() -> Ref

R - empty reference (corresponds to C macro R)

Ref::retregs

source

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

Ref::rint

source

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

INT(x) - integer literal reference (used by blit1's size)

Ref::rint_val

source

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

rint_val - extract integer literal value, -1 if not an RInt

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
  bid : 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

fn TmpWidth::code(self : TmpWidth) -> Int

TmpWidth::from_code

source

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

ARM64_FP

source

let ARM64_FP : Int

ARM64_IP0

source

let ARM64_IP0 : Int

ARM64_IP1

source

let ARM64_IP1 : Int

ARM64_LR

source

let ARM64_LR : Int

ARM64_R0

source

let ARM64_R0 : Int

ARM64_R1

source

let ARM64_R1 : Int

ARM64_R10

source

let ARM64_R10 : Int

ARM64_R11

source

let ARM64_R11 : Int

ARM64_R12

source

let ARM64_R12 : Int

ARM64_R13

source

let ARM64_R13 : Int

ARM64_R14

source

let ARM64_R14 : Int

ARM64_R15

source

let ARM64_R15 : Int

ARM64_R18

source

let ARM64_R18 : Int

ARM64_R19

source

let ARM64_R19 : Int

ARM64_R2

source

let ARM64_R2 : Int

ARM64_R20

source

let ARM64_R20 : Int

ARM64_R21

source

let ARM64_R21 : Int

ARM64_R22

source

let ARM64_R22 : Int

ARM64_R23

source

let ARM64_R23 : Int

ARM64_R24

source

let ARM64_R24 : Int

ARM64_R25

source

let ARM64_R25 : Int

ARM64_R26

source

let ARM64_R26 : Int

ARM64_R27

source

let ARM64_R27 : Int

ARM64_R28

source

let ARM64_R28 : Int

ARM64_R3

source

let ARM64_R3 : Int

ARM64_R4

source

let ARM64_R4 : Int

ARM64_R5

source

let ARM64_R5 : Int

ARM64_R6

source

let ARM64_R6 : Int

ARM64_R7

source

let ARM64_R7 : Int

ARM64_R8

source

let ARM64_R8 : Int

ARM64_R9

source

let ARM64_R9 : Int

ARM64_SP

source

let ARM64_SP : Int

ARM64_V0

source

let ARM64_V0 : Int

ARM64_V1

source

let ARM64_V1 : Int

ARM64_V10

source

let ARM64_V10 : Int

ARM64_V11

source

let ARM64_V11 : Int

ARM64_V12

source

let ARM64_V12 : Int

ARM64_V13

source

let ARM64_V13 : Int

ARM64_V14

source

let ARM64_V14 : Int

ARM64_V15

source

let ARM64_V15 : Int

ARM64_V16

source

let ARM64_V16 : Int

ARM64_V17

source

let ARM64_V17 : Int

ARM64_V18

source

let ARM64_V18 : Int

ARM64_V19

source

let ARM64_V19 : Int

ARM64_V2

source

let ARM64_V2 : Int

ARM64_V20

source

let ARM64_V20 : Int

ARM64_V21

source

let ARM64_V21 : Int

ARM64_V22

source

let ARM64_V22 : Int

ARM64_V23

source

let ARM64_V23 : Int

ARM64_V24

source

let ARM64_V24 : Int

ARM64_V25

source

let ARM64_V25 : Int

ARM64_V26

source

let ARM64_V26 : Int

ARM64_V27

source

let ARM64_V27 : Int

ARM64_V28

source

let ARM64_V28 : Int

ARM64_V29

source

let ARM64_V29 : Int

ARM64_V3

source

let ARM64_V3 : Int

ARM64_V30

source

let ARM64_V30 : Int

ARM64_V4

source

let ARM64_V4 : Int

ARM64_V5

source

let ARM64_V5 : Int

ARM64_V6

source

let ARM64_V6 : Int

ARM64_V7

source

let ARM64_V7 : Int

ARM64_V8

source

let ARM64_V8 : Int

ARM64_V9

source

let ARM64_V9 : Int

Arm64KmIsWide

source

let Arm64KmIsWide : Int

Arm64NCLR

source

let Arm64NCLR : Int

Arm64NFPR

source

let Arm64NFPR : Int

Arm64NFPS

source

let Arm64NFPS : Int

Arm64NGPR

source

let Arm64NGPR : Int

Arm64NGPS

source

let Arm64NGPS : Int

Arm64NRGLOB

source

let Arm64NRGLOB : Int

Arm64Tmp0

source

let Arm64Tmp0 : 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

LA_A0

source

let LA_A0 : Int

LA_A1

source

let LA_A1 : Int

LA_A2

source

let LA_A2 : Int

LA_A3

source

let LA_A3 : Int

LA_A4

source

let LA_A4 : Int

LA_A5

source

let LA_A5 : Int

LA_A6

source

let LA_A6 : Int

LA_A7

source

let LA_A7 : Int

LA_FA0

source

let LA_FA0 : Int

LA_FA1

source

let LA_FA1 : Int

LA_FA2

source

let LA_FA2 : Int

LA_FA3

source

let LA_FA3 : Int

LA_FA4

source

let LA_FA4 : Int

LA_FA5

source

let LA_FA5 : Int

LA_FA6

source

let LA_FA6 : Int

LA_FA7

source

let LA_FA7 : Int

LA_FP

source

let LA_FP : Int

LA_FS0

source

let LA_FS0 : Int

LA_FS1

source

let LA_FS1 : Int

LA_FS2

source

let LA_FS2 : Int

LA_FS3

source

let LA_FS3 : Int

LA_FS4

source

let LA_FS4 : Int

LA_FS5

source

let LA_FS5 : Int

LA_FS6

source

let LA_FS6 : Int

LA_FS7

source

let LA_FS7 : Int

LA_FT0

source

let LA_FT0 : Int

LA_FT1

source

let LA_FT1 : Int

LA_FT10

source

let LA_FT10 : Int

LA_FT11

source

let LA_FT11 : Int

LA_FT12

source

let LA_FT12 : Int

LA_FT13

source

let LA_FT13 : Int

LA_FT14

source

let LA_FT14 : Int

LA_FT15

source

let LA_FT15 : Int

LA_FT2

source

let LA_FT2 : Int

LA_FT3

source

let LA_FT3 : Int

LA_FT4

source

let LA_FT4 : Int

LA_FT5

source

let LA_FT5 : Int

LA_FT6

source

let LA_FT6 : Int

LA_FT7

source

let LA_FT7 : Int

LA_FT8

source

let LA_FT8 : Int

LA_FT9

source

let LA_FT9 : Int

LA_RA

source

let LA_RA : Int

LA_S0

source

let LA_S0 : Int

LA_S1

source

let LA_S1 : Int

LA_S2

source

let LA_S2 : Int

LA_S3

source

let LA_S3 : Int

LA_S4

source

let LA_S4 : Int

LA_S5

source

let LA_S5 : Int

LA_S6

source

let LA_S6 : Int

LA_S7

source

let LA_S7 : Int

LA_S8

source

let LA_S8 : Int

LA_SP

source

let LA_SP : Int

LA_T0

source

let LA_T0 : Int

LA_T1

source

let LA_T1 : Int

LA_T2

source

let LA_T2 : Int

LA_T3

source

let LA_T3 : Int

LA_T4

source

let LA_T4 : Int

LA_T5

source

let LA_T5 : Int

LA_T6

source

let LA_T6 : Int

LA_T7

source

let LA_T7 : Int

LA_T8

source

let LA_T8 : Int

LA_TP

source

let LA_TP : Int

LA_ZERO

source

let LA_ZERO : Int

La64KmIsWide

source

let La64KmIsWide : Int

La64NCLR

source

let La64NCLR : Int

La64NFPR

source

let La64NFPR : Int

La64NFPS

source

let La64NFPS : Int

La64NGPR

source

let La64NGPR : Int

La64NGPS

source

let La64NGPS : Int

La64NRGLOB

source

let La64NRGLOB : Int

La64Tmp0

source

let La64Tmp0 : 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_DATA_BASE

source

let WASM_DATA_BASE : 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

arm64_rclob

source

let arm64_rclob : Array[Int]

arm64_reg_name

source

fn arm64_reg_name(reg : Int) -> String

arm64_rglob_mask

source

fn arm64_rglob_mask() -> UInt64

arm64_rsave

source

let arm64_rsave : Array[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_arm64_target

source

fn init_arm64_target() -> Unit

init_la64_target

source

fn init_la64_target() -> Unit

init_rv64_target

source

fn init_rv64_target() -> Unit

la64_rclob

source

let la64_rclob : Array[Int]

la64_reg_name

source

fn la64_reg_name(reg : Int) -> String

la64_rglob_mask

source

fn la64_rglob_mask() -> UInt64

la64_rsave

source

let la64_rsave : Array[Int]

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

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