| /* |
| * Copyright (c) 2011,2017-2020 ARM Limited |
| * All rights reserved |
| * |
| * The license below extends only to copyright in the software and shall |
| * not be construed as granting a license to any other intellectual |
| * property including but not limited to intellectual property relating |
| * to a hardware implementation of the functionality of the software |
| * licensed hereunder. You may use the software subject to the license |
| * terms below provided that you ensure that this notice is replicated |
| * unmodified and in its entirety in all distributions of the software, |
| * modified or unmodified, in source code or in binary form. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer; |
| * redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution; |
| * neither the name of the copyright holders nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include <algorithm> |
| #include <cctype> |
| #include <cstring> |
| #include <iomanip> |
| #include <string> |
| |
| #include "arch/arm/tracers/tarmac_parser.hh" |
| |
| #include "arch/arm/insts/static_inst.hh" |
| #include "arch/arm/mmu.hh" |
| #include "arch/arm/regs/int.hh" |
| #include "arch/arm/regs/vec.hh" |
| #include "cpu/static_inst.hh" |
| #include "cpu/thread_context.hh" |
| #include "mem/packet.hh" |
| #include "mem/port_proxy.hh" |
| #include "mem/se_translating_port_proxy.hh" |
| #include "mem/translating_port_proxy.hh" |
| #include "sim/core.hh" |
| #include "sim/cur_tick.hh" |
| #include "sim/faults.hh" |
| #include "sim/full_system.hh" |
| #include "sim/sim_exit.hh" |
| |
| namespace gem5 |
| { |
| |
| using namespace ArmISA; |
| |
| namespace Trace { |
| |
| // TARMAC Parser static variables |
| const int TarmacParserRecord::MaxLineLength; |
| int8_t TarmacParserRecord::maxVectorLength = 0; |
| |
| TarmacParserRecord::ParserInstEntry TarmacParserRecord::instRecord; |
| TarmacParserRecord::ParserRegEntry TarmacParserRecord::regRecord; |
| TarmacParserRecord::ParserMemEntry TarmacParserRecord::memRecord; |
| TarmacBaseRecord::TarmacRecordType TarmacParserRecord::currRecordType; |
| |
| std::list<TarmacParserRecord::ParserRegEntry> |
| TarmacParserRecord::destRegRecords; |
| char TarmacParserRecord::buf[TarmacParserRecord::MaxLineLength]; |
| TarmacParserRecord::MiscRegMap TarmacParserRecord::miscRegMap = { |
| |
| { "cpsr", MISCREG_CPSR }, |
| { "nzcv", MISCREG_NZCV }, |
| |
| // AArch32 CP14 registers |
| { "dbgdidr", MISCREG_DBGDIDR }, |
| { "dbgdscrint", MISCREG_DBGDSCRint }, |
| { "dbgdccint", MISCREG_DBGDCCINT }, |
| { "dbgdtrtxint", MISCREG_DBGDTRTXint }, |
| { "dbgdtrrxint", MISCREG_DBGDTRRXint }, |
| { "dbgwfar", MISCREG_DBGWFAR }, |
| { "dbgvcr", MISCREG_DBGVCR }, |
| { "dbgdtrrxext", MISCREG_DBGDTRRXext }, |
| { "dbgdscrext", MISCREG_DBGDSCRext }, |
| { "dbgdtrtxext", MISCREG_DBGDTRTXext }, |
| { "dbgoseccr", MISCREG_DBGOSECCR }, |
| { "dbgbvr0", MISCREG_DBGBVR0 }, |
| { "dbgbvr1", MISCREG_DBGBVR1 }, |
| { "dbgbvr2", MISCREG_DBGBVR2 }, |
| { "dbgbvr3", MISCREG_DBGBVR3 }, |
| { "dbgbvr4", MISCREG_DBGBVR4 }, |
| { "dbgbvr5", MISCREG_DBGBVR5 }, |
| { "dbgbvr6", MISCREG_DBGBVR6 }, |
| { "dbgbvr7", MISCREG_DBGBVR7 }, |
| { "dbgbvr8", MISCREG_DBGBVR8 }, |
| { "dbgbvr9", MISCREG_DBGBVR9 }, |
| { "dbgbvr10", MISCREG_DBGBVR10 }, |
| { "dbgbvr11", MISCREG_DBGBVR11 }, |
| { "dbgbvr12", MISCREG_DBGBVR12 }, |
| { "dbgbvr13", MISCREG_DBGBVR13 }, |
| { "dbgbvr14", MISCREG_DBGBVR14 }, |
| { "dbgbvr15", MISCREG_DBGBVR15 }, |
| { "dbgbcr0", MISCREG_DBGBCR0 }, |
| { "dbgbcr1", MISCREG_DBGBCR1 }, |
| { "dbgbcr2", MISCREG_DBGBCR2 }, |
| { "dbgbcr3", MISCREG_DBGBCR3 }, |
| { "dbgbcr4", MISCREG_DBGBCR4 }, |
| { "dbgbcr5", MISCREG_DBGBCR5 }, |
| { "dbgbcr6", MISCREG_DBGBCR6 }, |
| { "dbgbcr7", MISCREG_DBGBCR7 }, |
| { "dbgbcr8", MISCREG_DBGBCR8 }, |
| { "dbgbcr9", MISCREG_DBGBCR9 }, |
| { "dbgbcr10", MISCREG_DBGBCR10 }, |
| { "dbgbcr11", MISCREG_DBGBCR11 }, |
| { "dbgbcr12", MISCREG_DBGBCR12 }, |
| { "dbgbcr13", MISCREG_DBGBCR13 }, |
| { "dbgbcr14", MISCREG_DBGBCR14 }, |
| { "dbgbcr15", MISCREG_DBGBCR15 }, |
| { "dbgwvr0", MISCREG_DBGWVR0 }, |
| { "dbgwvr1", MISCREG_DBGWVR1 }, |
| { "dbgwvr2", MISCREG_DBGWVR2 }, |
| { "dbgwvr3", MISCREG_DBGWVR3 }, |
| { "dbgwvr4", MISCREG_DBGWVR4 }, |
| { "dbgwvr5", MISCREG_DBGWVR5 }, |
| { "dbgwvr6", MISCREG_DBGWVR6 }, |
| { "dbgwvr7", MISCREG_DBGWVR7 }, |
| { "dbgwvr8", MISCREG_DBGWVR8 }, |
| { "dbgwvr9", MISCREG_DBGWVR9 }, |
| { "dbgwvr10", MISCREG_DBGWVR10 }, |
| { "dbgwvr11", MISCREG_DBGWVR11 }, |
| { "dbgwvr12", MISCREG_DBGWVR12 }, |
| { "dbgwvr13", MISCREG_DBGWVR13 }, |
| { "dbgwvr14", MISCREG_DBGWVR14 }, |
| { "dbgwvr15", MISCREG_DBGWVR15 }, |
| { "dbgwcr0", MISCREG_DBGWCR0 }, |
| { "dbgwcr1", MISCREG_DBGWCR1 }, |
| { "dbgwcr2", MISCREG_DBGWCR2 }, |
| { "dbgwcr3", MISCREG_DBGWCR3 }, |
| { "dbgwcr4", MISCREG_DBGWCR4 }, |
| { "dbgwcr5", MISCREG_DBGWCR5 }, |
| { "dbgwcr6", MISCREG_DBGWCR6 }, |
| { "dbgwcr7", MISCREG_DBGWCR7 }, |
| { "dbgwcr8", MISCREG_DBGWCR8 }, |
| { "dbgwcr9", MISCREG_DBGWCR9 }, |
| { "dbgwcr10", MISCREG_DBGWCR10 }, |
| { "dbgwcr11", MISCREG_DBGWCR11 }, |
| { "dbgwcr12", MISCREG_DBGWCR12 }, |
| { "dbgwcr13", MISCREG_DBGWCR13 }, |
| { "dbgwcr14", MISCREG_DBGWCR14 }, |
| { "dbgwcr15", MISCREG_DBGWCR15 }, |
| { "dbgdrar", MISCREG_DBGDRAR }, |
| { "dbgbxvr0", MISCREG_DBGBXVR0 }, |
| { "dbgbxvr1", MISCREG_DBGBXVR1 }, |
| { "dbgbxvr2", MISCREG_DBGBXVR2 }, |
| { "dbgbxvr3", MISCREG_DBGBXVR3 }, |
| { "dbgbxvr4", MISCREG_DBGBXVR4 }, |
| { "dbgbxvr5", MISCREG_DBGBXVR5 }, |
| { "dbgbxvr6", MISCREG_DBGBXVR6 }, |
| { "dbgbxvr7", MISCREG_DBGBXVR7 }, |
| { "dbgbxvr8", MISCREG_DBGBXVR8 }, |
| { "dbgbxvr9", MISCREG_DBGBXVR9 }, |
| { "dbgbxvr10", MISCREG_DBGBXVR10 }, |
| { "dbgbxvr11", MISCREG_DBGBXVR11 }, |
| { "dbgbxvr12", MISCREG_DBGBXVR12 }, |
| { "dbgbxvr13", MISCREG_DBGBXVR13 }, |
| { "dbgbxvr14", MISCREG_DBGBXVR14 }, |
| { "dbgbxvr15", MISCREG_DBGBXVR15 }, |
| { "dbgoslar", MISCREG_DBGOSLAR }, |
| { "dbgoslsr", MISCREG_DBGOSLSR }, |
| { "dbgosdlr", MISCREG_DBGOSDLR }, |
| { "dbgprcr", MISCREG_DBGPRCR }, |
| { "dbgdsar", MISCREG_DBGDSAR }, |
| { "dbgclaimset", MISCREG_DBGCLAIMSET }, |
| { "dbgclaimclr", MISCREG_DBGCLAIMCLR }, |
| { "dbgauthstatus", MISCREG_DBGAUTHSTATUS }, |
| { "dbgdevid2", MISCREG_DBGDEVID2 }, |
| { "dbgdevid1", MISCREG_DBGDEVID1 }, |
| { "dbgdevid0", MISCREG_DBGDEVID0 }, |
| { "teecr", MISCREG_TEECR }, |
| { "jidr", MISCREG_JIDR }, |
| { "teehbr", MISCREG_TEEHBR }, |
| { "joscr", MISCREG_JOSCR }, |
| { "jmcr", MISCREG_JMCR }, |
| |
| // AArch32 CP15 registers |
| { "midr", MISCREG_MIDR }, |
| { "ctr", MISCREG_CTR }, |
| { "tcmtr", MISCREG_TCMTR }, |
| { "tlbtr", MISCREG_TLBTR }, |
| { "mpidr", MISCREG_MPIDR }, |
| { "revidr", MISCREG_REVIDR }, |
| { "id_pfr0", MISCREG_ID_PFR0 }, |
| { "id_pfr1", MISCREG_ID_PFR1 }, |
| { "id_dfr0", MISCREG_ID_DFR0 }, |
| { "id_afr0", MISCREG_ID_AFR0 }, |
| { "id_mmfr0", MISCREG_ID_MMFR0 }, |
| { "id_mmfr1", MISCREG_ID_MMFR1 }, |
| { "id_mmfr2", MISCREG_ID_MMFR2 }, |
| { "id_mmfr3", MISCREG_ID_MMFR3 }, |
| { "id_mmfr4", MISCREG_ID_MMFR4 }, |
| { "id_isar0", MISCREG_ID_ISAR0 }, |
| { "id_isar1", MISCREG_ID_ISAR1 }, |
| { "id_isar2", MISCREG_ID_ISAR2 }, |
| { "id_isar3", MISCREG_ID_ISAR3 }, |
| { "id_isar4", MISCREG_ID_ISAR4 }, |
| { "id_isar5", MISCREG_ID_ISAR5 }, |
| { "id_isar6", MISCREG_ID_ISAR6 }, |
| { "ccsidr", MISCREG_CCSIDR }, |
| { "clidr", MISCREG_CLIDR }, |
| { "aidr", MISCREG_AIDR }, |
| { "csselr_ns", MISCREG_CSSELR_NS }, |
| { "csselr_s", MISCREG_CSSELR_S }, |
| { "vpidr", MISCREG_VPIDR }, |
| { "vmpidr", MISCREG_VMPIDR }, |
| { "sctlr_ns", MISCREG_SCTLR_NS }, |
| { "sctlr_s", MISCREG_SCTLR_S }, |
| { "actlr_ns", MISCREG_ACTLR_NS }, |
| { "actlr_s", MISCREG_ACTLR_S }, |
| { "cpacr", MISCREG_CPACR }, |
| { "scr", MISCREG_SCR }, |
| { "sder", MISCREG_SDER }, |
| { "nsacr", MISCREG_NSACR }, |
| { "hsctlr", MISCREG_HSCTLR }, |
| { "hactlr", MISCREG_HACTLR }, |
| { "hcr", MISCREG_HCR }, |
| { "hcr2", MISCREG_HCR2 }, |
| { "hdcr", MISCREG_HDCR }, |
| { "hcptr", MISCREG_HCPTR }, |
| { "hstr", MISCREG_HSTR }, |
| { "hacr", MISCREG_HACR }, |
| { "ttbr0_ns", MISCREG_TTBR0_NS }, |
| { "ttbr0_s", MISCREG_TTBR0_S }, |
| { "ttbr1_ns", MISCREG_TTBR1_NS }, |
| { "ttbr1_s", MISCREG_TTBR1_S }, |
| { "ttbcr_ns", MISCREG_TTBCR_NS }, |
| { "ttbcr_s", MISCREG_TTBCR_S }, |
| { "htcr", MISCREG_HTCR }, |
| { "vtcr", MISCREG_VTCR }, |
| { "dacr_ns", MISCREG_DACR_NS }, |
| { "dacr_s", MISCREG_DACR_S }, |
| { "dfsr_ns", MISCREG_DFSR_NS }, |
| { "dfsr_s", MISCREG_DFSR_S }, |
| { "ifsr_ns", MISCREG_IFSR_NS }, |
| { "ifsr_s", MISCREG_IFSR_S }, |
| { "adfsr_ns", MISCREG_ADFSR_NS }, |
| { "adfsr_s", MISCREG_ADFSR_S }, |
| { "aifsr_ns", MISCREG_AIFSR_NS }, |
| { "aifsr_s", MISCREG_AIFSR_S }, |
| { "hadfsr", MISCREG_HADFSR }, |
| { "haifsr", MISCREG_HAIFSR }, |
| { "hsr", MISCREG_HSR }, |
| { "dfar_ns", MISCREG_DFAR_NS }, |
| { "dfar_s", MISCREG_DFAR_S }, |
| { "ifar_ns", MISCREG_IFAR_NS }, |
| { "ifar_s", MISCREG_IFAR_S }, |
| { "hdfar", MISCREG_HDFAR }, |
| { "hifar", MISCREG_HIFAR }, |
| { "hpfar", MISCREG_HPFAR }, |
| { "icialluis", MISCREG_ICIALLUIS }, |
| { "bpiallis", MISCREG_BPIALLIS }, |
| { "par_ns", MISCREG_PAR_NS }, |
| { "par_s", MISCREG_PAR_S }, |
| { "iciallu", MISCREG_ICIALLU }, |
| { "icimvau", MISCREG_ICIMVAU }, |
| { "cp15isb", MISCREG_CP15ISB }, |
| { "bpiall", MISCREG_BPIALL }, |
| { "bpimva", MISCREG_BPIMVA }, |
| { "dcimvac", MISCREG_DCIMVAC }, |
| { "dcisw", MISCREG_DCISW }, |
| { "ats1cpr", MISCREG_ATS1CPR }, |
| { "ats1cpw", MISCREG_ATS1CPW }, |
| { "ats1cur", MISCREG_ATS1CUR }, |
| { "ats1cuw", MISCREG_ATS1CUW }, |
| { "ats12nsopr", MISCREG_ATS12NSOPR }, |
| { "ats12nsopw", MISCREG_ATS12NSOPW }, |
| { "ats12nsour", MISCREG_ATS12NSOUR }, |
| { "ats12nsouw", MISCREG_ATS12NSOUW }, |
| { "dccmvac", MISCREG_DCCMVAC }, |
| { "dccsw", MISCREG_DCCSW }, |
| { "cp15dsb", MISCREG_CP15DSB }, |
| { "cp15dmb", MISCREG_CP15DMB }, |
| { "dccmvau", MISCREG_DCCMVAU }, |
| { "dccimvac", MISCREG_DCCIMVAC }, |
| { "dccisw", MISCREG_DCCISW }, |
| { "ats1hr", MISCREG_ATS1HR }, |
| { "ats1hw", MISCREG_ATS1HW }, |
| { "tlbiallis", MISCREG_TLBIALLIS }, |
| { "tlbimvais", MISCREG_TLBIMVAIS }, |
| { "tlbiasidis", MISCREG_TLBIASIDIS }, |
| { "tlbimvaais", MISCREG_TLBIMVAAIS }, |
| { "tlbimvalis", MISCREG_TLBIMVALIS }, |
| { "tlbimvaalis", MISCREG_TLBIMVAALIS }, |
| { "itlbiall", MISCREG_ITLBIALL }, |
| { "itlbimva", MISCREG_ITLBIMVA }, |
| { "itlbiasid", MISCREG_ITLBIASID }, |
| { "dtlbiall", MISCREG_DTLBIALL }, |
| { "dtlbimva", MISCREG_DTLBIMVA }, |
| { "dtlbiasid", MISCREG_DTLBIASID }, |
| { "tlbiall", MISCREG_TLBIALL }, |
| { "tlbimva", MISCREG_TLBIMVA }, |
| { "tlbiasid", MISCREG_TLBIASID }, |
| { "tlbimvaa", MISCREG_TLBIMVAA }, |
| { "tlbimval", MISCREG_TLBIMVAL }, |
| { "tlbimvaal", MISCREG_TLBIMVAAL }, |
| { "tlbiipas2is", MISCREG_TLBIIPAS2IS }, |
| { "tlbiipas2lis", MISCREG_TLBIIPAS2LIS }, |
| { "tlbiallhis", MISCREG_TLBIALLHIS }, |
| { "tlbimvahis", MISCREG_TLBIMVAHIS }, |
| { "tlbiallnsnhis", MISCREG_TLBIALLNSNHIS }, |
| { "tlbimvalhis", MISCREG_TLBIMVALHIS }, |
| { "tlbiipas2", MISCREG_TLBIIPAS2 }, |
| { "tlbiipas2l", MISCREG_TLBIIPAS2L }, |
| { "tlbiallh", MISCREG_TLBIALLH }, |
| { "tlbimvah", MISCREG_TLBIMVAH }, |
| { "tlbiallnsnh", MISCREG_TLBIALLNSNH }, |
| { "tlbimvalh", MISCREG_TLBIMVALH }, |
| { "pmcr", MISCREG_PMCR }, |
| { "pmcntenset", MISCREG_PMCNTENSET }, |
| { "pmcntenclr", MISCREG_PMCNTENCLR }, |
| { "pmovsr", MISCREG_PMOVSR }, |
| { "pmswinc", MISCREG_PMSWINC }, |
| { "pmselr", MISCREG_PMSELR }, |
| { "pmceid0", MISCREG_PMCEID0 }, |
| { "pmceid1", MISCREG_PMCEID1 }, |
| { "pmccntr", MISCREG_PMCCNTR }, |
| { "pmxevtyper", MISCREG_PMXEVTYPER }, |
| { "pmccfiltr", MISCREG_PMCCFILTR }, |
| { "pmxevcntr", MISCREG_PMXEVCNTR }, |
| { "pmuserenr", MISCREG_PMUSERENR }, |
| { "pmintenset", MISCREG_PMINTENSET }, |
| { "pmintenclr", MISCREG_PMINTENCLR }, |
| { "pmovsset", MISCREG_PMOVSSET }, |
| { "l2ctlr", MISCREG_L2CTLR }, |
| { "l2ectlr", MISCREG_L2ECTLR }, |
| { "prrr_ns", MISCREG_PRRR_NS }, |
| { "prrr_s", MISCREG_PRRR_S }, |
| { "mair0_ns", MISCREG_MAIR0_NS }, |
| { "mair0_s", MISCREG_MAIR0_S }, |
| { "nmrr_ns", MISCREG_NMRR_NS }, |
| { "nmrr_s", MISCREG_NMRR_S }, |
| { "mair1_ns", MISCREG_MAIR1_NS }, |
| { "mair1_s", MISCREG_MAIR1_S }, |
| { "amair0_ns", MISCREG_AMAIR0_NS }, |
| { "amair0_s", MISCREG_AMAIR0_S }, |
| { "amair1_ns", MISCREG_AMAIR1_NS }, |
| { "amair1_s", MISCREG_AMAIR1_S }, |
| { "hmair0", MISCREG_HMAIR0 }, |
| { "hmair1", MISCREG_HMAIR1 }, |
| { "hamair0", MISCREG_HAMAIR0 }, |
| { "hamair1", MISCREG_HAMAIR1 }, |
| { "vbar_ns", MISCREG_VBAR_NS }, |
| { "vbar_s", MISCREG_VBAR_S }, |
| { "mvbar", MISCREG_MVBAR }, |
| { "rmr", MISCREG_RMR }, |
| { "isr", MISCREG_ISR }, |
| { "hvbar", MISCREG_HVBAR }, |
| { "fcseidr", MISCREG_FCSEIDR }, |
| { "contextidr_ns", MISCREG_CONTEXTIDR_NS }, |
| { "contextidr_s", MISCREG_CONTEXTIDR_S }, |
| { "tpidrurw_ns", MISCREG_TPIDRURW_NS }, |
| { "tpidrurw_s", MISCREG_TPIDRURW_S }, |
| { "tpidruro_ns", MISCREG_TPIDRURO_NS }, |
| { "tpidruro_s", MISCREG_TPIDRURO_S }, |
| { "tpidrprw_ns", MISCREG_TPIDRPRW_NS }, |
| { "tpidrprw_s", MISCREG_TPIDRPRW_S }, |
| { "htpidr", MISCREG_HTPIDR }, |
| { "cntfrq", MISCREG_CNTFRQ }, |
| { "cntkctl", MISCREG_CNTKCTL }, |
| { "cntp_tval_ns", MISCREG_CNTP_TVAL_NS }, |
| { "cntp_tval_s", MISCREG_CNTP_TVAL_S }, |
| { "cntp_ctl_ns", MISCREG_CNTP_CTL_NS }, |
| { "cntp_ctl_s", MISCREG_CNTP_CTL_S }, |
| { "cntv_tval", MISCREG_CNTV_TVAL }, |
| { "cntv_ctl", MISCREG_CNTV_CTL }, |
| { "cnthctl", MISCREG_CNTHCTL }, |
| { "cnthp_tval", MISCREG_CNTHP_TVAL }, |
| { "cnthp_ctl", MISCREG_CNTHP_CTL }, |
| { "il1data0", MISCREG_IL1DATA0 }, |
| { "il1data1", MISCREG_IL1DATA1 }, |
| { "il1data2", MISCREG_IL1DATA2 }, |
| { "il1data3", MISCREG_IL1DATA3 }, |
| { "dl1data0", MISCREG_DL1DATA0 }, |
| { "dl1data1", MISCREG_DL1DATA1 }, |
| { "dl1data2", MISCREG_DL1DATA2 }, |
| { "dl1data3", MISCREG_DL1DATA3 }, |
| { "dl1data4", MISCREG_DL1DATA4 }, |
| { "ramindex", MISCREG_RAMINDEX }, |
| { "l2actlr", MISCREG_L2ACTLR }, |
| { "cbar", MISCREG_CBAR }, |
| { "httbr", MISCREG_HTTBR }, |
| { "vttbr", MISCREG_VTTBR }, |
| { "cntpct", MISCREG_CNTPCT }, |
| { "cntvct", MISCREG_CNTVCT }, |
| { "cntp_cval_ns", MISCREG_CNTP_CVAL_NS }, |
| { "cntp_cval_s", MISCREG_CNTP_CVAL_S }, |
| { "cntv_cval", MISCREG_CNTV_CVAL }, |
| { "cntvoff", MISCREG_CNTVOFF }, |
| { "cnthp_cval", MISCREG_CNTHP_CVAL }, |
| { "cpumerrsr", MISCREG_CPUMERRSR }, |
| { "l2merrsr", MISCREG_L2MERRSR }, |
| |
| // AArch64 registers (Op0=2) |
| { "mdccint_el1", MISCREG_MDCCINT_EL1 }, |
| { "osdtrrx_el1", MISCREG_OSDTRRX_EL1 }, |
| { "mdscr_el1", MISCREG_MDSCR_EL1 }, |
| { "osdtrtx_el1", MISCREG_OSDTRTX_EL1 }, |
| { "oseccr_el1", MISCREG_OSECCR_EL1 }, |
| { "dbgbvr0_el1", MISCREG_DBGBVR0_EL1 }, |
| { "dbgbvr1_el1", MISCREG_DBGBVR1_EL1 }, |
| { "dbgbvr2_el1", MISCREG_DBGBVR2_EL1 }, |
| { "dbgbvr3_el1", MISCREG_DBGBVR3_EL1 }, |
| { "dbgbvr4_el1", MISCREG_DBGBVR4_EL1 }, |
| { "dbgbvr5_el1", MISCREG_DBGBVR5_EL1 }, |
| { "dbgbvr6_el1", MISCREG_DBGBVR6_EL1 }, |
| { "dbgbvr7_el1", MISCREG_DBGBVR7_EL1 }, |
| { "dbgbvr8_el1", MISCREG_DBGBVR8_EL1 }, |
| { "dbgbvr9_el1", MISCREG_DBGBVR9_EL1 }, |
| { "dbgbvr10_el1", MISCREG_DBGBVR10_EL1 }, |
| { "dbgbvr11_el1", MISCREG_DBGBVR11_EL1 }, |
| { "dbgbvr12_el1", MISCREG_DBGBVR12_EL1 }, |
| { "dbgbvr13_el1", MISCREG_DBGBVR13_EL1 }, |
| { "dbgbvr14_el1", MISCREG_DBGBVR14_EL1 }, |
| { "dbgbvr15_el1", MISCREG_DBGBVR15_EL1 }, |
| { "dbgbcr0_el1", MISCREG_DBGBCR0_EL1 }, |
| { "dbgbcr1_el1", MISCREG_DBGBCR1_EL1 }, |
| { "dbgbcr2_el1", MISCREG_DBGBCR2_EL1 }, |
| { "dbgbcr3_el1", MISCREG_DBGBCR3_EL1 }, |
| { "dbgbcr4_el1", MISCREG_DBGBCR4_EL1 }, |
| { "dbgbcr5_el1", MISCREG_DBGBCR5_EL1 }, |
| { "dbgbcr6_el1", MISCREG_DBGBCR6_EL1 }, |
| { "dbgbcr7_el1", MISCREG_DBGBCR7_EL1 }, |
| { "dbgbcr8_el1", MISCREG_DBGBCR8_EL1 }, |
| { "dbgbcr9_el1", MISCREG_DBGBCR9_EL1 }, |
| { "dbgbcr10_el1", MISCREG_DBGBCR10_EL1 }, |
| { "dbgbcr11_el1", MISCREG_DBGBCR11_EL1 }, |
| { "dbgbcr12_el1", MISCREG_DBGBCR12_EL1 }, |
| { "dbgbcr13_el1", MISCREG_DBGBCR13_EL1 }, |
| { "dbgbcr14_el1", MISCREG_DBGBCR14_EL1 }, |
| { "dbgbcr15_el1", MISCREG_DBGBCR15_EL1 }, |
| { "dbgwvr0_el1", MISCREG_DBGWVR0_EL1 }, |
| { "dbgwvr1_el1", MISCREG_DBGWVR1_EL1 }, |
| { "dbgwvr2_el1", MISCREG_DBGWVR2_EL1 }, |
| { "dbgwvr3_el1", MISCREG_DBGWVR3_EL1 }, |
| { "dbgwvr4_el1", MISCREG_DBGWVR4_EL1 }, |
| { "dbgwvr5_el1", MISCREG_DBGWVR5_EL1 }, |
| { "dbgwvr6_el1", MISCREG_DBGWVR6_EL1 }, |
| { "dbgwvr7_el1", MISCREG_DBGWVR7_EL1 }, |
| { "dbgwvr8_el1", MISCREG_DBGWVR8_EL1 }, |
| { "dbgwvr9_el1", MISCREG_DBGWVR9_EL1 }, |
| { "dbgwvr10_el1", MISCREG_DBGWVR10_EL1 }, |
| { "dbgwvr11_el1", MISCREG_DBGWVR11_EL1 }, |
| { "dbgwvr12_el1", MISCREG_DBGWVR12_EL1 }, |
| { "dbgwvr13_el1", MISCREG_DBGWVR13_EL1 }, |
| { "dbgwvr14_el1", MISCREG_DBGWVR14_EL1 }, |
| { "dbgwvr15_el1", MISCREG_DBGWVR15_EL1 }, |
| { "dbgwcr0_el1", MISCREG_DBGWCR0_EL1 }, |
| { "dbgwcr1_el1", MISCREG_DBGWCR1_EL1 }, |
| { "dbgwcr2_el1", MISCREG_DBGWCR2_EL1 }, |
| { "dbgwcr3_el1", MISCREG_DBGWCR3_EL1 }, |
| { "dbgwcr4_el1", MISCREG_DBGWCR4_EL1 }, |
| { "dbgwcr5_el1", MISCREG_DBGWCR5_EL1 }, |
| { "dbgwcr6_el1", MISCREG_DBGWCR6_EL1 }, |
| { "dbgwcr7_el1", MISCREG_DBGWCR7_EL1 }, |
| { "dbgwcr8_el1", MISCREG_DBGWCR8_EL1 }, |
| { "dbgwcr9_el1", MISCREG_DBGWCR9_EL1 }, |
| { "dbgwcr10_el1", MISCREG_DBGWCR10_EL1 }, |
| { "dbgwcr11_el1", MISCREG_DBGWCR11_EL1 }, |
| { "dbgwcr12_el1", MISCREG_DBGWCR12_EL1 }, |
| { "dbgwcr13_el1", MISCREG_DBGWCR13_EL1 }, |
| { "dbgwcr14_el1", MISCREG_DBGWCR14_EL1 }, |
| { "dbgwcr15_el1", MISCREG_DBGWCR15_EL1 }, |
| { "mdccsr_el0", MISCREG_MDCCSR_EL0 }, |
| { "mddtr_el0", MISCREG_MDDTR_EL0 }, |
| { "mddtrtx_el0", MISCREG_MDDTRTX_EL0 }, |
| { "mddtrrx_el0", MISCREG_MDDTRRX_EL0 }, |
| { "dbgvcr32_el2", MISCREG_DBGVCR32_EL2 }, |
| { "mdrar_el1", MISCREG_MDRAR_EL1 }, |
| { "oslar_el1", MISCREG_OSLAR_EL1 }, |
| { "oslsr_el1", MISCREG_OSLSR_EL1 }, |
| { "osdlr_el1", MISCREG_OSDLR_EL1 }, |
| { "dbgprcr_el1", MISCREG_DBGPRCR_EL1 }, |
| { "dbgclaimset_el1", MISCREG_DBGCLAIMSET_EL1 }, |
| { "dbgclaimclr_el1", MISCREG_DBGCLAIMCLR_EL1 }, |
| { "dbgauthstatus_el1", MISCREG_DBGAUTHSTATUS_EL1 }, |
| { "teecr32_el1", MISCREG_TEECR32_EL1 }, |
| { "teehbr32_el1", MISCREG_TEEHBR32_EL1 }, |
| |
| // AArch64 registers (Op0=1,3) |
| { "midr_el1", MISCREG_MIDR_EL1 }, |
| { "mpidr_el1", MISCREG_MPIDR_EL1 }, |
| { "revidr_el1", MISCREG_REVIDR_EL1 }, |
| { "id_pfr0_el1", MISCREG_ID_PFR0_EL1 }, |
| { "id_pfr1_el1", MISCREG_ID_PFR1_EL1 }, |
| { "id_dfr0_el1", MISCREG_ID_DFR0_EL1 }, |
| { "id_afr0_el1", MISCREG_ID_AFR0_EL1 }, |
| { "id_mmfr0_el1", MISCREG_ID_MMFR0_EL1 }, |
| { "id_mmfr1_el1", MISCREG_ID_MMFR1_EL1 }, |
| { "id_mmfr2_el1", MISCREG_ID_MMFR2_EL1 }, |
| { "id_mmfr3_el1", MISCREG_ID_MMFR3_EL1 }, |
| { "id_mmfr4_el1", MISCREG_ID_MMFR4_EL1 }, |
| { "id_isar0_el1", MISCREG_ID_ISAR0_EL1 }, |
| { "id_isar1_el1", MISCREG_ID_ISAR1_EL1 }, |
| { "id_isar2_el1", MISCREG_ID_ISAR2_EL1 }, |
| { "id_isar3_el1", MISCREG_ID_ISAR3_EL1 }, |
| { "id_isar4_el1", MISCREG_ID_ISAR4_EL1 }, |
| { "id_isar5_el1", MISCREG_ID_ISAR5_EL1 }, |
| { "id_isar6_el1", MISCREG_ID_ISAR6_EL1 }, |
| { "mvfr0_el1", MISCREG_MVFR0_EL1 }, |
| { "mvfr1_el1", MISCREG_MVFR1_EL1 }, |
| { "mvfr2_el1", MISCREG_MVFR2_EL1 }, |
| { "id_aa64pfr0_el1", MISCREG_ID_AA64PFR0_EL1 }, |
| { "id_aa64pfr1_el1", MISCREG_ID_AA64PFR1_EL1 }, |
| { "id_aa64dfr0_el1", MISCREG_ID_AA64DFR0_EL1 }, |
| { "id_aa64dfr1_el1", MISCREG_ID_AA64DFR1_EL1 }, |
| { "id_aa64afr0_el1", MISCREG_ID_AA64AFR0_EL1 }, |
| { "id_aa64afr1_el1", MISCREG_ID_AA64AFR1_EL1 }, |
| { "id_aa64isar0_el1", MISCREG_ID_AA64ISAR0_EL1 }, |
| { "id_aa64isar1_el1", MISCREG_ID_AA64ISAR1_EL1 }, |
| { "id_aa64mmfr0_el1", MISCREG_ID_AA64MMFR0_EL1 }, |
| { "id_aa64mmfr1_el1", MISCREG_ID_AA64MMFR1_EL1 }, |
| { "id_aa64mmfr2_el1", MISCREG_ID_AA64MMFR2_EL1 }, |
| { "ccsidr_el1", MISCREG_CCSIDR_EL1 }, |
| { "clidr_el1", MISCREG_CLIDR_EL1 }, |
| { "aidr_el1", MISCREG_AIDR_EL1 }, |
| { "csselr_el1", MISCREG_CSSELR_EL1 }, |
| { "ctr_el0", MISCREG_CTR_EL0 }, |
| { "dczid_el0", MISCREG_DCZID_EL0 }, |
| { "vpidr_el2", MISCREG_VPIDR_EL2 }, |
| { "vmpidr_el2", MISCREG_VMPIDR_EL2 }, |
| { "sctlr_el1", MISCREG_SCTLR_EL1 }, |
| { "actlr_el1", MISCREG_ACTLR_EL1 }, |
| { "cpacr_el1", MISCREG_CPACR_EL1 }, |
| { "sctlr_el2", MISCREG_SCTLR_EL2 }, |
| { "actlr_el2", MISCREG_ACTLR_EL2 }, |
| { "hcr_el2", MISCREG_HCR_EL2 }, |
| { "mdcr_el2", MISCREG_MDCR_EL2 }, |
| { "cptr_el2", MISCREG_CPTR_EL2 }, |
| { "hstr_el2", MISCREG_HSTR_EL2 }, |
| { "hacr_el2", MISCREG_HACR_EL2 }, |
| { "sctlr_el3", MISCREG_SCTLR_EL3 }, |
| { "actlr_el3", MISCREG_ACTLR_EL3 }, |
| { "scr_el3", MISCREG_SCR_EL3 }, |
| { "sder32_el3", MISCREG_SDER32_EL3 }, |
| { "cptr_el3", MISCREG_CPTR_EL3 }, |
| { "mdcr_el3", MISCREG_MDCR_EL3 }, |
| { "ttbr0_el1", MISCREG_TTBR0_EL1 }, |
| { "ttbr1_el1", MISCREG_TTBR1_EL1 }, |
| { "tcr_el1", MISCREG_TCR_EL1 }, |
| { "ttbr0_el2", MISCREG_TTBR0_EL2 }, |
| { "tcr_el2", MISCREG_TCR_EL2 }, |
| { "vttbr_el2", MISCREG_VTTBR_EL2 }, |
| { "vtcr_el2", MISCREG_VTCR_EL2 }, |
| { "ttbr0_el3", MISCREG_TTBR0_EL3 }, |
| { "tcr_el3", MISCREG_TCR_EL3 }, |
| { "dacr32_el2", MISCREG_DACR32_EL2 }, |
| { "spsr_el1", MISCREG_SPSR_EL1 }, |
| { "elr_el1", MISCREG_ELR_EL1 }, |
| { "sp_el0", MISCREG_SP_EL0 }, |
| { "spsel", MISCREG_SPSEL }, |
| { "currentel", MISCREG_CURRENTEL }, |
| { "nzcv", MISCREG_NZCV }, |
| { "daif", MISCREG_DAIF }, |
| { "fpcr", MISCREG_FPCR }, |
| { "fpsr", MISCREG_FPSR }, |
| { "dspsr_el0", MISCREG_DSPSR_EL0 }, |
| { "dlr_el0", MISCREG_DLR_EL0 }, |
| { "spsr_el2", MISCREG_SPSR_EL2 }, |
| { "elr_el2", MISCREG_ELR_EL2 }, |
| { "sp_el1", MISCREG_SP_EL1 }, |
| { "spsr_irq", MISCREG_SPSR_IRQ_AA64 }, |
| { "spsr_abt", MISCREG_SPSR_ABT_AA64 }, |
| { "spsr_und", MISCREG_SPSR_UND_AA64 }, |
| { "spsr_fiq", MISCREG_SPSR_FIQ_AA64 }, |
| { "spsr_el3", MISCREG_SPSR_EL3 }, |
| { "elr_el3", MISCREG_ELR_EL3 }, |
| { "sp_el2", MISCREG_SP_EL2 }, |
| { "afsr0_el1", MISCREG_AFSR0_EL1 }, |
| { "afsr1_el1", MISCREG_AFSR1_EL1 }, |
| { "esr_el1", MISCREG_ESR_EL1 }, |
| { "ifsr32_el2", MISCREG_IFSR32_EL2 }, |
| { "afsr0_el2", MISCREG_AFSR0_EL2 }, |
| { "afsr1_el2", MISCREG_AFSR1_EL2 }, |
| { "esr_el2", MISCREG_ESR_EL2 }, |
| { "fpexc32_el2", MISCREG_FPEXC32_EL2 }, |
| { "afsr0_el3", MISCREG_AFSR0_EL3 }, |
| { "afsr1_el3", MISCREG_AFSR1_EL3 }, |
| { "esr_el3", MISCREG_ESR_EL3 }, |
| { "far_el1", MISCREG_FAR_EL1 }, |
| { "far_el2", MISCREG_FAR_EL2 }, |
| { "hpfar_el2", MISCREG_HPFAR_EL2 }, |
| { "far_el3", MISCREG_FAR_EL3 }, |
| { "ic_ialluis", MISCREG_IC_IALLUIS }, |
| { "par_el1", MISCREG_PAR_EL1 }, |
| { "ic_iallu", MISCREG_IC_IALLU }, |
| { "dc_ivac_xt", MISCREG_DC_IVAC_Xt }, |
| { "dc_isw_xt", MISCREG_DC_ISW_Xt }, |
| { "at_s1e1r_xt", MISCREG_AT_S1E1R_Xt }, |
| { "at_s1e1w_xt", MISCREG_AT_S1E1W_Xt }, |
| { "at_s1e0r_xt", MISCREG_AT_S1E0R_Xt }, |
| { "at_s1e0w_xt", MISCREG_AT_S1E0W_Xt }, |
| { "dc_csw_xt", MISCREG_DC_CSW_Xt }, |
| { "dc_cisw_xt", MISCREG_DC_CISW_Xt }, |
| { "dc_zva_xt", MISCREG_DC_ZVA_Xt }, |
| { "ic_ivau_xt", MISCREG_IC_IVAU_Xt }, |
| { "dc_cvac_xt", MISCREG_DC_CVAC_Xt }, |
| { "dc_cvau_xt", MISCREG_DC_CVAU_Xt }, |
| { "dc_civac_xt", MISCREG_DC_CIVAC_Xt }, |
| { "at_s1e2r_xt", MISCREG_AT_S1E2R_Xt }, |
| { "at_s1e2w_xt", MISCREG_AT_S1E2W_Xt }, |
| { "at_s12e1r_xt", MISCREG_AT_S12E1R_Xt }, |
| { "at_s12e1w_xt", MISCREG_AT_S12E1W_Xt }, |
| { "at_s12e0r_xt", MISCREG_AT_S12E0R_Xt }, |
| { "at_s12e0w_xt", MISCREG_AT_S12E0W_Xt }, |
| { "at_s1e3r_xt", MISCREG_AT_S1E3R_Xt }, |
| { "at_s1e3w_xt", MISCREG_AT_S1E3W_Xt }, |
| { "tlbi_vmalle1is", MISCREG_TLBI_VMALLE1IS }, |
| { "tlbi_vae1is_xt", MISCREG_TLBI_VAE1IS_Xt }, |
| { "tlbi_aside1is_xt", MISCREG_TLBI_ASIDE1IS_Xt }, |
| { "tlbi_vaae1is_xt", MISCREG_TLBI_VAAE1IS_Xt }, |
| { "tlbi_vale1is_xt", MISCREG_TLBI_VALE1IS_Xt }, |
| { "tlbi_vaale1is_xt", MISCREG_TLBI_VAALE1IS_Xt }, |
| { "tlbi_vmalle1", MISCREG_TLBI_VMALLE1 }, |
| { "tlbi_vae1_xt", MISCREG_TLBI_VAE1_Xt }, |
| { "tlbi_aside1_xt", MISCREG_TLBI_ASIDE1_Xt }, |
| { "tlbi_vaae1_xt", MISCREG_TLBI_VAAE1_Xt }, |
| { "tlbi_vale1_xt", MISCREG_TLBI_VALE1_Xt }, |
| { "tlbi_vaale1_xt", MISCREG_TLBI_VAALE1_Xt }, |
| { "tlbi_ipas2e1is_xt", MISCREG_TLBI_IPAS2E1IS_Xt }, |
| { "tlbi_ipas2le1is_xt", MISCREG_TLBI_IPAS2LE1IS_Xt }, |
| { "tlbi_alle2is", MISCREG_TLBI_ALLE2IS }, |
| { "tlbi_vae2is_xt", MISCREG_TLBI_VAE2IS_Xt }, |
| { "tlbi_alle1is", MISCREG_TLBI_ALLE1IS }, |
| { "tlbi_vale2is_xt", MISCREG_TLBI_VALE2IS_Xt }, |
| { "tlbi_vmalls12e1is", MISCREG_TLBI_VMALLS12E1IS }, |
| { "tlbi_ipas2e1_xt", MISCREG_TLBI_IPAS2E1_Xt }, |
| { "tlbi_ipas2le1_xt", MISCREG_TLBI_IPAS2LE1_Xt }, |
| { "tlbi_alle2", MISCREG_TLBI_ALLE2 }, |
| { "tlbi_vae2_xt", MISCREG_TLBI_VAE2_Xt }, |
| { "tlbi_alle1", MISCREG_TLBI_ALLE1 }, |
| { "tlbi_vale2_xt", MISCREG_TLBI_VALE2_Xt }, |
| { "tlbi_vmalls12e1", MISCREG_TLBI_VMALLS12E1 }, |
| { "tlbi_alle3is", MISCREG_TLBI_ALLE3IS }, |
| { "tlbi_vae3is_xt", MISCREG_TLBI_VAE3IS_Xt }, |
| { "tlbi_vale3is_xt", MISCREG_TLBI_VALE3IS_Xt }, |
| { "tlbi_alle3", MISCREG_TLBI_ALLE3 }, |
| { "tlbi_vae3_xt", MISCREG_TLBI_VAE3_Xt }, |
| { "tlbi_vale3_xt", MISCREG_TLBI_VALE3_Xt }, |
| { "pmintenset_el1", MISCREG_PMINTENSET_EL1 }, |
| { "pmintenclr_el1", MISCREG_PMINTENCLR_EL1 }, |
| { "pmcr_el0", MISCREG_PMCR_EL0 }, |
| { "pmcntenset_el0", MISCREG_PMCNTENSET_EL0 }, |
| { "pmcntenclr_el0", MISCREG_PMCNTENCLR_EL0 }, |
| { "pmovsclr_el0", MISCREG_PMOVSCLR_EL0 }, |
| { "pmswinc_el0", MISCREG_PMSWINC_EL0 }, |
| { "pmselr_el0", MISCREG_PMSELR_EL0 }, |
| { "pmceid0_el0", MISCREG_PMCEID0_EL0 }, |
| { "pmceid1_el0", MISCREG_PMCEID1_EL0 }, |
| { "pmccntr_el0", MISCREG_PMCCNTR_EL0 }, |
| { "pmxevtyper_el0", MISCREG_PMXEVTYPER_EL0 }, |
| { "pmccfiltr_el0", MISCREG_PMCCFILTR_EL0 }, |
| { "pmxevcntr_el0", MISCREG_PMXEVCNTR_EL0 }, |
| { "pmuserenr_el0", MISCREG_PMUSERENR_EL0 }, |
| { "pmovsset_el0", MISCREG_PMOVSSET_EL0 }, |
| { "mair_el1", MISCREG_MAIR_EL1 }, |
| { "amair_el1", MISCREG_AMAIR_EL1 }, |
| { "mair_el2", MISCREG_MAIR_EL2 }, |
| { "amair_el2", MISCREG_AMAIR_EL2 }, |
| { "mair_el3", MISCREG_MAIR_EL3 }, |
| { "amair_el3", MISCREG_AMAIR_EL3 }, |
| { "l2ctlr_el1", MISCREG_L2CTLR_EL1 }, |
| { "l2ectlr_el1", MISCREG_L2ECTLR_EL1 }, |
| { "vbar_el1", MISCREG_VBAR_EL1 }, |
| { "rvbar_el1", MISCREG_RVBAR_EL1 }, |
| { "isr_el1", MISCREG_ISR_EL1 }, |
| { "vbar_el2", MISCREG_VBAR_EL2 }, |
| { "rvbar_el2", MISCREG_RVBAR_EL2 }, |
| { "vbar_el3", MISCREG_VBAR_EL3 }, |
| { "rvbar_el3", MISCREG_RVBAR_EL3 }, |
| { "rmr_el3", MISCREG_RMR_EL3 }, |
| { "contextidr_el1", MISCREG_CONTEXTIDR_EL1 }, |
| { "contextidr_el2", MISCREG_CONTEXTIDR_EL2 }, |
| { "tpidr_el1", MISCREG_TPIDR_EL1 }, |
| { "tpidr_el0", MISCREG_TPIDR_EL0 }, |
| { "tpidrro_el0", MISCREG_TPIDRRO_EL0 }, |
| { "tpidr_el2", MISCREG_TPIDR_EL2 }, |
| { "tpidr_el3", MISCREG_TPIDR_EL3 }, |
| { "cntkctl_el1", MISCREG_CNTKCTL_EL1 }, |
| { "cntfrq_el0", MISCREG_CNTFRQ_EL0 }, |
| { "cntpct_el0", MISCREG_CNTPCT_EL0 }, |
| { "cntvct_el0", MISCREG_CNTVCT_EL0 }, |
| { "cntp_tval_el0", MISCREG_CNTP_TVAL_EL0 }, |
| { "cntp_ctl_el0", MISCREG_CNTP_CTL_EL0 }, |
| { "cntp_cval_el0", MISCREG_CNTP_CVAL_EL0 }, |
| { "cntv_tval_el0", MISCREG_CNTV_TVAL_EL0 }, |
| { "cntv_ctl_el0", MISCREG_CNTV_CTL_EL0 }, |
| { "cntv_cval_el0", MISCREG_CNTV_CVAL_EL0 }, |
| { "pmevcntr0_el0", MISCREG_PMEVCNTR0_EL0 }, |
| { "pmevcntr1_el0", MISCREG_PMEVCNTR1_EL0 }, |
| { "pmevcntr2_el0", MISCREG_PMEVCNTR2_EL0 }, |
| { "pmevcntr3_el0", MISCREG_PMEVCNTR3_EL0 }, |
| { "pmevcntr4_el0", MISCREG_PMEVCNTR4_EL0 }, |
| { "pmevcntr5_el0", MISCREG_PMEVCNTR5_EL0 }, |
| { "pmevtyper0_el0", MISCREG_PMEVTYPER0_EL0 }, |
| { "pmevtyper1_el0", MISCREG_PMEVTYPER1_EL0 }, |
| { "pmevtyper2_el0", MISCREG_PMEVTYPER2_EL0 }, |
| { "pmevtyper3_el0", MISCREG_PMEVTYPER3_EL0 }, |
| { "pmevtyper4_el0", MISCREG_PMEVTYPER4_EL0 }, |
| { "pmevtyper5_el0", MISCREG_PMEVTYPER5_EL0 }, |
| { "cntvoff_el2", MISCREG_CNTVOFF_EL2 }, |
| { "cnthctl_el2", MISCREG_CNTHCTL_EL2 }, |
| { "cnthp_tval_el2", MISCREG_CNTHP_TVAL_EL2 }, |
| { "cnthp_ctl_el2", MISCREG_CNTHP_CTL_EL2 }, |
| { "cnthp_cval_el2", MISCREG_CNTHP_CVAL_EL2 }, |
| { "cntps_tval_el1", MISCREG_CNTPS_TVAL_EL1 }, |
| { "cntps_ctl_el1", MISCREG_CNTPS_CTL_EL1 }, |
| { "cntps_cval_el1", MISCREG_CNTPS_CVAL_EL1 }, |
| { "il1data0_el1", MISCREG_IL1DATA0_EL1 }, |
| { "il1data1_el1", MISCREG_IL1DATA1_EL1 }, |
| { "il1data2_el1", MISCREG_IL1DATA2_EL1 }, |
| { "il1data3_el1", MISCREG_IL1DATA3_EL1 }, |
| { "dl1data0_el1", MISCREG_DL1DATA0_EL1 }, |
| { "dl1data1_el1", MISCREG_DL1DATA1_EL1 }, |
| { "dl1data2_el1", MISCREG_DL1DATA2_EL1 }, |
| { "dl1data3_el1", MISCREG_DL1DATA3_EL1 }, |
| { "dl1data4_el1", MISCREG_DL1DATA4_EL1 }, |
| { "l2actlr_el1", MISCREG_L2ACTLR_EL1 }, |
| { "cpuactlr_el1", MISCREG_CPUACTLR_EL1 }, |
| { "cpuectlr_el1", MISCREG_CPUECTLR_EL1 }, |
| { "cpumerrsr_el1", MISCREG_CPUMERRSR_EL1 }, |
| { "l2merrsr_el1", MISCREG_L2MERRSR_EL1 }, |
| { "cbar_el1", MISCREG_CBAR_EL1 }, |
| }; |
| |
| void |
| TarmacParserRecord::TarmacParserRecordEvent::process() |
| { |
| std::ostream &outs = Trace::output(); |
| |
| std::list<ParserRegEntry>::iterator it = destRegRecords.begin(), |
| end = destRegRecords.end(); |
| |
| std::vector<uint64_t> values; |
| |
| for (; it != end; ++it) { |
| values.clear(); |
| switch (it->type) { |
| case REG_R: |
| case REG_X: |
| values.push_back(thread->getReg(intRegClass[it->index])); |
| break; |
| case REG_S: |
| if (instRecord.isetstate == ISET_A64) { |
| ArmISA::VecRegContainer vc; |
| thread->getReg(vecRegClass[it->index], &vc); |
| auto vv = vc.as<uint32_t>(); |
| values.push_back(vv[0]); |
| } else { |
| const VecElem elem = thread->getReg(vecElemClass[it->index]); |
| values.push_back(elem); |
| } |
| break; |
| case REG_D: |
| if (instRecord.isetstate == ISET_A64) { |
| ArmISA::VecRegContainer vc; |
| thread->getReg(vecRegClass[it->index], &vc); |
| auto vv = vc.as<uint64_t>(); |
| values.push_back(vv[0]); |
| } else { |
| const VecElem w0 = thread->getReg(vecElemClass[it->index]); |
| const VecElem w1 = thread->getReg(vecElemClass[it->index + 1]); |
| |
| values.push_back((uint64_t)(w1) << 32 | w0); |
| } |
| break; |
| case REG_P: |
| { |
| ArmISA::VecPredRegContainer pc; |
| thread->getReg(vecPredRegClass[it->index], &pc); |
| auto pv = pc.as<uint8_t>(); |
| uint64_t p = 0; |
| for (int i = maxVectorLength * 8; i > 0; ) { |
| p = (p << 1) | pv[--i]; |
| } |
| values.push_back(p); |
| } |
| break; |
| case REG_Q: |
| if (instRecord.isetstate == ISET_A64) { |
| ArmISA::VecRegContainer vc; |
| thread->getReg(vecRegClass[it->index], &vc); |
| auto vv = vc.as<uint64_t>(); |
| values.push_back(vv[0]); |
| values.push_back(vv[1]); |
| } else { |
| const VecElem w0 = thread->getReg(vecElemClass[it->index]); |
| const VecElem w1 = thread->getReg(vecElemClass[it->index + 1]); |
| const VecElem w2 = thread->getReg(vecElemClass[it->index + 2]); |
| const VecElem w3 = thread->getReg(vecElemClass[it->index + 3]); |
| |
| values.push_back((uint64_t)(w1) << 32 | w0); |
| values.push_back((uint64_t)(w3) << 32 | w2); |
| } |
| break; |
| case REG_Z: |
| { |
| int8_t i = maxVectorLength; |
| ArmISA::VecRegContainer vc; |
| thread->getReg(vecRegClass[it->index], &vc); |
| auto vv = vc.as<uint64_t>(); |
| while (i > 0) { |
| values.push_back(vv[--i]); |
| } |
| } |
| break; |
| case REG_MISC: |
| if (it->index == MISCREG_CPSR) { |
| // Read condition codes from aliased integer regs |
| CPSR cpsr = thread->readMiscRegNoEffect(it->index); |
| cpsr.nz = thread->getReg(cc_reg::Nz); |
| cpsr.c = thread->getReg(cc_reg::C); |
| cpsr.v = thread->getReg(cc_reg::V); |
| cpsr.ge = thread->getReg(cc_reg::Ge); |
| values.push_back(cpsr); |
| } else if (it->index == MISCREG_NZCV) { |
| CPSR cpsr = 0; |
| cpsr.nz = thread->getReg(cc_reg::Nz); |
| cpsr.c = thread->getReg(cc_reg::C); |
| cpsr.v = thread->getReg(cc_reg::V); |
| values.push_back(cpsr); |
| } else if (it->index == MISCREG_FPCR) { |
| // Read FPSCR and extract FPCR value |
| FPSCR fpscr = thread->readMiscRegNoEffect(MISCREG_FPSCR); |
| const uint32_t ones = (uint32_t)(-1); |
| FPSCR fpcrMask = 0; |
| fpcrMask.ioe = ones; |
| fpcrMask.dze = ones; |
| fpcrMask.ofe = ones; |
| fpcrMask.ufe = ones; |
| fpcrMask.ixe = ones; |
| fpcrMask.ide = ones; |
| fpcrMask.len = ones; |
| fpcrMask.stride = ones; |
| fpcrMask.rMode = ones; |
| fpcrMask.fz = ones; |
| fpcrMask.dn = ones; |
| fpcrMask.ahp = ones; |
| values.push_back(fpscr & fpcrMask); |
| } else if (it->index == MISCREG_FPSR) { |
| // Read FPSCR and extract FPSR value |
| FPSCR fpscr = thread->readMiscRegNoEffect(MISCREG_FPSCR); |
| const uint32_t ones = (uint32_t)(-1); |
| FPSCR fpsrMask = 0; |
| fpsrMask.ioc = ones; |
| fpsrMask.dzc = ones; |
| fpsrMask.ofc = ones; |
| fpsrMask.ufc = ones; |
| fpsrMask.ixc = ones; |
| fpsrMask.idc = ones; |
| fpsrMask.qc = ones; |
| fpsrMask.v = ones; |
| fpsrMask.c = ones; |
| fpsrMask.z = ones; |
| fpsrMask.n = ones; |
| values.push_back(fpscr & fpsrMask); |
| } else { |
| values.push_back(thread->readMiscRegNoEffect(it->index)); |
| } |
| break; |
| default: |
| panic("Unknown TARMAC trace record type!"); |
| } |
| |
| bool same = true; |
| if (values.size() != it->values.size()) same = false; |
| |
| uint32_t size = values.size(); |
| if (size > it->values.size()) |
| size = it->values.size(); |
| |
| if (same) { |
| for (int i = 0; i < size; ++i) { |
| if (values[i] != it->values[i]) { |
| same = false; |
| break; |
| } |
| } |
| } |
| |
| if (!same) { |
| if (!mismatch) { |
| TarmacParserRecord::printMismatchHeader(inst, *pc); |
| mismatch = true; |
| } |
| outs << "diff> [" << it->repr << "] gem5: 0x" << std::hex; |
| for (auto v : values) |
| outs << std::setw(16) << std::setfill('0') << v; |
| |
| outs << ", TARMAC: 0x" << std::hex; |
| for (auto v : it->values) |
| outs << std::setw(16) << std::setfill('0') << v; |
| outs << std::endl; |
| } |
| } |
| destRegRecords.clear(); |
| |
| if (mismatchOnPcOrOpcode && (parent.exitOnDiff || |
| parent.exitOnInsnDiff)) |
| exitSimLoop("a mismatch with the TARMAC trace has been detected " |
| "on PC or opcode", 1); |
| if (mismatch && parent.exitOnDiff) |
| exitSimLoop("a mismatch with the TARMAC trace has been detected " |
| "on data value", 1); |
| } |
| |
| const char * |
| TarmacParserRecord::TarmacParserRecordEvent::description() const |
| { |
| return "TARMAC parser record event"; |
| } |
| |
| |
| void |
| TarmacParserRecord::printMismatchHeader(const StaticInstPtr staticInst, |
| const PCStateBase &pc) |
| { |
| std::ostream &outs = Trace::output(); |
| outs << "\nMismatch between gem5 and TARMAC trace @ " << std::dec |
| << curTick() << " ticks\n" |
| << "[seq_num: " << std::dec << instRecord.seq_num |
| << ", opcode: 0x" << std::hex << (staticInst->getEMI() & 0xffffffff) |
| << ", PC: 0x" << pc.instAddr() |
| << ", disasm: " << staticInst->disassemble(pc.instAddr()) << "]" |
| << std::endl; |
| } |
| |
| TarmacParserRecord::TarmacParserRecord(Tick _when, ThreadContext *_thread, |
| const StaticInstPtr _staticInst, |
| const PCStateBase &_pc, |
| TarmacParser& _parent, |
| const StaticInstPtr _macroStaticInst) |
| : TarmacBaseRecord(_when, _thread, _staticInst, |
| _pc, _macroStaticInst), |
| parsingStarted(false), mismatch(false), |
| mismatchOnPcOrOpcode(false), parent(_parent) |
| { |
| memReq = std::make_shared<Request>(); |
| if (maxVectorLength == 0) { |
| maxVectorLength = ArmStaticInst::getCurSveVecLen<uint64_t>(_thread); |
| } |
| } |
| |
| void |
| TarmacParserRecord::dump() |
| { |
| std::ostream &outs = Trace::output(); |
| |
| uint64_t written_data = 0; |
| unsigned mem_flags = 3 | ArmISA::MMU::AllowUnaligned; |
| |
| ISetState isetstate; |
| |
| if (!staticInst->isMicroop() || staticInst->isLastMicroop()) { |
| |
| if (parent.macroopInProgress && !staticInst->isLastMicroop()) { |
| // A microop faulted and it was not the last microop -> advance |
| // TARMAC trace to next instruction |
| advanceTrace(); |
| } |
| |
| parent.macroopInProgress = false; |
| |
| auto arm_inst = static_cast<const ArmStaticInst*>( |
| staticInst.get() |
| ); |
| |
| while (advanceTrace()) { |
| switch (currRecordType) { |
| |
| case TARMAC_INST: |
| parsingStarted = true; |
| if (pc->instAddr() != instRecord.addr) { |
| if (!mismatch) |
| printMismatchHeader(staticInst, *pc); |
| outs << "diff> [PC] gem5: 0x" << std::hex << pc->instAddr() |
| << ", TARMAC: 0x" << instRecord.addr << std::endl; |
| mismatch = true; |
| mismatchOnPcOrOpcode = true; |
| } |
| |
| if (arm_inst->encoding() != instRecord.opcode) { |
| if (!mismatch) |
| printMismatchHeader(staticInst, *pc); |
| outs << "diff> [opcode] gem5: 0x" << std::hex |
| << arm_inst->encoding() |
| << ", TARMAC: 0x" << instRecord.opcode << std::endl; |
| mismatch = true; |
| mismatchOnPcOrOpcode = true; |
| } |
| |
| // Set the Instruction set state. |
| isetstate = pcToISetState(*pc); |
| |
| if (instRecord.isetstate != isetstate && |
| isetstate != ISET_UNSUPPORTED) { |
| if (!mismatch) |
| printMismatchHeader(staticInst, *pc); |
| outs << "diff> [iset_state] gem5: " |
| << iSetStateToStr(isetstate) |
| << ", TARMAC: " |
| << iSetStateToStr(instRecord.isetstate); |
| mismatch = true; |
| } |
| |
| // TODO(Giacomo): add support for predicate and mode checking |
| break; |
| |
| case TARMAC_REG: |
| destRegRecords.push_back(regRecord); |
| break; |
| |
| case TARMAC_MEM: |
| if (!readMemNoEffect(memRecord.addr, (uint8_t*) &written_data, |
| memRecord.size, mem_flags)) |
| break; |
| if (written_data != memRecord.data) { |
| if (!mismatch) |
| printMismatchHeader(staticInst, *pc); |
| outs << "diff> [mem(0x" << std::hex << memRecord.addr |
| << ")] gem5: 0x" << written_data |
| << ", TARMAC: 0x" << memRecord.data |
| << std::endl; |
| } |
| break; |
| |
| case TARMAC_UNSUPPORTED: |
| break; |
| |
| default: |
| panic("Unknown TARMAC trace record type!"); |
| } |
| } |
| // We are done with the current instruction, i.e. all the corresponding |
| // entries in the TARMAC trace have been parsed |
| if (destRegRecords.size()) { |
| TarmacParserRecordEvent *event = new TarmacParserRecordEvent( |
| parent, thread, staticInst, *pc, mismatch, |
| mismatchOnPcOrOpcode); |
| mainEventQueue[0]->schedule(event, curTick()); |
| } else if (mismatchOnPcOrOpcode && (parent.exitOnDiff || |
| parent.exitOnInsnDiff)) { |
| exitSimLoop("a mismatch with the TARMAC trace has been detected " |
| "on PC or opcode", 1); |
| } |
| } else { |
| parent.macroopInProgress = true; |
| } |
| } |
| |
| bool |
| TarmacParserRecord::advanceTrace() |
| { |
| std::ifstream& trace = parent.trace; |
| trace >> std::hex; // All integer values are in hex base |
| |
| if (buf[0] != 'I') { |
| trace >> buf; |
| if (trace.eof()) |
| return false; |
| trace >> buf >> buf; |
| if (parent.cpuId) { |
| assert((buf[0] == 'c') && (buf[1] == 'p') && (buf[2] == 'u')); |
| trace >> buf; |
| } |
| } |
| |
| if (trace.eof()) |
| return false; |
| |
| if (buf[0] == 'I') { |
| // Instruction trace record |
| if (parsingStarted) |
| return false; |
| currRecordType = TARMAC_INST; |
| instRecord.taken = (buf[1] == 'T'); |
| trace >> buf; |
| instRecord.seq_num = atoi(&buf[1]); |
| trace >> instRecord.addr; |
| char c = trace.peek(); |
| if (c == ':') { |
| // Skip phys. address and _S/_NS suffix |
| trace >> c >> buf; |
| } |
| trace >> instRecord.opcode; |
| trace >> buf; |
| switch (buf[0]) { |
| case 'A': |
| instRecord.isetstate = ISET_ARM; |
| break; |
| case 'T': |
| instRecord.isetstate = ISET_THUMB; |
| break; |
| case 'O': |
| instRecord.isetstate = ISET_A64; |
| break; |
| default: |
| warn("Invalid TARMAC trace record (seq_num: %lld)", |
| instRecord.seq_num); |
| instRecord.isetstate = ISET_UNSUPPORTED; |
| currRecordType = TARMAC_UNSUPPORTED; |
| break; |
| } |
| trace.ignore(MaxLineLength, '\n'); |
| buf[0] = 0; |
| } else if (buf[0] == 'R') { |
| // Register trace record |
| currRecordType = TARMAC_REG; |
| regRecord.values.clear(); |
| trace >> buf; |
| strcpy(regRecord.repr, buf); |
| if (std::tolower(buf[0]) == 'r' && isdigit(buf[1])) { |
| // R register |
| regRecord.type = REG_R; |
| int base_index = atoi(&buf[1]); |
| char* pch = strchr(buf, '_'); |
| if (pch == NULL) { |
| regRecord.index = int_reg::usr(base_index); |
| } else { |
| ++pch; |
| if (strncmp(pch, "usr", 3) == 0) |
| regRecord.index = int_reg::usr(base_index); |
| else if (strncmp(pch, "fiq", 3) == 0) |
| regRecord.index = int_reg::fiq(base_index); |
| else if (strncmp(pch, "irq", 3) == 0) |
| regRecord.index = int_reg::irq(base_index); |
| else if (strncmp(pch, "svc", 3) == 0) |
| regRecord.index = int_reg::svc(base_index); |
| else if (strncmp(pch, "mon", 3) == 0) |
| regRecord.index = int_reg::mon(base_index); |
| else if (strncmp(pch, "abt", 3) == 0) |
| regRecord.index = int_reg::abt(base_index); |
| else if (strncmp(pch, "und", 3) == 0) |
| regRecord.index = int_reg::und(base_index); |
| else if (strncmp(pch, "hyp", 3) == 0) |
| regRecord.index = int_reg::hyp(base_index); |
| } |
| } else if (std::tolower(buf[0]) == 'x' && isdigit(buf[1])) { |
| // X register (A64) |
| regRecord.type = REG_X; |
| regRecord.index = atoi(&buf[1]); |
| } else if (std::tolower(buf[0]) == 's' && isdigit(buf[1])) { |
| // S register |
| regRecord.type = REG_S; |
| regRecord.index = atoi(&buf[1]); |
| } else if (std::tolower(buf[0]) == 'd' && isdigit(buf[1])) { |
| // D register |
| regRecord.type = REG_D; |
| regRecord.index = atoi(&buf[1]); |
| } else if (std::tolower(buf[0]) == 'q' && isdigit(buf[1])) { |
| // Q register |
| regRecord.type = REG_Q; |
| regRecord.index = atoi(&buf[1]); |
| } else if (std::tolower(buf[0]) == 'z' && isdigit(buf[1])) { |
| // Z (SVE vector) register |
| regRecord.type = REG_Z; |
| regRecord.index = atoi(&buf[1]); |
| } else if (std::tolower(buf[0]) == 'p' && isdigit(buf[1])) { |
| // P (SVE predicate) register |
| regRecord.type = REG_P; |
| regRecord.index = atoi(&buf[1]); |
| } else if (strncmp(buf, "SP_EL", 5) == 0) { |
| // A64 stack pointer |
| regRecord.type = REG_X; |
| regRecord.index = int_reg::Sp0 + atoi(&buf[5]); |
| } else if (miscRegMap.count(buf)) { |
| // Misc. register |
| regRecord.type = REG_MISC; |
| regRecord.index = miscRegMap[buf]; |
| } else { |
| // Try match with upper case name (misc. register) |
| std::string reg_name = buf; |
| std::transform(reg_name.begin(), reg_name.end(), reg_name.begin(), |
| ::tolower); |
| if (miscRegMap.count(reg_name.c_str())) { |
| regRecord.type = REG_MISC; |
| regRecord.index = miscRegMap[reg_name.c_str()]; |
| } else { |
| warn("Unknown register in TARMAC trace (%s).\n", buf); |
| currRecordType = TARMAC_UNSUPPORTED; |
| trace.ignore(MaxLineLength, '\n'); |
| buf[0] = 0; |
| return true; |
| } |
| } |
| if (regRecord.type == REG_Q) { |
| trace.ignore(); |
| trace.get(buf, 17); |
| uint64_t hi = strtoull(buf, NULL, 16); |
| trace.get(buf, 17); |
| uint64_t lo = strtoull(buf, NULL, 16); |
| regRecord.values.push_back(lo); |
| regRecord.values.push_back(hi); |
| } else if (regRecord.type == REG_Z) { |
| regRecord.values.resize(maxVectorLength); |
| for (uint8_t i = 0; i < maxVectorLength; ++i) { |
| uint64_t v; |
| trace >> v; |
| char c; |
| trace >> c; |
| assert(c == '_'); |
| |
| uint64_t lsw = 0; |
| trace >> lsw; |
| v = (v << 32) | lsw; |
| if (i < maxVectorLength - 1) trace >> c; |
| regRecord.values[i] = v; |
| } |
| } else { |
| // REG_P values are also parsed here |
| uint64_t v; |
| trace >> v; |
| char c = trace.peek(); |
| if ((c == ':') || (c == '_')) { |
| // 64-bit value with : or _ in the middle |
| uint64_t lsw = 0; |
| trace >> c >> lsw; |
| v = (v << 32) | lsw; |
| } |
| regRecord.values.push_back(v); |
| } |
| trace.ignore(MaxLineLength, '\n'); |
| buf[0] = 0; |
| } else if (buf[0] == 'M' && (parent.memWrCheck && buf[1] == 'W')) { |
| currRecordType = TARMAC_MEM; |
| memRecord.size = atoi(&buf[2]); |
| trace >> memRecord.addr; |
| char c = trace.peek(); |
| if (c == ':') { |
| // Skip phys. address and _S/_NS suffix |
| trace >> c >> buf; |
| } |
| uint64_t data = 0; |
| trace >> data; |
| c = trace.peek(); |
| if (c == '_') { |
| // 64-bit value with _ in the middle |
| uint64_t lsw = 0; |
| trace >> c >> lsw; |
| data = (data << 32) | lsw; |
| } |
| memRecord.data = data; |
| trace.ignore(MaxLineLength, '\n'); |
| buf[0] = 0; |
| } else { |
| currRecordType = TARMAC_UNSUPPORTED; |
| trace.ignore(MaxLineLength, '\n'); |
| buf[0] = 0; |
| } |
| |
| return true; |
| } |
| |
| bool |
| TarmacParserRecord::readMemNoEffect(Addr addr, uint8_t *data, unsigned size, |
| unsigned flags) |
| { |
| const RequestPtr &req = memReq; |
| auto mmu = static_cast<MMU*>(thread->getMMUPtr()); |
| |
| req->setVirt(addr, size, flags, thread->pcState().instAddr(), |
| Request::funcRequestorId); |
| |
| // Translate to physical address |
| Fault fault = mmu->translateAtomic(req, thread, BaseMMU::Read); |
| |
| // Ignore read if the address falls into the ignored range |
| if (parent.ignoredAddrRange.contains(addr)) |
| return false; |
| |
| // Now do the access |
| if (fault == NoFault && |
| !req->getFlags().isSet(Request::NO_ACCESS)) { |
| if (req->isLLSC() || req->isLocalAccess()) |
| // LLSCs and local accesses are ignored |
| return false; |
| // the translating proxy will perform the virtual to physical |
| // translation again |
| TranslatingPortProxy fs_proxy(thread); |
| SETranslatingPortProxy se_proxy(thread); |
| PortProxy &virt_proxy = FullSystem ? fs_proxy : se_proxy; |
| |
| virt_proxy.readBlob(addr, data, size); |
| } else { |
| return false; |
| } |
| |
| if (fault != NoFault) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| void |
| TarmacParser::advanceTraceToStartPc() |
| { |
| char buf[TarmacParserRecord::MaxLineLength]; |
| Addr pc; |
| int saved_offset; |
| |
| trace >> std::hex; // All integer values are in hex base |
| |
| while (true) { |
| saved_offset = trace.tellg(); |
| trace >> buf >> buf >> buf; |
| if (cpuId) |
| trace >> buf; |
| if (buf[0] == 'I') { |
| trace >> buf >> pc; |
| if (pc == startPc) { |
| // Set file pointer to the beginning of this line |
| trace.seekg(saved_offset, std::ios::beg); |
| return; |
| } else { |
| trace.ignore(TarmacParserRecord::MaxLineLength, '\n'); |
| } |
| } else { |
| trace.ignore(TarmacParserRecord::MaxLineLength, '\n'); |
| } |
| if (trace.eof()) |
| panic("End of TARMAC trace reached before start PC\n"); |
| } |
| } |
| |
| const char* |
| TarmacParserRecord::iSetStateToStr(ISetState isetstate) const |
| { |
| switch (isetstate) { |
| case ISET_ARM: |
| return "ARM (A32)"; |
| case ISET_THUMB: |
| return "Thumb (A32)"; |
| case ISET_A64: |
| return "A64"; |
| default: |
| return "UNSUPPORTED"; |
| } |
| } |
| |
| } // namespace Trace |
| } // namespace gem5 |
