OpenCSD - CoreSight Trace Decode Library  0.12.1
trc_pkt_elem_etmv4i.h
Go to the documentation of this file.
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"
42 
56 {
57 public:
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  }
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];
92  uint8_t m_v_addr_ISA[3];
93 };
94 
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();
115  void initNextPacket();
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();
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 
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 
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 
523 #endif // ARM_TRC_PKT_ELEM_ETMV4I_H_INCLUDED
524 
525 /* End of File trc_pkt_elem_etmv4i.h */
const ocsd_vaddr_t & getAddrVal() const
virtual const void * c_pkt() const
return the underlying C API packet structure
void setDataSyncMarker(const uint8_t dsm_val)
ocsd_vaddr_t val
Definition: trc_pkt_types.h:61
const uint32_t getCC() const
const bool hasCommitElementsCount() const
return true if this packet has set the commit packet count.
void setAtomPacket(const ocsd_pkt_atm_type type, const uint32_t En_bits, const uint8_t num)
const etmv4_trace_info_t & getTraceInfo() const
const uint32_t getCurrSpecDepth() const
void set32BitAddress(const uint32_t addr, const uint8_t IS)
void setCommitElements(const uint32_t commit_elem)
void get_idx(const uint8_t idx, ocsd_pkt_vaddr &vaddr, uint8_t &isa)
const uint64_t getTS() const
uint64_t ocsd_vaddr_t
const uint32_t getCCThreshold() const
void setCondRF2(const uint8_t key_incr, const uint8_t token)
void setTraceInfoCyct(const uint32_t cyctVal)
const bool isBadPacket() const
enum _ocsd_etmv4_i_pkt_type ocsd_etmv4_i_pkt_type
ocsd_pkt_va_size size
Definition: trc_pkt_types.h:60
OpenCSD : Standard printable element base class.
void setTraceInfoKey(const uint32_t keyVal)
void setCondIF1(uint32_t const cond_key)
const bool getAddr64Bit() const
const ocsd_etmv4_i_pkt_type getType() const
void setTraceInfoSpec(const uint32_t specVal)
void setContextInfo(const bool update, const uint8_t EL=0, const uint8_t NS=0, const uint8_t SF=0)
ETMv4 Address packet values stackThis class represents a stack of recent broadcast address values - u...
void setCondRF3(const uint16_t tokens)
void updateErrType(const ocsd_etmv4_i_pkt_type err_pkt_type, const uint8_t val=0)
void setExceptionInfo(const uint16_t excep_type, const uint8_t addr_interp, const uint8_t m_fault_pending, const uint8_t m_type)
uint8_t valid_bits
Definition: trc_pkt_types.h:63
void setCycleCount(const uint32_t value)
void setAddressExactMatch(const uint8_t idx)
const ocsd_pkt_atom & getAtom() const
void setCondRF4(const uint8_t token)
void setCondIF3(uint8_t const num_c_elem, const bool finalElem)
void setTraceInfo(const uint32_t infoVal)
void updateShortAddress(const uint32_t addr, const uint8_t IS, const uint8_t update_bits)
void clearTraceInfo()
clear all the trace info data prior to setting for new trace info packet.
void setType(const ocsd_etmv4_i_pkt_type pkt_type)
void set64BitAddress(const uint64_t addr, const uint8_t IS)
enum _ocsd_pkt_atm_type ocsd_pkt_atm_type
Class to provide trace element strings for printing.
const uint32_t getP0Key() const
const uint8_t & getAddrMatch() const
void setContextVMID(const uint32_t VMID)
void setQType(const bool has_count, const uint32_t count, const bool has_addr, const bool addr_match, const uint8_t type)
void setCondRF1(const uint32_t key[2], const uint8_t res[2], const uint8_t CI[2], const bool set2Keys)
#define OCSD_BIT_MASK(bits)
void setCondIF2(uint8_t const c_elem_idx)
ETMv4 Instuction Trace Protocol Packet.This class represents a single ETMv4 data trace packet...
const etmv4_context_t & getContext() const
const ocsd_etmv4_i_pkt_type getErrType() const
void setCancelElements(const uint32_t cancel_elem)
void setEvent(const uint8_t event_val)
const uint8_t & getAddrIS() const
void setTS(const uint64_t value, const uint8_t bits)
void setContextCID(const uint32_t CID)
void push(const ocsd_pkt_vaddr vaddr, const uint8_t isa)