🥮 mooncakes.io

    Milky2018/vcode/allocation_types does not have a README file

    AllocationConstraint

    source
    pub(all) enum AllocationConstraint {
      AnyReg
      AnyLocation
      PreservedHome
      FixedReg(PhysicalReg)
    } derive(Eq, 
    Debug    )

    A normalized register-allocation constraint.

    Operand ties are represented separately by a shared nonnegative tie label, so this type contains only location constraints.

    AllocationConstraint::equal

    source

    AllocationConstraint::not_equal

    source

    AllocationConstraint::to_repr

    source

    AllocationContents

    source
    pub struct AllocationContents[V] {
      // private fields
    }

    The values definitely present in each physical location at a CFG point. The allocator and VCode verifiers use the same transfer and join rules.

    AllocationContents::add_alias

    source
    fn[V : Eq] AllocationContents::add_alias(self : AllocationContents[V], value : V, location : AllocationLocation) -> Unit

    Name an existing value at a block parameter's home after a parallel rename.

    AllocationContents::contains

    source
    fn[V : Eq] AllocationContents::contains(self : AllocationContents[V], value : V, location : AllocationLocation) -> Bool

    AllocationContents::copy

    source

    AllocationContents::copy_location_from

    source
    fn[V] AllocationContents::copy_location_from(self : AllocationContents[V], source : AllocationContents[V], from : AllocationLocation, to : AllocationLocation) -> Unit

    Copy every alias of a location from the incoming state of a move.

    AllocationContents::equals

    source
    fn[V : Eq] AllocationContents::equals(self : AllocationContents[V], other : AllocationContents[V]) -> Bool

    AllocationContents::meet_with

    source
    fn[V : Eq] AllocationContents::meet_with(self : AllocationContents[V], other : AllocationContents[V]) -> Unit

    AllocationContents::new

    source

    AllocationContents::remove_register

    source
    fn[V] AllocationContents::remove_register(self : AllocationContents[V], reg : PhysicalReg) -> Unit

    AllocationContents::remove_value

    source
    fn[V : Eq] AllocationContents::remove_value(self : AllocationContents[V], value : V) -> Unit

    AllocationContents::set

    source
    fn[V] AllocationContents::set(self : AllocationContents[V], value : V, location : AllocationLocation) -> Unit

    AllocationLocation

    source
    pub(all) struct AllocationLocation {
      encoded : Int64
    } derive(Eq)

    A packed allocation result location within one allocation session.

    Spill indices are session-local and must be translated at ownership boundaries before they are exposed as product-facing stack-slot handles.

    AllocationLocation::equal

    source

    AllocationLocation::is_register

    source
    fn AllocationLocation::is_register(self : AllocationLocation) -> Bool

    AllocationLocation::is_spill

    source
    fn AllocationLocation::is_spill(self : AllocationLocation) -> Bool

    AllocationLocation::not_equal

    source

    AllocationLocation::reg

    source

    AllocationLocation::register

    source

    AllocationLocation::register_unchecked

    source
    fn AllocationLocation::register_unchecked(self : AllocationLocation) -> PhysicalReg

    Decode a register location after is_register has been established.

    AllocationLocation::spill

    source
    fn AllocationLocation::spill(index : Int) -> AllocationLocation

    AllocationLocation::spill_index

    source
    fn AllocationLocation::spill_index(self : AllocationLocation) -> Int?

    AllocationLocation::spill_index_unchecked

    source
    fn AllocationLocation::spill_index_unchecked(self : AllocationLocation) -> Int

    Decode a spill location after is_spill has been established.

    AllocationLocation::to_repr

    source

    AllocationOperand

    source
    pub(all) struct AllocationOperand {
      vreg : VirtualReg
      role : OperandRole
      constraint : AllocationConstraint
      preference : PhysicalReg?
      tie_id : Int
      timing : OperandTiming
    } derive(Eq, 
    Debug    )

    The canonical allocation facts for one instruction operand.

    AllocationOperand::def

    source

    AllocationOperand::equal

    source

    AllocationOperand::not_equal

    source
    fn AllocationOperand::not_equal(x : AllocationOperand, y : AllocationOperand) -> Bool

    AllocationOperand::to_repr

    source

    AllocationOperand::use_reg

    source

    AllocationOperand::with_constraint

    source
    fn AllocationOperand::with_constraint(self : AllocationOperand, constraint : AllocationConstraint) -> AllocationOperand

    AllocationOperand::with_preference

    source
    fn AllocationOperand::with_preference(self : AllocationOperand, preference : PhysicalReg) -> AllocationOperand

    Prefer a physical register without making it a correctness constraint.

    AllocationOperand::with_tie

    source
    fn AllocationOperand::with_tie(self : AllocationOperand, tie_id : Int) -> AllocationOperand

    Tie operands in one instruction by a shared nonnegative label.

    AllocationOperand::with_timing

    source

    OperandRole

    source
    pub(all) enum OperandRole {
      Use
      Def
      UseDef
    } derive(Eq, 
    Debug    )

    Whether an allocation operand reads, writes, or both reads and writes its virtual register.

    SSA VCode producers use Use and Def. UseDef remains available to standalone register-allocation clients that model in-place updates.

    OperandRole::equal

    source
    fn OperandRole::equal(OperandRole, OperandRole) -> Bool

    OperandRole::not_equal

    source
    fn OperandRole::not_equal(x : OperandRole, y : OperandRole) -> Bool

    OperandRole::to_repr

    source

    OperandTiming

    source
    pub(all) enum OperandTiming {
      Early
      Late
    } derive(Eq, 
    Debug    )

    The point within an instruction where an allocation operand is read or written.

    OperandTiming::equal

    source

    OperandTiming::not_equal

    source
    fn OperandTiming::not_equal(x : OperandTiming, y : OperandTiming) -> Bool

    OperandTiming::to_repr

    source

    PhysicalReg

    source
    pub(all) struct PhysicalReg {
      id : Int
      class : RegClass
    } derive(Eq)

    A target physical register identified within one register class.

    PhysicalReg::equal

    source
    fn PhysicalReg::equal(PhysicalReg, PhysicalReg) -> Bool

    PhysicalReg::new

    source
    fn PhysicalReg::new(id : Int, class : RegClass) -> PhysicalReg

    PhysicalReg::not_equal

    source
    fn PhysicalReg::not_equal(x : PhysicalReg, y : PhysicalReg) -> Bool

    PhysicalReg::to_repr

    source

    RegClass

    source
    pub(all) enum RegClass {
      Int
      Float
      Vector
      FpVector
    } derive(Eq, Hash, 
    Debug    )

    Target-neutral register-class identity shared by VCode and register allocation.

    FpVector preserves targets whose scalar floating-point and vector values occupy one physical register bank. Float and Vector remain available to standalone allocator embeddings that model distinct banks.

    RegClass::equal

    source
    fn RegClass::equal(RegClass, RegClass) -> Bool

    RegClass::hash

    source
    fn RegClass::hash(self : RegClass) -> Int

    RegClass::hash_combine

    source
    fn RegClass::hash_combine(RegClass, Hasher) -> Unit

    RegClass::not_equal

    source
    fn RegClass::not_equal(x : RegClass, y : RegClass) -> Bool

    RegClass::text

    source
    fn RegClass::text(self : RegClass) -> String

    RegClass::to_repr

    source

    VirtualReg

    source
    pub(all) struct VirtualReg {
      id : Int
      class : RegClass
    } derive(Eq, 
    Debug    )

    A dense virtual-register identity within one allocation session.

    VirtualReg::equal

    source
    fn VirtualReg::equal(VirtualReg, VirtualReg) -> Bool

    VirtualReg::not_equal

    source
    fn VirtualReg::not_equal(x : VirtualReg, y : VirtualReg) -> Bool

    VirtualReg::to_repr

    source

    Source Files