contrib/opencsd/decoder/include/opencsd/etmv4/trc_pkt_elem_etmv4i.h

   1 /*
   2  * \file       trc_pkt_elem_etmv4i.h
   3  * \brief      OpenCSD :
   4  *
   5  * \copyright  Copyright (c) 2015, ARM Limited. All Rights Reserved.
   6  */
   7
   8
   9 /*
  10  * Redistribution and use in source and binary forms, with or without modification,
  11  * are permitted provided that the following conditions are met:
  12  *
  13  * 1. Redistributions of source code must retain the above copyright notice,
  14  * this list of conditions and the following disclaimer.
  15  *
  16  * 2. Redistributions in binary form must reproduce the above copyright notice,
  17  * this list of conditions and the following disclaimer in the documentation
  18  * and/or other materials provided with the distribution.
  19  *
  20  * 3. Neither the name of the copyright holder nor the names of its contributors
  21  * may be used to endorse or promote products derived from this software without
  22  * specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  26  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  27  * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  28  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  29  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  30  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  31  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  32  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  33  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34  */
  35
  36 #ifndef ARM_TRC_PKT_ELEM_ETMV4I_H_INCLUDED
  37 #define ARM_TRC_PKT_ELEM_ETMV4I_H_INCLUDED
  38
  39 #include "trc_pkt_types_etmv4.h"
  40 #include "common/trc_printable_elem.h"
  41 #include "common/trc_pkt_elem_base.h"
  42
  43 /** @addtogroup trc_pkts
  44 @{*/
  45
  46 /*!
  47 * @class Etmv4PktAddrStack
  48 * @brief ETMv4 Address packet values stack
  49 * @ingroup trc_pkts
  50 *
  51 *  This class represents a stack of recent broadcast address values -
  52 *  used to fulfil the ExactMatch address type where no address is output.
  53 *
  54 */
  55 class Etmv4PktAddrStack
  56 {
  57 public:
  58     Etmv4PktAddrStack()
  59     {
  60         for (int i = 0; i < 3; i++)
  61         {
  62             m_v_addr[i].pkt_bits = 0;
  63             m_v_addr[i].size = VA_64BIT;
  64             m_v_addr[i].val = 0;
  65             m_v_addr[i].valid_bits = 0;
  66             m_v_addr_ISA[i] = 0;
  67         }
  68     }
  69     ~Etmv4PktAddrStack() {};
  70
  71     void push(const ocsd_pkt_vaddr vaddr, const uint8_t isa)
  72     {
  73         m_v_addr[2] = m_v_addr[1];
  74         m_v_addr[1] = m_v_addr[0];
  75         m_v_addr[0] = vaddr;
  76         m_v_addr_ISA[2] = m_v_addr_ISA[1];
  77         m_v_addr_ISA[1] = m_v_addr_ISA[0];
  78         m_v_addr_ISA[0] = isa;
  79     }
  80
  81     void get_idx(const uint8_t idx, ocsd_pkt_vaddr &vaddr, uint8_t &isa)
  82     {
  83         if (idx < 3)
  84         {
  85             vaddr = m_v_addr[idx];
  86             isa = m_v_addr_ISA[idx];
  87         }
  88     }
  89
  90 private:
  91     ocsd_pkt_vaddr m_v_addr[3];         //!< most recently broadcast address packet
  92     uint8_t        m_v_addr_ISA[3];
  93 };
  94
  95 /*!
  96  * @class EtmV4ITrcPacket
  97  * @brief ETMv4 Instuction Trace Protocol Packet.
  98  * @ingroup trc_pkts
  99  *
 100  *  This class represents a single ETMv4 data trace packet, along with intra packet state.
 101  *
 102  */
 103 class EtmV4ITrcPacket :  public TrcPacketBase, public ocsd_etmv4_i_pkt, public trcPrintableElem
 104 {
 105 public:
 106     EtmV4ITrcPacket();
 107     ~EtmV4ITrcPacket();
 108
 109     EtmV4ITrcPacket &operator =(const ocsd_etmv4_i_pkt* p_pkt);
 110
 111     virtual const void *c_pkt() const { return (const ocsd_etmv4_i_pkt *)this; };
 112
 113     // update interface - set packet values
 114     void initStartState();   //!< Set to initial state - no intra packet state valid. Use on start of trace / discontinuities.
 115     void initNextPacket();  //!< clear any single packet only flags / state.
 116
 117     void setType(const ocsd_etmv4_i_pkt_type pkt_type) { type = pkt_type; };
 118     void updateErrType(const ocsd_etmv4_i_pkt_type err_pkt_type, const uint8_t val = 0);
 119
 120     void clearTraceInfo();  //!< clear all the trace info data prior to setting for new trace info packet.
 121     void setTraceInfo(const uint32_t infoVal);
 122     void setTraceInfoKey(const uint32_t keyVal);
 123     void setTraceInfoSpec(const uint32_t specVal);
 124     void setTraceInfoCyct(const uint32_t cyctVal);
 125
 126     void setTS(const uint64_t value, const uint8_t bits);
 127     void setCycleCount(const uint32_t value);
 128     void setCommitElements(const uint32_t commit_elem);
 129     void setCancelElements(const uint32_t cancel_elem);
 130     void setAtomPacket(const ocsd_pkt_atm_type type, const uint32_t En_bits, const uint8_t num);
 131
 132     void setCondIF1(uint32_t const cond_key);
 133     void setCondIF2(uint8_t const c_elem_idx);
 134     void setCondIF3(uint8_t const num_c_elem, const bool finalElem);
 135
 136     void setCondRF1(const uint32_t key[2], const uint8_t res[2], const uint8_t CI[2], const bool set2Keys);
 137     void setCondRF2(const uint8_t key_incr, const uint8_t token);
 138     void setCondRF3(const uint16_t tokens);
 139     void setCondRF4(const uint8_t token);
 140
 141     void setContextInfo(const bool update, const uint8_t EL = 0, const uint8_t NS = 0, const uint8_t SF = 0);
 142     void setContextVMID(const uint32_t VMID);
 143     void setContextCID(const uint32_t CID);
 144
 145     void setExceptionInfo(const uint16_t excep_type, const uint8_t addr_interp, const uint8_t m_fault_pending, const uint8_t m_type);
 146
 147     void set64BitAddress(const uint64_t addr, const uint8_t IS);
 148     void set32BitAddress(const uint32_t addr, const uint8_t IS);
 149     void updateShortAddress(const uint32_t addr, const uint8_t IS, const uint8_t update_bits);
 150     void setAddressExactMatch(const uint8_t idx);
 151
 152     void setDataSyncMarker(const uint8_t dsm_val);
 153     void setEvent(const uint8_t event_val);
 154
 155     void setQType(const bool has_count, const uint32_t count, const bool has_addr, const bool addr_match, const uint8_t type);
 156
 157     // packet status interface - get packet info.
 158     const ocsd_etmv4_i_pkt_type getType() const { return type; };
 159     const ocsd_etmv4_i_pkt_type getErrType() const { return err_type; };
 160
 161     //! return true if this packet has set the commit packet count.
 162     const bool hasCommitElementsCount() const
 163     {
 164         return pkt_valid.bits.commit_elem_valid ? true : false;
 165     };
 166
 167     // trace info
 168     const etmv4_trace_info_t &getTraceInfo() const { return trace_info; };
 169     const uint32_t getCCThreshold() const;
 170     const uint32_t getP0Key() const;
 171     const uint32_t getCurrSpecDepth() const;
 172
 173     // atom
 174     const ocsd_pkt_atom &getAtom() const { return atom; };
 175
 176     // context
 177     const etmv4_context_t &getContext() const { return context; };
 178
 179     // address
 180     const uint8_t &getAddrMatch() const  { return addr_exact_match_idx; };
 181     const ocsd_vaddr_t &getAddrVal() const { return v_addr.val; };
 182     const uint8_t &getAddrIS() const { return v_addr_ISA; };
 183     const bool getAddr64Bit() const { return v_addr.size == VA_64BIT; };
 184
 185     // ts
 186     const uint64_t getTS() const { return pkt_valid.bits.ts_valid ? ts.timestamp : 0; };
 187
 188     // cc
 189     const uint32_t getCC() const { return pkt_valid.bits.cc_valid ? cycle_count : 0; };
 190
 191     // packet type
 192     const bool isBadPacket() const;
 193
 194     // printing
 195     virtual void toString(std::string &str) const;
 196     virtual void toStringFmt(const uint32_t fmtFlags, std::string &str) const;
 197
 198 private:
 199     const char *packetTypeName(const ocsd_etmv4_i_pkt_type type, const char **pDesc) const;
 200     void contextStr(std::string &ctxtStr) const;
 201     void atomSeq(std::string &valStr) const;
 202     void addrMatchIdx(std::string &valStr) const;
 203     void exceptionInfo(std::string &valStr) const;
 204
 205     void push_vaddr();
 206     void pop_vaddr_idx(const uint8_t idx);
 207
 208     Etmv4PktAddrStack m_addr_stack;
 209 };
 210
 211 inline void  EtmV4ITrcPacket::updateErrType(const ocsd_etmv4_i_pkt_type err_pkt_type, const uint8_t err_val /* = 0 */)
 212 {
 213     // set primary type to incoming error type, set packet err type to previous primary type.
 214     err_type = type;
 215     type = err_pkt_type;
 216     err_hdr_val = err_val;
 217 }
 218
 219 inline void EtmV4ITrcPacket::clearTraceInfo()
 220 {
 221     pkt_valid.bits.ts_valid = 0;
 222     pkt_valid.bits.trace_info_valid = 0;
 223     pkt_valid.bits.p0_key_valid = 0;
 224     pkt_valid.bits.spec_depth_valid = 0;
 225     pkt_valid.bits.cc_thresh_valid  = 0;
 226
 227     // set these as defaults - if they don't appear in TINFO this is the state.
 228     setTraceInfo(0);
 229     setTraceInfoSpec(0);
 230 }
 231
 232 inline void EtmV4ITrcPacket::setTraceInfo(const uint32_t infoVal)
 233 {
 234     trace_info.val = infoVal;
 235     pkt_valid.bits.trace_info_valid = 1;
 236 }
 237
 238 inline void EtmV4ITrcPacket::setTraceInfoKey(const uint32_t keyVal)
 239 {
 240     p0_key = keyVal;
 241     pkt_valid.bits.p0_key_valid = 1;
 242 }
 243
 244 inline void EtmV4ITrcPacket::setTraceInfoSpec(const uint32_t specVal)
 245 {
 246     curr_spec_depth = specVal;
 247     pkt_valid.bits.spec_depth_valid = 1;
 248 }
 249
 250 inline void EtmV4ITrcPacket::setTraceInfoCyct(const uint32_t cyctVal)
 251 {
 252     cc_threshold = cyctVal;
 253     pkt_valid.bits.cc_thresh_valid  = 1;
 254 }
 255
 256 inline void EtmV4ITrcPacket::setTS(const uint64_t value, const uint8_t bits)
 257 {
 258     uint64_t mask = (uint64_t)-1LL;
 259     if(bits < 64) mask = (1ULL << bits) - 1;
 260     ts.timestamp = (ts.timestamp & ~mask) | (value & mask);
 261     ts.bits_changed = bits;
 262     pkt_valid.bits.ts_valid = 1;
 263 }
 264
 265 inline void EtmV4ITrcPacket::setCycleCount(const uint32_t value)
 266 {
 267     pkt_valid.bits.cc_valid = 1;
 268     cycle_count = value;
 269 }
 270
 271 inline void EtmV4ITrcPacket::setCommitElements(const uint32_t commit_elem)
 272 {
 273     pkt_valid.bits.commit_elem_valid = 1;
 274     commit_elements = commit_elem;
 275 }
 276
 277 inline const uint32_t EtmV4ITrcPacket::getCCThreshold() const
 278 {
 279     if(pkt_valid.bits.cc_thresh_valid)
 280         return cc_threshold;
 281     return 0;
 282 }
 283
 284 inline const uint32_t EtmV4ITrcPacket::getP0Key() const
 285 {
 286     if(pkt_valid.bits.p0_key_valid)
 287         return p0_key;
 288     return 0;
 289 }
 290
 291 inline const uint32_t EtmV4ITrcPacket::getCurrSpecDepth() const
 292 {
 293     if(pkt_valid.bits.spec_depth_valid)
 294         return curr_spec_depth;
 295     return 0;
 296 }
 297
 298 inline void EtmV4ITrcPacket::setCancelElements(const uint32_t cancel_elem)
 299 {
 300     cancel_elements = cancel_elem;
 301 }
 302
 303 inline void EtmV4ITrcPacket::setAtomPacket(const ocsd_pkt_atm_type type, const uint32_t En_bits, const uint8_t num)
 304 {
 305     if(type == ATOM_REPEAT)
 306     {
 307         uint32_t bit_patt = En_bits & 0x1;
 308         if(bit_patt)
 309         {
 310             // none zero - all 1s
 311             bit_patt = (bit_patt << num) - 1;
 312         }
 313         atom.En_bits = bit_patt;
 314     }
 315     else
 316         atom.En_bits = En_bits;
 317     atom.num = num;
 318 }
 319
 320 inline void EtmV4ITrcPacket::setCondIF1(const uint32_t cond_key)
 321 {
 322     cond_instr.cond_key_set = 1;
 323     cond_instr.f3_final_elem = 0;
 324     cond_instr.f2_cond_incr = 0;
 325     cond_instr.num_c_elem = 1;
 326     cond_instr.cond_c_key = cond_key;
 327 }
 328
 329 inline void EtmV4ITrcPacket::setCondIF2(const uint8_t c_elem_idx)
 330 {
 331     cond_instr.cond_key_set = 0;
 332     cond_instr.f3_final_elem = 0;
 333     switch(c_elem_idx & 0x3)
 334     {
 335     case 0:
 336         cond_instr.f2_cond_incr = 1;
 337         cond_instr.num_c_elem = 1;
 338         break;
 339
 340     case 1:
 341         cond_instr.f2_cond_incr = 0;
 342         cond_instr.num_c_elem = 1;
 343         break;
 344
 345     case 2:
 346         cond_instr.f2_cond_incr = 1;
 347         cond_instr.num_c_elem = 2;
 348         break;
 349     }
 350 }
 351
 352 inline void EtmV4ITrcPacket::setCondIF3(const uint8_t num_c_elem, const bool finalElem)
 353 {
 354     cond_instr.cond_key_set = 0;
 355     cond_instr.f3_final_elem = finalElem ? 1: 0;
 356     cond_instr.f2_cond_incr = 0;
 357     cond_instr.num_c_elem = num_c_elem;
 358 }
 359
 360 inline void EtmV4ITrcPacket::setCondRF1(const uint32_t key[2], const uint8_t res[2], const uint8_t CI[2],const bool set2Keys)
 361 {
 362     cond_result.key_res_0_set = 1;
 363     cond_result.cond_r_key_0 = key[0];
 364     cond_result.res_0 = res[0];
 365     cond_result.ci_0 = CI[0];
 366
 367     if(set2Keys)
 368     {
 369         cond_result.key_res_1_set = 1;
 370         cond_result.cond_r_key_1 = key[1];
 371         cond_result.res_1 = res[1];
 372         cond_result.ci_1 = CI[1];
 373     }
 374 }
 375
 376
 377 inline void EtmV4ITrcPacket::setCondRF2(const uint8_t key_incr, const uint8_t token)
 378 {
 379     cond_result.key_res_0_set = 0;
 380     cond_result.key_res_1_set = 0;
 381     cond_result.f2_key_incr = key_incr;
 382     cond_result.f2f4_token = token;
 383 }
 384
 385 inline void EtmV4ITrcPacket::setCondRF3(const uint16_t tokens)
 386 {
 387     cond_result.key_res_0_set = 0;
 388     cond_result.key_res_1_set = 0;
 389     cond_result.f3_tokens = tokens;
 390 }
 391
 392 inline void EtmV4ITrcPacket::setCondRF4(const uint8_t token)
 393 {
 394     cond_result.key_res_0_set = 0;
 395     cond_result.key_res_1_set = 0;
 396     cond_result.f2f4_token = token;
 397 }
 398
 399 inline void EtmV4ITrcPacket::setContextInfo(const bool update, const uint8_t EL, const uint8_t NS, const uint8_t SF)
 400 {
 401     pkt_valid.bits.context_valid = 1;
 402     if(update)
 403     {
 404         context.updated = 1;
 405         context.EL = EL;
 406         context.NS = NS;
 407         context.SF = SF;
 408     }
 409 }
 410
 411 inline void EtmV4ITrcPacket::setContextVMID(const uint32_t VMID)
 412 {
 413     pkt_valid.bits.context_valid = 1;
 414     context.updated = 1;
 415     context.VMID = VMID;
 416     context.updated_v = 1;
 417 }
 418
 419 inline void EtmV4ITrcPacket::setContextCID(const uint32_t CID)
 420 {
 421     pkt_valid.bits.context_valid = 1;
 422     context.updated = 1;
 423     context.ctxtID = CID;
 424     context.updated_c = 1;
 425 }
 426
 427 inline void EtmV4ITrcPacket::setExceptionInfo(const uint16_t excep_type, const uint8_t addr_interp, const uint8_t m_fault_pending, const uint8_t m_type)
 428 {
 429     exception_info.exceptionType = excep_type;
 430     exception_info.addr_interp = addr_interp;
 431     exception_info.m_fault_pending = m_fault_pending;
 432     exception_info.m_type = m_type;
 433 }
 434
 435 inline void EtmV4ITrcPacket::set64BitAddress(const uint64_t addr, const uint8_t IS)
 436 {
 437     v_addr.pkt_bits = 64;
 438     v_addr.valid_bits = 64;
 439     v_addr.size = VA_64BIT;
 440     v_addr.val = addr;
 441     v_addr_ISA = IS;
 442     push_vaddr();
 443 }
 444
 445 inline void EtmV4ITrcPacket::set32BitAddress(const uint32_t addr, const uint8_t IS)
 446 {
 447     uint64_t mask = OCSD_BIT_MASK(32);
 448     v_addr.pkt_bits = 32;
 449
 450         if (pkt_valid.bits.context_valid && context.SF)
 451         {
 452                 v_addr.size = VA_64BIT;
 453                 if (v_addr.valid_bits < 32) // may be updating a 64 bit address so only set 32 if currently less.
 454                         v_addr.valid_bits = 32;
 455                 v_addr.val = (v_addr.val & ~mask) | (addr & mask);
 456         }
 457     else
 458     {
 459                 v_addr.val = addr;
 460         v_addr.size = VA_32BIT;
 461                 v_addr.valid_bits = 32;
 462         }
 463
 464     v_addr_ISA = IS;
 465     push_vaddr();
 466 }
 467
 468 inline void EtmV4ITrcPacket::updateShortAddress(const uint32_t addr, const uint8_t IS, const uint8_t update_bits)
 469 {
 470     ocsd_vaddr_t update_mask = OCSD_BIT_MASK(update_bits);
 471     v_addr.pkt_bits = update_bits;
 472     if(v_addr.valid_bits < update_bits)
 473         v_addr.valid_bits = update_bits;
 474
 475     v_addr.val = (v_addr.val & ~update_mask) | (addr & update_mask);
 476     v_addr_ISA = IS;
 477     push_vaddr();
 478 }
 479
 480 inline void EtmV4ITrcPacket::setAddressExactMatch(const uint8_t idx)
 481 {
 482     addr_exact_match_idx = idx;
 483     pop_vaddr_idx(idx);
 484     push_vaddr();
 485 }
 486
 487 inline void EtmV4ITrcPacket::setDataSyncMarker(const uint8_t dsm_value)
 488 {
 489     dsm_val = dsm_value;
 490 }
 491
 492 inline void EtmV4ITrcPacket::setEvent(const uint8_t event_value)
 493 {
 494     event_val = event_value;
 495 }
 496
 497 inline void EtmV4ITrcPacket::setQType(const bool has_count, const uint32_t count, const bool has_addr, const bool addr_match, const uint8_t type)
 498 {
 499     Q_pkt.q_count = count;
 500     Q_pkt.q_type = type;
 501     Q_pkt.count_present = has_count ? 1 : 0;
 502     Q_pkt.addr_present = has_addr ? 1: 0;
 503     Q_pkt.addr_match = addr_match ? 1 :0;
 504 }
 505
 506 inline const bool EtmV4ITrcPacket::isBadPacket() const
 507 {
 508     return (type >= ETM4_PKT_I_BAD_SEQUENCE);
 509 }
 510
 511 inline void  EtmV4ITrcPacket::push_vaddr()
 512 {
 513     m_addr_stack.push(v_addr, v_addr_ISA);
 514 }
 515
 516 inline void EtmV4ITrcPacket::pop_vaddr_idx(const uint8_t idx)
 517 {
 518     m_addr_stack.get_idx(idx, v_addr, v_addr_ISA);
 519 }
 520
 521 /** @}*/
 522
 523 #endif // ARM_TRC_PKT_ELEM_ETMV4I_H_INCLUDED
 524
 525 /* End of File trc_pkt_elem_etmv4i.h */