672 lines
22 KiB
C++
672 lines
22 KiB
C++
/*
|
|
* \file trc_pkt_decode_ptm.cpp
|
|
* \brief OpenCSD : PTM packet decoder.
|
|
*
|
|
* \copyright Copyright (c) 2016, ARM Limited. All Rights Reserved.
|
|
*/
|
|
|
|
/*
|
|
* Redistribution and use in source and binary forms, with or without modification,
|
|
* are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
*
|
|
* 2. 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.
|
|
*
|
|
* 3. Neither the name of the copyright holder 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 HOLDER 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 <sstream>
|
|
#include "opencsd/ptm/trc_pkt_decode_ptm.h"
|
|
|
|
#define DCD_NAME "DCD_PTM"
|
|
|
|
TrcPktDecodePtm::TrcPktDecodePtm()
|
|
: TrcPktDecodeBase(DCD_NAME)
|
|
{
|
|
initDecoder();
|
|
}
|
|
|
|
TrcPktDecodePtm::TrcPktDecodePtm(int instIDNum)
|
|
: TrcPktDecodeBase(DCD_NAME,instIDNum)
|
|
{
|
|
initDecoder();
|
|
}
|
|
|
|
TrcPktDecodePtm::~TrcPktDecodePtm()
|
|
{
|
|
}
|
|
|
|
/*********************** implementation packet decoding interface */
|
|
|
|
ocsd_datapath_resp_t TrcPktDecodePtm::processPacket()
|
|
{
|
|
ocsd_datapath_resp_t resp = OCSD_RESP_CONT;
|
|
bool bPktDone = false;
|
|
|
|
while(!bPktDone)
|
|
{
|
|
switch(m_curr_state)
|
|
{
|
|
case NO_SYNC:
|
|
// no sync - output a no sync packet then transition to wait sync.
|
|
m_output_elem.elem_type = OCSD_GEN_TRC_ELEM_NO_SYNC;
|
|
m_output_elem.unsync_eot_info = m_unsync_info;
|
|
resp = outputTraceElement(m_output_elem);
|
|
m_curr_state = (m_curr_packet_in->getType() == PTM_PKT_A_SYNC) ? WAIT_ISYNC : WAIT_SYNC;
|
|
bPktDone = true;
|
|
break;
|
|
|
|
case WAIT_SYNC:
|
|
if(m_curr_packet_in->getType() == PTM_PKT_A_SYNC)
|
|
m_curr_state = WAIT_ISYNC;
|
|
bPktDone = true;
|
|
break;
|
|
|
|
case WAIT_ISYNC:
|
|
if(m_curr_packet_in->getType() == PTM_PKT_I_SYNC)
|
|
m_curr_state = DECODE_PKTS;
|
|
else
|
|
bPktDone = true;
|
|
break;
|
|
|
|
case DECODE_PKTS:
|
|
resp = decodePacket();
|
|
bPktDone = true;
|
|
break;
|
|
|
|
default:
|
|
// should only see these after a _WAIT resp - in flush handler
|
|
case CONT_ISYNC:
|
|
case CONT_ATOM:
|
|
bPktDone = true;
|
|
// throw a decoder error
|
|
break;
|
|
}
|
|
}
|
|
return resp;
|
|
}
|
|
|
|
ocsd_datapath_resp_t TrcPktDecodePtm::onEOT()
|
|
{
|
|
ocsd_datapath_resp_t resp = OCSD_RESP_CONT;
|
|
// shouldn't be any packets left to be processed - flush shoudl have done this.
|
|
// just output the end of trace marker
|
|
m_output_elem.setType(OCSD_GEN_TRC_ELEM_EO_TRACE);
|
|
m_output_elem.setUnSyncEOTReason(UNSYNC_EOT);
|
|
resp = outputTraceElement(m_output_elem);
|
|
return resp;
|
|
}
|
|
|
|
ocsd_datapath_resp_t TrcPktDecodePtm::onReset()
|
|
{
|
|
ocsd_datapath_resp_t resp = OCSD_RESP_CONT;
|
|
m_unsync_info = UNSYNC_RESET_DECODER;
|
|
resetDecoder();
|
|
return resp;
|
|
}
|
|
|
|
ocsd_datapath_resp_t TrcPktDecodePtm::onFlush()
|
|
{
|
|
ocsd_datapath_resp_t resp = OCSD_RESP_CONT;
|
|
resp = contProcess();
|
|
return resp;
|
|
}
|
|
|
|
// atom and isync packets can have multiple ouput packets that can be _WAITed mid stream.
|
|
ocsd_datapath_resp_t TrcPktDecodePtm::contProcess()
|
|
{
|
|
ocsd_datapath_resp_t resp = OCSD_RESP_CONT;
|
|
switch(m_curr_state)
|
|
{
|
|
case CONT_ISYNC:
|
|
resp = processIsync();
|
|
break;
|
|
|
|
case CONT_ATOM:
|
|
resp = processAtom();
|
|
break;
|
|
|
|
case CONT_WPUP:
|
|
resp = processWPUpdate();
|
|
break;
|
|
|
|
case CONT_BRANCH:
|
|
resp = processBranch();
|
|
break;
|
|
|
|
default: break; // not a state that requires further processing
|
|
}
|
|
|
|
if(OCSD_DATA_RESP_IS_CONT(resp) && processStateIsCont())
|
|
m_curr_state = DECODE_PKTS; // continue packet processing - assuming we have not degraded into an unsynced state.
|
|
|
|
return resp;
|
|
}
|
|
|
|
ocsd_err_t TrcPktDecodePtm::onProtocolConfig()
|
|
{
|
|
ocsd_err_t err = OCSD_OK;
|
|
if(m_config == 0)
|
|
return OCSD_ERR_NOT_INIT;
|
|
|
|
// static config - copy of CSID for easy reference
|
|
m_CSID = m_config->getTraceID();
|
|
|
|
// handle return stack implementation
|
|
if (m_config->hasRetStack())
|
|
{
|
|
m_return_stack.set_active(m_config->enaRetStack());
|
|
#ifdef TRC_RET_STACK_DEBUG
|
|
m_return_stack.set_dbg_logger(this);
|
|
#endif
|
|
}
|
|
|
|
// config options affecting decode
|
|
m_instr_info.pe_type.profile = m_config->coreProfile();
|
|
m_instr_info.pe_type.arch = m_config->archVersion();
|
|
m_instr_info.dsb_dmb_waypoints = m_config->dmsbWayPt() ? 1 : 0;
|
|
m_instr_info.wfi_wfe_branch = 0;
|
|
return err;
|
|
}
|
|
|
|
/****************** local decoder routines */
|
|
|
|
void TrcPktDecodePtm::initDecoder()
|
|
{
|
|
m_CSID = 0;
|
|
m_instr_info.pe_type.profile = profile_Unknown;
|
|
m_instr_info.pe_type.arch = ARCH_UNKNOWN;
|
|
m_instr_info.dsb_dmb_waypoints = 0;
|
|
m_unsync_info = UNSYNC_INIT_DECODER;
|
|
resetDecoder();
|
|
}
|
|
|
|
void TrcPktDecodePtm::resetDecoder()
|
|
{
|
|
m_curr_state = NO_SYNC;
|
|
m_need_isync = true; // need context to start.
|
|
|
|
m_instr_info.isa = ocsd_isa_unknown;
|
|
m_mem_nacc_pending = false;
|
|
|
|
m_pe_context.ctxt_id_valid = 0;
|
|
m_pe_context.bits64 = 0;
|
|
m_pe_context.vmid_valid = 0;
|
|
m_pe_context.exception_level = ocsd_EL_unknown;
|
|
m_pe_context.security_level = ocsd_sec_secure;
|
|
m_pe_context.el_valid = 0;
|
|
|
|
m_curr_pe_state.instr_addr = 0x0;
|
|
m_curr_pe_state.isa = ocsd_isa_unknown;
|
|
m_curr_pe_state.valid = false;
|
|
|
|
m_atoms.clearAll();
|
|
m_output_elem.init();
|
|
}
|
|
|
|
ocsd_datapath_resp_t TrcPktDecodePtm::decodePacket()
|
|
{
|
|
ocsd_datapath_resp_t resp = OCSD_RESP_CONT;
|
|
switch(m_curr_packet_in->getType())
|
|
{
|
|
// ignore these from trace o/p point of veiw
|
|
case PTM_PKT_NOTSYNC:
|
|
case PTM_PKT_INCOMPLETE_EOT:
|
|
case PTM_PKT_NOERROR:
|
|
break;
|
|
|
|
// bad / reserved packet - need to wait for next sync point
|
|
case PTM_PKT_BAD_SEQUENCE:
|
|
case PTM_PKT_RESERVED:
|
|
m_curr_state = WAIT_SYNC;
|
|
m_need_isync = true; // need context to re-start.
|
|
m_output_elem.setType(OCSD_GEN_TRC_ELEM_NO_SYNC);
|
|
resp = outputTraceElement(m_output_elem);
|
|
break;
|
|
|
|
// packets we can ignore if in sync
|
|
case PTM_PKT_A_SYNC:
|
|
case PTM_PKT_IGNORE:
|
|
break;
|
|
|
|
//
|
|
case PTM_PKT_I_SYNC:
|
|
resp = processIsync();
|
|
break;
|
|
|
|
case PTM_PKT_BRANCH_ADDRESS:
|
|
resp = processBranch();
|
|
break;
|
|
|
|
case PTM_PKT_TRIGGER:
|
|
m_output_elem.setType(OCSD_GEN_TRC_ELEM_EVENT);
|
|
m_output_elem.setEvent(EVENT_TRIGGER, 0);
|
|
resp = outputTraceElement(m_output_elem);
|
|
break;
|
|
|
|
case PTM_PKT_WPOINT_UPDATE:
|
|
resp = processWPUpdate();
|
|
break;
|
|
|
|
case PTM_PKT_CONTEXT_ID:
|
|
{
|
|
bool bUpdate = true;
|
|
// see if this is a change
|
|
if((m_pe_context.ctxt_id_valid) && (m_pe_context.context_id == m_curr_packet_in->context.ctxtID))
|
|
bUpdate = false;
|
|
if(bUpdate)
|
|
{
|
|
m_pe_context.context_id = m_curr_packet_in->context.ctxtID;
|
|
m_pe_context.ctxt_id_valid = 1;
|
|
m_output_elem.setType(OCSD_GEN_TRC_ELEM_PE_CONTEXT);
|
|
m_output_elem.setContext(m_pe_context);
|
|
resp = outputTraceElement(m_output_elem);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case PTM_PKT_VMID:
|
|
{
|
|
bool bUpdate = true;
|
|
// see if this is a change
|
|
if((m_pe_context.vmid_valid) && (m_pe_context.vmid == m_curr_packet_in->context.VMID))
|
|
bUpdate = false;
|
|
if(bUpdate)
|
|
{
|
|
m_pe_context.vmid = m_curr_packet_in->context.VMID;
|
|
m_pe_context.vmid_valid = 1;
|
|
m_output_elem.setType(OCSD_GEN_TRC_ELEM_PE_CONTEXT);
|
|
m_output_elem.setContext(m_pe_context);
|
|
resp = outputTraceElement(m_output_elem);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case PTM_PKT_ATOM:
|
|
if(m_curr_pe_state.valid)
|
|
{
|
|
m_atoms.initAtomPkt(m_curr_packet_in->getAtom(),m_index_curr_pkt);
|
|
resp = processAtom();
|
|
}
|
|
break;
|
|
|
|
case PTM_PKT_TIMESTAMP:
|
|
m_output_elem.setType(OCSD_GEN_TRC_ELEM_TIMESTAMP);
|
|
m_output_elem.timestamp = m_curr_packet_in->timestamp;
|
|
if(m_curr_packet_in->cc_valid)
|
|
m_output_elem.setCycleCount(m_curr_packet_in->cycle_count);
|
|
resp = outputTraceElement(m_output_elem);
|
|
break;
|
|
|
|
case PTM_PKT_EXCEPTION_RET:
|
|
m_output_elem.setType(OCSD_GEN_TRC_ELEM_EXCEPTION_RET);
|
|
resp = outputTraceElement(m_output_elem);
|
|
break;
|
|
|
|
}
|
|
return resp;
|
|
}
|
|
|
|
ocsd_datapath_resp_t TrcPktDecodePtm::processIsync()
|
|
{
|
|
ocsd_datapath_resp_t resp = OCSD_RESP_CONT;
|
|
|
|
// extract the I-Sync data if not re-entering after a _WAIT
|
|
if(m_curr_state == DECODE_PKTS)
|
|
{
|
|
m_curr_pe_state.instr_addr = m_curr_packet_in->getAddrVal();
|
|
m_curr_pe_state.isa = m_curr_packet_in->getISA();
|
|
m_curr_pe_state.valid = true;
|
|
|
|
m_i_sync_pe_ctxt = m_curr_packet_in->ISAChanged();
|
|
if(m_curr_packet_in->CtxtIDUpdated())
|
|
{
|
|
m_pe_context.context_id = m_curr_packet_in->getCtxtID();
|
|
m_pe_context.ctxt_id_valid = 1;
|
|
m_i_sync_pe_ctxt = true;
|
|
}
|
|
|
|
if(m_curr_packet_in->VMIDUpdated())
|
|
{
|
|
m_pe_context.vmid = m_curr_packet_in->getVMID();
|
|
m_pe_context.vmid_valid = 1;
|
|
m_i_sync_pe_ctxt = true;
|
|
}
|
|
m_pe_context.security_level = m_curr_packet_in->getNS() ? ocsd_sec_nonsecure : ocsd_sec_secure;
|
|
|
|
if(m_need_isync || (m_curr_packet_in->iSyncReason() != iSync_Periodic))
|
|
{
|
|
m_output_elem.setType(OCSD_GEN_TRC_ELEM_TRACE_ON);
|
|
m_output_elem.trace_on_reason = TRACE_ON_NORMAL;
|
|
if(m_curr_packet_in->iSyncReason() == iSync_TraceRestartAfterOverflow)
|
|
m_output_elem.trace_on_reason = TRACE_ON_OVERFLOW;
|
|
else if(m_curr_packet_in->iSyncReason() == iSync_DebugExit)
|
|
m_output_elem.trace_on_reason = TRACE_ON_EX_DEBUG;
|
|
if(m_curr_packet_in->hasCC())
|
|
m_output_elem.setCycleCount(m_curr_packet_in->getCCVal());
|
|
resp = outputTraceElement(m_output_elem);
|
|
}
|
|
else
|
|
{
|
|
// periodic - no output
|
|
m_i_sync_pe_ctxt = false;
|
|
}
|
|
m_need_isync = false; // got 1st Isync - can continue to process data.
|
|
m_return_stack.flush();
|
|
}
|
|
|
|
if(m_i_sync_pe_ctxt && OCSD_DATA_RESP_IS_CONT(resp))
|
|
{
|
|
m_output_elem.setType(OCSD_GEN_TRC_ELEM_PE_CONTEXT);
|
|
m_output_elem.setContext(m_pe_context);
|
|
m_output_elem.setISA(m_curr_pe_state.isa);
|
|
resp = outputTraceElement(m_output_elem);
|
|
m_i_sync_pe_ctxt = false;
|
|
}
|
|
|
|
// if wait and still stuff to process....
|
|
if(OCSD_DATA_RESP_IS_WAIT(resp) && ( m_i_sync_pe_ctxt))
|
|
m_curr_state = CONT_ISYNC;
|
|
|
|
return resp;
|
|
}
|
|
|
|
// change of address and/or exception in program flow.
|
|
// implies E atom before the branch if none exception.
|
|
ocsd_datapath_resp_t TrcPktDecodePtm::processBranch()
|
|
{
|
|
ocsd_datapath_resp_t resp = OCSD_RESP_CONT;
|
|
|
|
// initial pass - decoding packet.
|
|
if(m_curr_state == DECODE_PKTS)
|
|
{
|
|
// specific behviour if this is an exception packet.
|
|
if(m_curr_packet_in->isBranchExcepPacket())
|
|
{
|
|
// exception - record address and output exception packet.
|
|
m_output_elem.setType(OCSD_GEN_TRC_ELEM_EXCEPTION);
|
|
m_output_elem.exception_number = m_curr_packet_in->excepNum();
|
|
m_output_elem.excep_ret_addr = 0;
|
|
if(m_curr_pe_state.valid)
|
|
{
|
|
m_output_elem.excep_ret_addr = 1;
|
|
m_output_elem.en_addr = m_curr_pe_state.instr_addr;
|
|
}
|
|
// could be an associated cycle count
|
|
if(m_curr_packet_in->hasCC())
|
|
m_output_elem.setCycleCount(m_curr_packet_in->getCCVal());
|
|
|
|
// output the element
|
|
resp = outputTraceElement(m_output_elem);
|
|
}
|
|
else
|
|
{
|
|
// branch address only - implies E atom - need to output a range element based on the atom.
|
|
if(m_curr_pe_state.valid)
|
|
resp = processAtomRange(ATOM_E,"BranchAddr");
|
|
}
|
|
|
|
// now set the branch address for the next time.
|
|
m_curr_pe_state.isa = m_curr_packet_in->getISA();
|
|
m_curr_pe_state.instr_addr = m_curr_packet_in->getAddrVal();
|
|
m_curr_pe_state.valid = true;
|
|
}
|
|
|
|
// atom range may return with NACC pending
|
|
checkPendingNacc(resp);
|
|
|
|
// if wait and still stuff to process....
|
|
if(OCSD_DATA_RESP_IS_WAIT(resp) && ( m_mem_nacc_pending))
|
|
m_curr_state = CONT_BRANCH;
|
|
|
|
return resp;
|
|
}
|
|
|
|
// effectively completes a range prior to exception or after many bytes of trace (>4096)
|
|
//
|
|
ocsd_datapath_resp_t TrcPktDecodePtm::processWPUpdate()
|
|
{
|
|
ocsd_datapath_resp_t resp = OCSD_RESP_CONT;
|
|
|
|
// if we need an address to run from then the WPUpdate will not form a range as
|
|
// we do not have a start point - still waiting for branch or other address packet
|
|
if(m_curr_pe_state.valid)
|
|
{
|
|
// WP update implies atom - use E, we cannot be sure if the instruction passed its condition codes
|
|
// - though it doesn't really matter as it is not a branch so cannot change flow.
|
|
resp = processAtomRange(ATOM_E,"WP update",TRACE_TO_ADDR_INCL,m_curr_packet_in->getAddrVal());
|
|
}
|
|
|
|
// atom range may return with NACC pending
|
|
checkPendingNacc(resp);
|
|
|
|
// if wait and still stuff to process....
|
|
if(OCSD_DATA_RESP_IS_WAIT(resp) && ( m_mem_nacc_pending))
|
|
m_curr_state = CONT_WPUP;
|
|
|
|
return resp;
|
|
}
|
|
|
|
// a single atom packet can result in multiple range outputs...need to be re-entrant in case we get a wait response.
|
|
// also need to handle nacc response from instruction walking routine
|
|
//
|
|
ocsd_datapath_resp_t TrcPktDecodePtm::processAtom()
|
|
{
|
|
ocsd_datapath_resp_t resp = OCSD_RESP_CONT;
|
|
|
|
// loop to process all the atoms in the packet
|
|
while(m_atoms.numAtoms() && m_curr_pe_state.valid && OCSD_DATA_RESP_IS_CONT(resp))
|
|
{
|
|
resp = processAtomRange(m_atoms.getCurrAtomVal(),"atom");
|
|
if(!m_curr_pe_state.valid)
|
|
m_atoms.clearAll();
|
|
else
|
|
m_atoms.clearAtom();
|
|
}
|
|
|
|
// bad address may mean a nacc needs sending
|
|
checkPendingNacc(resp);
|
|
|
|
// if wait and still stuff to process....
|
|
if(OCSD_DATA_RESP_IS_WAIT(resp) && ( m_mem_nacc_pending || m_atoms.numAtoms()))
|
|
m_curr_state = CONT_ATOM;
|
|
|
|
return resp;
|
|
}
|
|
|
|
void TrcPktDecodePtm::checkPendingNacc(ocsd_datapath_resp_t &resp)
|
|
{
|
|
if(m_mem_nacc_pending && OCSD_DATA_RESP_IS_CONT(resp))
|
|
{
|
|
m_output_elem.setType(OCSD_GEN_TRC_ELEM_ADDR_NACC);
|
|
m_output_elem.st_addr = m_nacc_addr;
|
|
resp = outputTraceElementIdx(m_index_curr_pkt,m_output_elem);
|
|
m_mem_nacc_pending = false;
|
|
}
|
|
}
|
|
|
|
// given an atom element - walk the code and output a range or mark nacc.
|
|
ocsd_datapath_resp_t TrcPktDecodePtm::processAtomRange(const ocsd_atm_val A, const char *pkt_msg, const waypoint_trace_t traceWPOp /*= TRACE_WAYPOINT*/, const ocsd_vaddr_t nextAddrMatch /*= 0*/)
|
|
{
|
|
ocsd_datapath_resp_t resp = OCSD_RESP_CONT;
|
|
bool bWPFound = false;
|
|
std::ostringstream oss;
|
|
ocsd_err_t err = OCSD_OK;
|
|
|
|
m_instr_info.instr_addr = m_curr_pe_state.instr_addr;
|
|
m_instr_info.isa = m_curr_pe_state.isa;
|
|
|
|
// set type (which resets out-elem) before traceInstrToWP modifies out-elem values
|
|
m_output_elem.setType(OCSD_GEN_TRC_ELEM_INSTR_RANGE);
|
|
|
|
err = traceInstrToWP(bWPFound,traceWPOp,nextAddrMatch);
|
|
if(err != OCSD_OK)
|
|
{
|
|
if(err == OCSD_ERR_UNSUPPORTED_ISA)
|
|
{
|
|
m_curr_pe_state.valid = false; // need a new address packet
|
|
oss << "Warning: unsupported instruction set processing " << pkt_msg << " packet.";
|
|
LogError(ocsdError(OCSD_ERR_SEV_WARN,err,m_index_curr_pkt,m_CSID,oss.str()));
|
|
// wait for next address
|
|
return OCSD_RESP_WARN_CONT;
|
|
}
|
|
else
|
|
{
|
|
resp = OCSD_RESP_FATAL_INVALID_DATA;
|
|
oss << "Error processing " << pkt_msg << " packet.";
|
|
LogError(ocsdError(OCSD_ERR_SEV_ERROR,err,m_index_curr_pkt,m_CSID,oss.str()));
|
|
return resp;
|
|
}
|
|
}
|
|
|
|
if(bWPFound)
|
|
{
|
|
// save recorded next instuction address
|
|
ocsd_vaddr_t nextAddr = m_instr_info.instr_addr;
|
|
|
|
// action according to waypoint type and atom value
|
|
switch(m_instr_info.type)
|
|
{
|
|
case OCSD_INSTR_BR:
|
|
if (A == ATOM_E)
|
|
{
|
|
m_instr_info.instr_addr = m_instr_info.branch_addr;
|
|
if (m_instr_info.is_link)
|
|
m_return_stack.push(nextAddr,m_instr_info.isa);
|
|
}
|
|
break;
|
|
|
|
// For PTM -> branch addresses imply E atom, N atom does not need address (return stack will require this)
|
|
case OCSD_INSTR_BR_INDIRECT:
|
|
if (A == ATOM_E)
|
|
{
|
|
// atom on indirect branch - either implied E from a branch address packet, or return stack if active.
|
|
|
|
// indirect branch taken - need new address -if the current packet is a branch address packet this will be sorted.
|
|
m_curr_pe_state.valid = false;
|
|
|
|
// if return stack and the incoming packet is an atom.
|
|
if (m_return_stack.is_active() && (m_curr_packet_in->getType() == PTM_PKT_ATOM))
|
|
{
|
|
// we have an E atom packet and return stack value - set address from return stack
|
|
m_instr_info.instr_addr = m_return_stack.pop(m_instr_info.next_isa);
|
|
|
|
if (m_return_stack.overflow())
|
|
{
|
|
resp = OCSD_RESP_FATAL_INVALID_DATA;
|
|
oss << "Return stack error processing " << pkt_msg << " packet.";
|
|
LogError(ocsdError(OCSD_ERR_SEV_ERROR, OCSD_ERR_RET_STACK_OVERFLOW, m_index_curr_pkt, m_CSID, oss.str()));
|
|
return resp;
|
|
}
|
|
else
|
|
m_curr_pe_state.valid = true;
|
|
}
|
|
if(m_instr_info.is_link)
|
|
m_return_stack.push(nextAddr, m_instr_info.isa);
|
|
}
|
|
break;
|
|
}
|
|
|
|
m_output_elem.setLastInstrInfo((A == ATOM_E),m_instr_info.type, m_instr_info.sub_type,m_instr_info.instr_size);
|
|
m_output_elem.setISA(m_curr_pe_state.isa);
|
|
if(m_curr_packet_in->hasCC())
|
|
m_output_elem.setCycleCount(m_curr_packet_in->getCCVal());
|
|
m_output_elem.setLastInstrCond(m_instr_info.is_conditional);
|
|
resp = outputTraceElementIdx(m_index_curr_pkt,m_output_elem);
|
|
|
|
m_curr_pe_state.instr_addr = m_instr_info.instr_addr;
|
|
m_curr_pe_state.isa = m_instr_info.next_isa;
|
|
}
|
|
else
|
|
{
|
|
// no waypoint - likely inaccessible memory range.
|
|
m_curr_pe_state.valid = false; // need an address update
|
|
|
|
if(m_output_elem.st_addr != m_output_elem.en_addr)
|
|
{
|
|
// some trace before we were out of memory access range
|
|
m_output_elem.setLastInstrInfo(true,m_instr_info.type, m_instr_info.sub_type,m_instr_info.instr_size);
|
|
m_output_elem.setISA(m_curr_pe_state.isa);
|
|
m_output_elem.setLastInstrCond(m_instr_info.is_conditional);
|
|
resp = outputTraceElementIdx(m_index_curr_pkt,m_output_elem);
|
|
}
|
|
}
|
|
return resp;
|
|
}
|
|
|
|
ocsd_err_t TrcPktDecodePtm::traceInstrToWP(bool &bWPFound, const waypoint_trace_t traceWPOp /*= TRACE_WAYPOINT*/, const ocsd_vaddr_t nextAddrMatch /*= 0*/)
|
|
{
|
|
uint32_t opcode;
|
|
uint32_t bytesReq;
|
|
ocsd_err_t err = OCSD_OK;
|
|
ocsd_vaddr_t curr_op_address;
|
|
|
|
ocsd_mem_space_acc_t mem_space = (m_pe_context.security_level == ocsd_sec_secure) ? OCSD_MEM_SPACE_S : OCSD_MEM_SPACE_N;
|
|
|
|
m_output_elem.st_addr = m_output_elem.en_addr = m_instr_info.instr_addr;
|
|
m_output_elem.num_instr_range = 0;
|
|
|
|
bWPFound = false;
|
|
|
|
while(!bWPFound && !m_mem_nacc_pending)
|
|
{
|
|
// start off by reading next opcode;
|
|
bytesReq = 4;
|
|
curr_op_address = m_instr_info.instr_addr; // save the start address for the current opcode
|
|
err = accessMemory(m_instr_info.instr_addr,mem_space,&bytesReq,(uint8_t *)&opcode);
|
|
if(err != OCSD_OK) break;
|
|
|
|
if(bytesReq == 4) // got data back
|
|
{
|
|
m_instr_info.opcode = opcode;
|
|
err = instrDecode(&m_instr_info);
|
|
if(err != OCSD_OK) break;
|
|
|
|
// increment address - may be adjusted by direct branch value later
|
|
m_instr_info.instr_addr += m_instr_info.instr_size;
|
|
|
|
// update the range decoded address in the output packet.
|
|
m_output_elem.en_addr = m_instr_info.instr_addr;
|
|
m_output_elem.num_instr_range++;
|
|
|
|
m_output_elem.last_i_type = m_instr_info.type;
|
|
// either walking to match the next instruction address or a real waypoint
|
|
if(traceWPOp != TRACE_WAYPOINT)
|
|
{
|
|
if(traceWPOp == TRACE_TO_ADDR_EXCL)
|
|
bWPFound = (m_output_elem.en_addr == nextAddrMatch);
|
|
else
|
|
bWPFound = (curr_op_address == nextAddrMatch);
|
|
}
|
|
else
|
|
bWPFound = (m_instr_info.type != OCSD_INSTR_OTHER);
|
|
}
|
|
else
|
|
{
|
|
// not enough memory accessible.
|
|
m_mem_nacc_pending = true;
|
|
m_nacc_addr = m_instr_info.instr_addr;
|
|
}
|
|
}
|
|
return err;
|
|
}
|
|
|
|
/* End of File trc_pkt_decode_ptm.cpp */
|