PTO-SCALAR-MODEL-SYS-REGISTERS

1// PTO-UNIT: {"id":"PTO-SCALAR-MODEL-SYS-REGISTERS","surface":"scalar","classification":["model","sys","registers"],"depends_on":["PTO-SCALAR-MODEL-SYS-SEMANTICS","PTO-ARCH-SYSTEM-REGISTERS-MAINTENANCE"]}2// PTO-REQ-SCALAR-SSR-001, PTO-REQ-PROFILE-001: canonical 24-bit3// system-register addressing with explicit Access Control Ring checks.4
5readonly impdef func SystemRegisterAccessPermitted(6    address: SystemRegisterAddress, write: boolean,7    ring: AccessControlRing) => boolean8begin9    // The active profile permits base registers at every ring and keeps10    // context-family registers root-ring-only.11    return UInt(address[11:0]) < 0x0f00 || ring == 0;12end;13
14pure func IsBaseSystemRegisterAddress(address: SystemRegisterAddress) => boolean15begin16    return address == Zeros{24} + 0x0000 ||17           address == Zeros{24} + 0x0001 ||18           address == Zeros{24} + 0x0010 ||19           address == Zeros{24} + 0x0020 ||20           address == Zeros{24} + 0x0021 ||21           address == Zeros{24} + 0x0022 ||22           address == Zeros{24} + 0x0023 ||23           address == Zeros{24} + 0x0024 ||24           address == Zeros{24} + 0x0025 ||25           address == Zeros{24} + 0x0026 ||26           address == Zeros{24} + 0x0027 ||27           address == Zeros{24} + 0x0050 ||28           address == Zeros{24} + 0x0051 ||29           address == Zeros{24} + 0x0c00;30end;31
32pure func BaseSystemRegisterOfAddress(address: SystemRegisterAddress) => SystemRegister33begin34    case UInt(address) of35        when 0x0000 => return SystemRegister_THREAD_PTR;36        when 0x0001 => return SystemRegister_GLOBAL_PTR;37        when 0x0010 => return SystemRegister_TIME;38        when 0x0020 => return SystemRegister_CORE_STATE;39        when 0x0021 => return SystemRegister_CORE_ID;40        when 0x0022 => return SystemRegister_VENDOR;41        when 0x0023 => return SystemRegister_VERSION;42        when 0x0024 => return SystemRegister_CORE_FEATURE;43        when 0x0025 => return SystemRegister_CORE_FEATURE_ENABLE;44        when 0x0026 => return SystemRegister_THREAD_ID;45        when 0x0027 => return SystemRegister_TILE_CAPACITY;46        when 0x0050 => return SystemRegister_BLOCKNUM;47        when 0x0051 => return SystemRegister_BLOCKID;48        when 0x0c00 => return SystemRegister_CYCLE;49        otherwise => unreachable;50    end;51end;52
53pure func SystemRegisterFileIndexOf(address: SystemRegisterAddress)54        => SystemRegisterFileIndex55begin56    assert address[23:16] == Zeros{8};57    return UInt(address[15:0]) as SystemRegisterFileIndex;58end;59
60func ReadSystemRegisterAddress(address: SystemRegisterAddress) => Word61begin62    if !SystemRegisterAccessPermitted(address, FALSE, CurrentACR()) then63        SetFault(Fault_IllegalInstruction, ReadPC());64        return Zeros{PTO_XLEN};65    end;66    let access = SystemRegisterAccessOf(address);67    if access == SystemRegisterAccess_Unknown ||68       access == SystemRegisterAccess_WriteOnly then69        SetFault(Fault_IllegalInstruction, ReadPC());70        return Zeros{PTO_XLEN};71    end;72    if IsBaseSystemRegisterAddress(address) then73        return ReadSystemRegister(BaseSystemRegisterOfAddress(address));74    end;75
76    let low_index = UInt(address[11:0]);77    let ring = UInt(address[15:12]) as AccessControlRing;78    if low_index == 0x0f02 then return PackTrapStatus(ring); end;79    if low_index == 0x0f03 then return _ACRTrapArgument0[[ring]]; end;80    if low_index == 0x0f08 then return ReadInterruptPending(ring); end;81    if low_index == 0x0f09 then return ReadTopPendingInterrupt(ring); end;82    if low_index == 0x0f20 then return ReadMonotonicTime(); end;83    return _ExtendedSystemRegisters[[SystemRegisterFileIndexOf(address)]];84end;85
86readonly func SystemRegisterWritePermitted(address: SystemRegisterAddress)87    => boolean88begin89    let access = SystemRegisterAccessOf(address);90    return SystemRegisterAccessPermitted(address, TRUE, CurrentACR()) &&91           access != SystemRegisterAccess_Unknown &&92           access != SystemRegisterAccess_ReadOnly;93end;94
95readonly func SystemRegisterSwapPermitted(address: SystemRegisterAddress)96    => boolean97begin98    return SystemRegisterAccessPermitted(address, FALSE, CurrentACR()) &&99           SystemRegisterAccessPermitted(address, TRUE, CurrentACR()) &&100           SystemRegisterAccessOf(address) == SystemRegisterAccess_ReadWrite;101end;102
103func WriteSystemRegisterAddress(address: SystemRegisterAddress, value: Word)104begin105    if !SystemRegisterWritePermitted(address) then106        SetFault(Fault_IllegalInstruction, ReadPC());107        return;108    end;109    if IsBaseSystemRegisterAddress(address) then110        WriteSystemRegister(BaseSystemRegisterOfAddress(address), value);111        return;112    end;113
114    let low_index = UInt(address[11:0]);115    let ring = UInt(address[15:12]) as AccessControlRing;116    if low_index == 0x0f02 then117        UnpackTrapStatus(ring, value);118    elsif low_index == 0x0f03 then119        _ACRTrapArgument0[[ring]] = value;120    else121        if low_index == 0x0f0a then122            EndOfInterrupt(ring, value);123        else124            _ExtendedSystemRegisters[[SystemRegisterFileIndexOf(address)]] = value;125            if low_index == 0x0f21 then RefreshTimerPending(ring); end;126        end;127    end;128end;129
130func SwapSystemRegisterAddress(address: SystemRegisterAddress, value: Word) => Word131begin132    // A swap is a read/write transaction.  Preflight both permissions and the133    // access class before reading so a rejected swap cannot trigger read-side134    // effects such as timer-pending refresh on a read-only register.135    if !SystemRegisterSwapPermitted(address) then136        SetFault(Fault_IllegalInstruction, ReadPC());137        return Zeros{PTO_XLEN};138    end;139    let old_value = ReadSystemRegisterAddress(address);140    if _LastFault == Fault_None then WriteSystemRegisterAddress(address, value); end;141    return old_value;142end;143
144func ExecuteSystemRegisterGet(destination: Reg5Selector,145                              address: SystemRegisterAddress)146begin147    let value = ReadSystemRegisterAddress(address);148    if _LastFault == Fault_None then WriteScalarDestination(destination, value); end;149end;150
151func ExecuteCompressedSystemRegisterGet(address: SystemRegisterAddress)152begin153    let value = ReadSystemRegisterAddress(address);154    if _LastFault == Fault_None then WriteCompressedTResult(value); end;155end;156
157func ExecuteSystemRegisterSet(source: Reg5Selector,158                              address: SystemRegisterAddress)159begin160    if !SystemRegisterWritePermitted(address) then161        SetFault(Fault_IllegalInstruction, ReadPC());162        return;163    end;164    let value = ReadScalarRegisterOperand(source);165    WriteSystemRegisterAddress(address, value);166end;167
168func ExecuteSystemRegisterSwap(destination: Reg5Selector, source: Reg5Selector,169                               address: SystemRegisterAddress)170begin171    if !SystemRegisterSwapPermitted(address) then172        SetFault(Fault_IllegalInstruction, ReadPC());173        return;174    end;175    let value = ReadScalarRegisterOperand(source);176    let old_value = SwapSystemRegisterAddress(address, value);177    if _LastFault == Fault_None then WriteScalarDestination(destination, old_value); end;178end;179