#!/usr/bin/env fuchsia-vendored-python
#
# Copyright 2021 The Fuchsia Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""
decode ARM Exception Syndrome Register (ESR) values
"""

# TODO(maniscalco): Add a flag that assumes RAS is implemented and
# then further decode the RAS-specific details.

import argparse
import sys


# Return the Stage S1PTW description for the given value.
def s1ptw_desc(value):
    return {
        0b0: "Fault not on a stage 2 translation for a stage 1 translation table walk",
        0b1: "Fault on the stage 2 translation of an access for a stage 1 translation table walk",
    }.get(value, "Unexpected S1PTW")


# Return the IFSC description for the given value.
def ifsc_desc(value):
    return {
        0b000000: "Address size fault, level 0 of translation or translation table base register",
        0b000001: "Address size fault, level 1",
        0b000010: "Address size fault, level 2",
        0b000011: "Address size fault, level 3",
        0b000100: "Translation fault, level 0",
        0b000101: "Translation fault, level 1",
        0b000110: "Translation fault, level 2",
        0b000111: "Translation fault, level 3",
        0b001001: "Access flag fault, level 1",
        0b001010: "Access flag fault, level 2",
        0b001011: "Access flag fault, level 3",
        0b001101: "Permission fault, level 1",
        0b001110: "Permission fault, level 2",
        0b001111: "Permission fault, level 3",
        0b010000: "Synchronous External abort, not on translation table walk",
        0b011000: "Synchronous parity or ECC error on memory access, not on translation table walk",
        0b010100: "Synchronous External abort, on translation table walk, level 0",
        0b010101: "Synchronous External abort, on translation table walk, level 1",
        0b010110: "Synchronous External abort, on translation table walk, level 2",
        0b010111: "Synchronous External abort, on translation table walk, level 3",
        0b011000: "Synchronous parity or ECC error on memory access, not on translation table walk",
        0b011100: "Synchronous parity or ECC error on memory access on translation table walk, level 0",
        0b011101: "Synchronous parity or ECC error on memory access on translation table walk, level 1",
        0b011110: "Synchronous parity or ECC error on memory access on translation table walk, level 2",
        0b011111: "Synchronous parity or ECC error on memory access on translation table walk, level 3",
        0b110000: "TLB conflict abort",
        0b110001: (
            "Unsupported atomic hardware update fault, if the implementation includes "
            "ARMv8.1-TTHM. Otherwise reserved."
        ),
    }.get(value, "Unexpected IFSC")


# Return the IFSC, S1PTW, EA, FnV, and SET for the given Instruction Abort ISS.
def unpack_instruction_abort_iss(iss):
    ifsc = iss & ((1 << 6) - 1)
    iss >>= 6  # eat IFSC

    iss >>= 1  # eat RES0

    s1ptw = iss & ((1 << 1) - 1)
    iss >>= 1  # eat S1PTW

    iss >>= 1  # eat RES0

    ea = iss & ((1 << 1) - 1)
    iss >>= 1  # eat EA

    fnv = iss & ((1 << 1) - 1)
    iss >>= 1  # eat FnV

    set_value = iss & ((1 << 2) - 1)
    iss >>= 2  # eat SET
    return ifsc, s1ptw, ea, fnv, set_value


# Decode an instruction abort.
def decode_instruction_abort(ec, ec_desc, iss):
    ifsc, s1ptw, ea, fnv, set_value = unpack_instruction_abort_iss(iss)
    decode_ec(ec_desc)
    print(
        "ISS --> IFSC=0b{:06b} S1PTW=0b{:01b} EA=0b{:01b} FnV=0b{:01b} SET=0b{:02b}".format(
            ifsc, s1ptw, ea, fnv, set_value
        )
    )
    print("IFSC:", ifsc_desc(ifsc))
    print("S1PTW:", s1ptw_desc(s1ptw))
    if fnv != 0:
        print("FnV: FAR is not valid, and holds an UNKNOWN value")


# Return the DFSC description for the given value.
def dfsc_desc(value):
    return {
        0b000000: "Address size fault, level 0 of translation or translation table base register",
        0b000001: "Address size fault, level 1",
        0b000010: "Address size fault, level 2",
        0b000011: "Address size fault, level 3",
        0b000100: "Translation fault, level 0",
        0b000101: "Translation fault, level 1",
        0b000110: "Translation fault, level 2",
        0b000111: "Translation fault, level 3",
        0b001001: "Access flag fault, level 1",
        0b001010: "Access flag fault, level 2",
        0b001011: "Access flag fault, level 3",
        0b001101: "Permission fault, level 1",
        0b001110: "Permission fault, level 2",
        0b001111: "Permission fault, level 3",
        0b010000: "Synchronous External abort, not on translation table walk",
        0b011000: "Synchronous parity or ECC error on memory access, not on translation table walk",
        0b010100: "Synchronous External abort, on translation table walk, level 0",
        0b010101: "Synchronous External abort, on translation table walk, level 1",
        0b010110: "Synchronous External abort, on translation table walk, level 2",
        0b010111: "Synchronous External abort, on translation table walk, level 3",
        0b011000: "Synchronous parity or ECC error on memory access, not on translation table walk",
        0b011100: "Synchronous parity or ECC error on memory access on translation table walk, level 0",
        0b011101: "Synchronous parity or ECC error on memory access on translation table walk, level 1",
        0b011110: "Synchronous parity or ECC error on memory access on translation table walk, level 2",
        0b011111: "Synchronous parity or ECC error on memory access on translation table walk, level 3",
        0b100001: "Alignment fault",
        0b110000: "TLB conflict abort",
        0b110001: (
            "Unsupported atomic hardware update fault, if the implementation "
            "includes ARMv8.1-TTHM. Otherwise reserved."
        ),
        0b110100: "IMPLEMENTATION DEFINED fault (Lockdown)",
        0b110101: "IMPLEMENTATION DEFINED fault (Unsupported Exclusive or Atomic access)",
        0b111101: "Section Domain Fault, used only for faults reported in the PAR_EL1",
        0b111110: "Page Domain Fault, used only for faults reported in the PAR_EL1",
    }.get(value, "Unexpected DFSC")


# Return the WnR description for the given value.
def wnr_desc(value):
    return {
        0b0: "Abort caused by an instruction reading from a memory location",
        0b1: "Abort caused by an instruction writing to a memory location",
    }.get(value, "Unexpected WnR")


# Return the CM description for the given value.
def cm_desc(value):
    return {
        0b0: "The Data Abort was not generated by the execution of a cache maintenance instruction",
        0b1: (
            "The Data Abort was generated by the execution of a cache maintenance "
            " instruction or by a synchronous fault on the execution of an address "
            "translation instruction (DC ZVA does not count as a cache maintenance "
            "instruction"
        ),
    }.get(value, "Unexpected CM")


# Return the SAS description for the given value.
def sas_desc(value):
    return {
        0b00: "Byte",
        0b01: "Halfword",
        0b10: "Word",
        0b11: "Doubleword",
    }.get(value, "Unexpected SAS")


# Return the DFSC, WnR, S1PTW, CM, EA, FnV, SET, VNCR, AR, SF, SRT, SSE,
# SAS, and ISV for the given Data Abort ISS.
def unpack_data_abort_iss(iss):
    dfsc = iss & ((1 << 6) - 1)
    iss >>= 6  # eat DFSC

    wnr = iss & ((1 << 1) - 1)
    iss >>= 1  # eat WNR

    s1ptw = iss & ((1 << 1) - 1)
    iss >>= 1  # eat S1PTW

    cm = iss & ((1 << 1) - 1)
    iss >>= 1  # eat CM

    ea = iss & ((1 << 1) - 1)
    iss >>= 1  # eat EA

    fnv = iss & ((1 << 1) - 1)
    iss >>= 1  # eat FnV

    set_value = iss & ((1 << 2) - 1)
    iss >>= 2  # eat SET

    vncr = iss & ((1 << 1) - 1)
    iss >>= 1  # eat VNCR

    ar = iss & ((1 << 1) - 1)
    iss >>= 1  # eat AR

    sf = iss & ((1 << 1) - 1)
    iss >>= 1  # eat SF

    srt = iss & ((5 << 1) - 1)
    iss >>= 5  # eat SRT

    sse = iss & ((1 << 1) - 1)
    iss >>= 1  # eat SSE

    sas = iss & ((1 << 2) - 1)
    iss >>= 2  # eat SAS

    isv = iss & ((1 << 1) - 1)
    iss >>= 1  # eat ISV

    return (
        dfsc,
        wnr,
        s1ptw,
        cm,
        ea,
        fnv,
        set_value,
        vncr,
        ar,
        sf,
        srt,
        sse,
        sas,
        isv,
    )


# Decode a data abort.
def decode_data_abort(ec, ec_desc, iss):
    (
        dfsc,
        wnr,
        s1ptw,
        cm,
        ea,
        fnv,
        set_value,
        vncr,
        ar,
        sf,
        srt,
        sse,
        sas,
        isv,
    ) = unpack_data_abort_iss(iss)
    decode_ec(ec_desc)
    print(
        "ISS --> DFSC=0b{:06b} WnR=0b{:01b} S1PTW=0b{:01b} CM=0b{:01b} EA=0b{:01b} FnV=0b{:01b} SET=0b{:02b} VNCR=0b{:01b} AR=0b{:01b} SF=0b{:01b} SRT=0b{:05b} SSE=0b{:01b} ISV=0b{:01b}".format(
            dfsc,
            wnr,
            s1ptw,
            cm,
            ea,
            fnv,
            set_value,
            vncr,
            ar,
            sf,
            srt,
            sse,
            isv,
        )
    )
    print("DFSC:", dfsc_desc(dfsc))
    if ea != 1 and dfsc != 0b110101 and dfsc != 0b110001:
        print("WnR:", wnr_desc(wnr))
    print("S1PTW:", s1ptw_desc(s1ptw))
    print("CM:", cm_desc(cm))
    if dfsc == 0b100000 and fnv == 1:
        print("FnV: FAR is not valid, and holds an UNKNOWN value")
    if isv == 1:
        print("SAS: Access size is", sas_desc(sas))


# Decode just the EC.
def decode_ec(ec_desc):
    print("EC:", ec_desc)


# Decode the EC and ISS.
def decode_ec_iss(ec, iss):
    if ec == 0b000000:
        decode_ec("Unknown reason")
    elif ec == 0b000001:
        decode_ec("Trapped WFI or WFE instruction execution")
    elif ec == 0b000011:
        decode_ec(
            "Trapped MCR or MRC access with (coproc==1111) that is not reported using EC 0b000000"
        )
    elif ec == 0b000100:
        decode_ec(
            "Trapped MCRR or MRRC access with (coproc==1111) that is not reported using EC 0b000000"
        )
    elif ec == 0b000101:
        decode_ec("Trapped MCR or MRC access with (coproc==1110)")
    elif ec == 0b000110:
        decode_ec("Trapped LDC or STC access")
    elif ec == 0b000111:
        decode_ec(
            "Trapped access to SVE, Advanced SIMD, or floating-point functionality"
        )
    elif ec == 0b001000:
        decode_ec(
            "Trapped VMRS access, from ID group trap, that is not reported using EC 0b000111"
        )
    elif ec == 0b001001:
        decode_ec(
            "Trapped Pointer Authentication instruction because HCR_EL2.API==0 or SCR_EL3.API==0"
        )
    elif ec == 0b001010:
        decode_ec(
            "Trapped execution of an LD64B, ST64B, ST64BV, or ST64BV0 instruction"
        )
    elif ec == 0b001100:
        decode_ec("Trapped MRRC access with (coproc==1110)")
    elif ec == 0b001110:
        decode_ec("Illegal Execution state")
    elif ec == 0b010001:
        decode_ec("SVC instruction execution in AArch32 state")
    elif ec == 0b010010:
        decode_ec(
            "HVC instruction execution in AArch32 state, when HVC is not disabled"
        )
    elif ec == 0b010011:
        decode_ec(
            "SMC instruction execution in AArch32 state, when SMC is not disabled"
        )
    elif ec == 0b010101:
        decode_ec("SVC instruction execution in AArch64 state")
    elif ec == 0b010110:
        decode_ec(
            "HVC instruction execution in AArch64 state, when HVC is not disabled"
        )
    elif ec == 0b010111:
        decode_ec(
            "SMC instruction execution in AArch64 state, when SMC is not disabled"
        )
    elif ec == 0b011000:
        decode_ec(
            "Trapped MSR, MRS or System instruction execution in AArch64 state"
        )
    elif ec == 0b011001:
        decode_ec("Trapped SVE functionality")
    elif ec == 0b011010:
        decode_ec("Trapped ERET, ERETAA, or ERETAB instruction execution")
    elif ec == 0b011100:
        decode_ec(
            "Exception from a Pointer Authentication instruction authentication failure"
        )
    elif ec == 0b011111:
        decode_ec("IMPLEMENTATION DEFINED exception to EL3")
    elif ec == 0b100000:
        ec_desc = "Instruction Abort from a lower Exception level, that might be using AArch32 or AArch64"
        decode_instruction_abort(ec, ec_desc, iss)
    elif ec == 0b100001:
        ec_desc = "Instruction Abort taken without a change in Exception level"
        decode_instruction_abort(ec, ec_desc, iss)
    elif ec == 0b100010:
        decode_ec("PC alignment fault exception")
    elif ec == 0b100100:
        ec_desc = "Data Abort from a lower Exception level, that might be using AArch32 or AArch64"
        decode_data_abort(ec, ec_desc, iss)
    elif ec == 0b100101:
        ec_desc = "Data Abort taken without a change in Exception level"
        decode_data_abort(ec, ec_desc, iss)
    elif ec == 0b100110:
        decode_ec("SP alignment fault exception")
    elif ec == 0b101000:
        decode_ec("Trapped floating-point exception taken from AArch32 state")
    elif ec == 0b101100:
        decode_ec("Trapped floating-point exception taken from AArch64 state")
    elif ec == 0b101111:
        decode_ec("SError interrupt")
    elif ec == 0b110000:
        decode_ec(
            "Breakpoint exception from a lower Exception level, that might be using AArch32 or AArch64"
        )
    elif ec == 0b110001:
        decode_ec(
            "Breakpoint exception taken without a change in Exception level"
        )
    elif ec == 0b110010:
        decode_ec(
            "Software Step exception from a lower Exception level, that might be using AArch32 or AArch64"
        )
    elif ec == 0b110011:
        decode_ec(
            "Software Step exception taken without a change in Exception level"
        )
    elif ec == 0b110100:
        decode_ec(
            "Watchpoint exception from a lower Exception level, that might be using AArch32 or AArch64"
        )
    elif ec == 0b110101:
        decode_ec(
            "Watchpoint exception taken without a change in Exception level"
        )
    elif ec == 0b111000:
        decode_ec("BKPT instruction execution in AArch32 state")
    elif ec == 0b111010:
        decode_ec("Vector Catch exception from AArch32 state")
    elif ec == 0b111100:
        decode_ec("BRK instruction execution in AArch64 state")
    else:
        decode_ec("Unexpected EC value")


def decode_esr(esr):
    # Extract ISS from bits [24:0].
    iss_mask = (1 << 25) - 1
    iss = esr & iss_mask
    # Extract IL from bit [25].
    il = (esr >> 25) & 1
    # Extract EC from bits [31:26].
    ec = esr >> 26
    print(
        "ESR=0x{:08x} --> EC=0b{:06b} IL=0b{:01b} ISS=0x{:07x}".format(
            esr, ec, il, iss
        )
    )
    decode_ec_iss(ec, iss)


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("esr", help="32-bit ESR value")
    args = parser.parse_args()

    esr = int(args.esr, 16)
    if esr > (2**32) - 1:
        print(
            "ERROR: ESR value too large to be a 32-bit value: 0x{0:02x}".format(
                esr
            )
        )
        sys.exit(1)

    decode_esr(esr)


if __name__ == "__main__":
    main()