Struct PageTableEntry Copy item path

{ Self((self.0 & !Self::PROP_MASK()) | flags as usize) }

self.0 == old(self).prop_assign_spec(flags).0,

{
    let flags: u8 = prop.flags.value();
    let priv_flags: u8 = prop.priv_flags.value();
    PageTableFlags::PRESENT() | flags.map_forward(&PAGE_FLAG_MAPPING)
        | flags.map_invert_forward(&PAGE_INVERTED_FLAG_MAPPING)
        | priv_flags.map_forward(&PAGE_PRIV_MAPPING) | Self::encode_cache(prop.cache)
}

res == Self::format_flags_spec(prop),

{
    let flags: u8 = entry.map_backward(&PAGE_FLAG_MAPPING)
        | entry.map_invert_backward(&PAGE_INVERTED_FLAG_MAPPING);
    let priv_flags: u8 = entry.map_backward(&PAGE_PRIV_MAPPING);
    let cache = Self::format_cache(entry);
    PageProperty {
        flags: PageFlags::from_bits(flags),
        cache,
        priv_flags: PrivilegedPageFlags::from_bits(priv_flags),
    }
}

res == Self::format_property_spec(entry),

{ Self { 0: 0 } }

res == Self::default_spec(),

{ Self::default_spec() }

{ self.0 as usize }

res == self.as_usize_spec(),

{ self.0 & PageTableFlags::PRESENT() != 0 }

res == self.is_present_spec(),

{
    let flags = Self::format_flags(prop);
    self.prop_assign_spec(flags)
}

*self == old(self).set_prop_spec(prop),

{
    let addr = paddr & PHYS_ADDR_MASK();
    let hp = Self::format_huge_page(level) as usize;
    let flags = Self::format_flags(prop) as usize;
    Self(addr | hp | flags)
}

{
    let addr = paddr & PHYS_ADDR_MASK();
    Self(
        addr | PageTableFlags::PRESENT() | PageTableFlags::WRITABLE()
            | PageTableFlags::USER(),
    )
}

{ self.0 & PHYS_ADDR_MASK() }

res == self.paddr_spec(),

{ Self::format_property(self.0) }

res == self.prop_spec(),

{ level == 1 || (self.0 & PageTableFlags::HUGE() != 0) }

res == self.is_last_spec(level),