1 /* 2 * \file trc_pkt_elem_etmv3.cpp 3 * \brief OpenCSD : 4 * 5 * \copyright Copyright (c) 2015, ARM Limited. All Rights Reserved. 6 */ 7 8 /* 9 * Redistribution and use in source and binary forms, with or without modification, 10 * are permitted provided that the following conditions are met: 11 * 12 * 1. Redistributions of source code must retain the above copyright notice, 13 * this list of conditions and the following disclaimer. 14 * 15 * 2. Redistributions in binary form must reproduce the above copyright notice, 16 * this list of conditions and the following disclaimer in the documentation 17 * and/or other materials provided with the distribution. 18 * 19 * 3. Neither the name of the copyright holder nor the names of its contributors 20 * may be used to endorse or promote products derived from this software without 21 * specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND 24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 25 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 26 * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 27 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 28 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 29 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 30 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 32 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 33 */ 34 35 #include <cstring> 36 #include <sstream> 37 #include <iomanip> 38 39 #include "opencsd/etmv3/trc_pkt_elem_etmv3.h" 40 41 EtmV3TrcPacket::EtmV3TrcPacket() 42 { 43 m_pkt_data.addr.size = VA_32BIT; // etm v3 only handles 32 bit addresses. 44 } 45 46 EtmV3TrcPacket::~EtmV3TrcPacket() 47 { 48 } 49 50 // update interface - set packet values 51 52 // clear this packet info 53 void EtmV3TrcPacket::Clear() 54 { 55 // clear structure flags and counter elements etc, that work per packet. 56 // leave intra packet data unchanged 57 m_pkt_data.addr.pkt_bits = 0; 58 m_pkt_data.prev_isa = m_pkt_data.curr_isa; // mark ISA as not changed 59 m_pkt_data.exception.bits.present = 0; 60 m_pkt_data.atom.num = 0; 61 m_pkt_data.cycle_count = 0; 62 m_pkt_data.context.updated = 0; 63 m_pkt_data.context.updated_c = 0; 64 m_pkt_data.context.updated_v = 0; 65 m_pkt_data.data.ooo_tag = 0; 66 m_pkt_data.data.value = 0; 67 m_pkt_data.data.update_addr = 0; 68 m_pkt_data.data.update_be = 0; 69 m_pkt_data.data.update_dval = 0; 70 m_pkt_data.ts_update_bits = 0; 71 m_pkt_data.isync_info.has_cycle_count = 0; 72 m_pkt_data.isync_info.has_LSipAddress = 0; 73 m_pkt_data.isync_info.no_address = 0; 74 } 75 76 // reset all state including intra packet 77 void EtmV3TrcPacket::ResetState() 78 { 79 memset(&m_pkt_data,0,sizeof(ocsd_etmv3_pkt)); 80 m_pkt_data.curr_isa = m_pkt_data.prev_isa = ocsd_isa_unknown; 81 } 82 83 void EtmV3TrcPacket::UpdateAddress(const ocsd_vaddr_t partAddrVal, const int updateBits) 84 { 85 ocsd_vaddr_t validMask = OCSD_VA_MASK; 86 validMask >>= OCSD_MAX_VA_BITSIZE-updateBits; 87 m_pkt_data.addr.pkt_bits = updateBits; 88 m_pkt_data.addr.val &= ~validMask; 89 m_pkt_data.addr.val |= (partAddrVal & validMask); 90 if(updateBits > m_pkt_data.addr.valid_bits) 91 m_pkt_data.addr.valid_bits = updateBits; 92 } 93 94 void EtmV3TrcPacket::UpdateDataAddress(const uint32_t value, const uint8_t valid_bits) 95 { 96 // ETMv3 data addresses 32 bits. 97 uint32_t validMask = 0xFFFFFFFF; 98 validMask >>= 32-valid_bits; 99 m_pkt_data.addr.pkt_bits = valid_bits; 100 m_pkt_data.addr.val &= ~validMask; 101 m_pkt_data.addr.val |= (value & validMask); 102 if(valid_bits > m_pkt_data.addr.valid_bits) 103 m_pkt_data.addr.valid_bits = valid_bits; 104 m_pkt_data.data.update_addr = 1; 105 } 106 107 void EtmV3TrcPacket::UpdateTimestamp(const uint64_t tsVal, const uint8_t updateBits) 108 { 109 uint64_t validMask = ~0ULL; 110 validMask >>= 64-updateBits; 111 m_pkt_data.timestamp &= ~validMask; 112 m_pkt_data.timestamp |= (tsVal & validMask); 113 m_pkt_data.ts_update_bits = updateBits; 114 } 115 116 117 118 void EtmV3TrcPacket::SetException( const ocsd_armv7_exception type, 119 const uint16_t number, 120 const bool cancel, 121 const bool cm_type, 122 const int irq_n /*= 0*/, 123 const int resume /* = 0*/) 124 { 125 // initial data 126 m_pkt_data.exception.bits.cancel = cancel ? 1 : 0; 127 m_pkt_data.exception.bits.cm_irq_n = irq_n; 128 m_pkt_data.exception.bits.cm_resume = resume; 129 m_pkt_data.exception.bits.cm_type = cm_type ? 1 : 0; 130 m_pkt_data.exception.number = number; 131 m_pkt_data.exception.type = type; 132 133 // mark as valid in this packet 134 m_pkt_data.exception.bits.present = 1; 135 } 136 137 bool EtmV3TrcPacket::UpdateAtomFromPHdr(const uint8_t pHdr, const bool cycleAccurate) 138 { 139 bool bValid = true; 140 uint8_t E = 0, N = 0; 141 if(!cycleAccurate) 142 { 143 if((pHdr & 0x3) == 0x0) 144 { 145 E = ((pHdr >> 2) & 0xF); 146 N = (pHdr & 0x40) ? 1 : 0; 147 m_pkt_data.atom.num = E+N; 148 m_pkt_data.atom.En_bits = (((uint32_t)0x1) << E) - 1; 149 m_pkt_data.p_hdr_fmt = 1; 150 } 151 else if((pHdr & 0x3) == 0x2) 152 { 153 m_pkt_data.atom.num = 2; 154 m_pkt_data.p_hdr_fmt = 2; 155 m_pkt_data.atom.En_bits = (pHdr & 0x8 ? 0 : 1) | (pHdr & 0x4 ? 0 : 0x2); 156 } 157 else 158 bValid = false; 159 } 160 else 161 { 162 uint8_t pHdr_code = pHdr & 0xA3; 163 switch(pHdr_code) 164 { 165 case 0x80: 166 m_pkt_data.p_hdr_fmt = 1; 167 E = ((pHdr >> 2) & 0x7); 168 N = (pHdr & 0x40) ? 1 : 0; 169 m_pkt_data.atom.num = E+N; 170 if(m_pkt_data.atom.num) 171 { 172 m_pkt_data.atom.En_bits = (((uint32_t)0x1) << E) - 1; 173 m_pkt_data.cycle_count = E+N; 174 } 175 else 176 bValid = false; // deprecated 8b'10000000 code 177 178 break; 179 180 case 0x82: 181 m_pkt_data.p_hdr_fmt = 2; 182 if(pHdr & 0x10) 183 { 184 m_pkt_data.p_hdr_fmt = 4; 185 m_pkt_data.atom.num = 1; 186 m_pkt_data.cycle_count = 0; 187 m_pkt_data.atom.En_bits = pHdr & 0x04 ? 0 : 1; 188 } 189 else 190 { 191 m_pkt_data.atom.num = 2; 192 m_pkt_data.cycle_count = 1; 193 m_pkt_data.atom.En_bits = (pHdr & 0x8 ? 0 : 1) | (pHdr & 0x4 ? 0 : 0x2); 194 } 195 break; 196 197 case 0xA0: 198 m_pkt_data.p_hdr_fmt = 3; 199 m_pkt_data.cycle_count = ((pHdr >> 2) & 7) + 1; 200 E = pHdr & 0x40 ? 1 : 0; 201 m_pkt_data.atom.num = E; 202 m_pkt_data.atom.En_bits = E; 203 break; 204 205 default: 206 bValid = false; 207 break; 208 209 } 210 } 211 return bValid; 212 } 213 214 EtmV3TrcPacket &EtmV3TrcPacket::operator =(const ocsd_etmv3_pkt* p_pkt) 215 { 216 m_pkt_data = *p_pkt; 217 return *this; 218 } 219 220 // printing 221 void EtmV3TrcPacket::toString(std::string &str) const 222 { 223 const char *name; 224 const char *desc; 225 std::string valStr, ctxtStr = ""; 226 227 name = packetTypeName(m_pkt_data.type, &desc); 228 str = name + (std::string)" : " + desc; 229 230 switch(m_pkt_data.type) 231 { 232 // print the original header type for the bad sequences. 233 case ETM3_PKT_BAD_SEQUENCE: 234 case ETM3_PKT_BAD_TRACEMODE: 235 name = packetTypeName(m_pkt_data.err_type,0); 236 str += "[" + (std::string)name + "]"; 237 break; 238 239 case ETM3_PKT_BRANCH_ADDRESS: 240 getBranchAddressStr(valStr); 241 str += "; " + valStr; 242 break; 243 244 case ETM3_PKT_I_SYNC_CYCLE: 245 case ETM3_PKT_I_SYNC: 246 getISyncStr(valStr); 247 str += "; " + valStr; 248 break; 249 250 case ETM3_PKT_P_HDR: 251 getAtomStr(valStr); 252 str += "; " + valStr; 253 break; 254 255 case ETM3_PKT_CYCLE_COUNT: 256 { 257 std::ostringstream oss; 258 oss << "; Cycles=" << m_pkt_data.cycle_count; 259 str += oss.str(); 260 } 261 break; 262 263 case ETM3_PKT_CONTEXT_ID: 264 { 265 std::ostringstream oss; 266 oss << "; CtxtID=" << std::hex << "0x" << m_pkt_data.context.ctxtID; 267 str += oss.str(); 268 } 269 break; 270 271 case ETM3_PKT_VMID: 272 { 273 std::ostringstream oss; 274 oss << "; VMID=" << std::hex << "0x" << m_pkt_data.context.VMID; 275 str += oss.str(); 276 } 277 break; 278 279 case ETM3_PKT_TIMESTAMP: 280 { 281 std::ostringstream oss; 282 oss << "; TS=" << std::hex << "0x" << m_pkt_data.timestamp << " (" << std::dec << m_pkt_data.timestamp << ") "; 283 str += oss.str(); 284 } 285 break; 286 287 case ETM3_PKT_OOO_DATA: 288 { 289 std::ostringstream oss; 290 oss << "; Val=" << std::hex << "0x" << m_pkt_data.data.value; 291 oss << "; OO_Tag=" << std::hex << "0x" << m_pkt_data.data.ooo_tag; 292 str += oss.str(); 293 } 294 break; 295 296 case ETM3_PKT_VAL_NOT_TRACED: 297 if(m_pkt_data.data.update_addr) 298 { 299 trcPrintableElem::getValStr(valStr,32, m_pkt_data.data.addr.valid_bits, 300 m_pkt_data.data.addr.val,true,m_pkt_data.data.addr.pkt_bits); 301 str += "; Addr=" + valStr; 302 } 303 break; 304 305 case ETM3_PKT_OOO_ADDR_PLC: 306 if(m_pkt_data.data.update_addr) 307 { 308 trcPrintableElem::getValStr(valStr,32, m_pkt_data.data.addr.valid_bits, 309 m_pkt_data.data.addr.val,true,m_pkt_data.data.addr.pkt_bits); 310 str += "; Addr=" + valStr; 311 } 312 { 313 std::ostringstream oss; 314 oss << "; OO_Tag=" << std::hex << "0x" << m_pkt_data.data.ooo_tag; 315 str += oss.str(); 316 } 317 break; 318 319 case ETM3_PKT_NORM_DATA: 320 if(m_pkt_data.data.update_addr) 321 { 322 trcPrintableElem::getValStr(valStr,32, m_pkt_data.data.addr.valid_bits, 323 m_pkt_data.data.addr.val,true,m_pkt_data.data.addr.pkt_bits); 324 str += "; Addr=" + valStr; 325 } 326 if(m_pkt_data.data.update_dval) 327 { 328 std::ostringstream oss; 329 oss << "; Val=" << std::hex << "0x" << m_pkt_data.data.value; 330 str += oss.str(); 331 } 332 break; 333 } 334 } 335 336 void EtmV3TrcPacket::toStringFmt(const uint32_t fmtFlags, std::string &str) const 337 { 338 // no formatting implemented at present. 339 toString(str); 340 } 341 342 const char *EtmV3TrcPacket::packetTypeName(const ocsd_etmv3_pkt_type type, const char **ppDesc) const 343 { 344 const char *pName = "I_RESERVED"; 345 const char *pDesc = "Reserved Packet Header"; 346 347 switch(type) 348 { 349 // markers for unknown packets 350 // case ETM3_PKT_NOERROR:, //!< no error in packet - supplimentary data. 351 case ETM3_PKT_NOTSYNC: //!< no sync found yet 352 pName = "NOTSYNC"; 353 pDesc = "Trace Stream not synchronised"; 354 break; 355 356 case ETM3_PKT_INCOMPLETE_EOT: //!< flushing incomplete/empty packet at end of trace. 357 pName = "INCOMPLETE_EOT."; 358 pDesc = "Incomplete packet at end of trace data."; 359 break; 360 361 // markers for valid packets 362 case ETM3_PKT_BRANCH_ADDRESS: 363 pName = "BRANCH_ADDRESS"; 364 pDesc = "Branch address."; 365 break; 366 367 case ETM3_PKT_A_SYNC: 368 pName = "A_SYNC"; 369 pDesc = "Alignment Synchronisation."; 370 break; 371 372 case ETM3_PKT_CYCLE_COUNT: 373 pName = "CYCLE_COUNT"; 374 pDesc = "Cycle Count."; 375 break; 376 377 case ETM3_PKT_I_SYNC: 378 pName = "I_SYNC"; 379 pDesc = "Instruction Packet synchronisation."; 380 break; 381 382 case ETM3_PKT_I_SYNC_CYCLE: 383 pName = "I_SYNC_CYCLE"; 384 pDesc = "Instruction Packet synchronisation with cycle count."; 385 break; 386 387 case ETM3_PKT_TRIGGER: 388 pName = "TRIGGER"; 389 pDesc = "Trace Trigger Event."; 390 break; 391 392 case ETM3_PKT_P_HDR: 393 pName = "P_HDR"; 394 pDesc = "Atom P-header."; 395 break; 396 397 case ETM3_PKT_STORE_FAIL: 398 pName = "STORE_FAIL"; 399 pDesc = "Data Store Failed."; 400 break; 401 402 case ETM3_PKT_OOO_DATA: 403 pName = "OOO_DATA"; 404 pDesc = "Out of Order data value packet."; 405 break; 406 407 case ETM3_PKT_OOO_ADDR_PLC: 408 pName = "OOO_ADDR_PLC"; 409 pDesc = "Out of Order data address placeholder."; 410 break; 411 412 case ETM3_PKT_NORM_DATA: 413 pName = "NORM_DATA"; 414 pDesc = "Data trace packet."; 415 break; 416 417 case ETM3_PKT_DATA_SUPPRESSED: 418 pName = "DATA_SUPPRESSED"; 419 pDesc = "Data trace suppressed."; 420 break; 421 422 case ETM3_PKT_VAL_NOT_TRACED: 423 pName = "VAL_NOT_TRACED"; 424 pDesc = "Data trace value not traced."; 425 break; 426 427 case ETM3_PKT_IGNORE: 428 pName = "IGNORE"; 429 pDesc = "Packet ignored."; 430 break; 431 432 case ETM3_PKT_CONTEXT_ID: 433 pName = "CONTEXT_ID"; 434 pDesc = "Context ID change."; 435 break; 436 437 case ETM3_PKT_VMID: 438 pName = "VMID"; 439 pDesc = "VMID change."; 440 break; 441 442 case ETM3_PKT_EXCEPTION_ENTRY: 443 pName = "EXCEPTION_ENTRY"; 444 pDesc = "Exception entry data marker."; 445 break; 446 447 case ETM3_PKT_EXCEPTION_EXIT: 448 pName = "EXCEPTION_EXIT"; 449 pDesc = "Exception return."; 450 break; 451 452 case ETM3_PKT_TIMESTAMP: 453 pName = "TIMESTAMP"; 454 pDesc = "Timestamp Value."; 455 break; 456 457 // internal processing types 458 // case ETM3_PKT_BRANCH_OR_BYPASS_EOT: not externalised 459 460 // packet errors 461 case ETM3_PKT_BAD_SEQUENCE: 462 pName = "BAD_SEQUENCE"; 463 pDesc = "Invalid sequence for packet type."; 464 break; 465 466 case ETM3_PKT_BAD_TRACEMODE: 467 pName = "BAD_TRACEMODE"; 468 pDesc = "Invalid packet type for this trace mode."; 469 break; 470 471 // leave thest unchanged. 472 case ETM3_PKT_RESERVED: 473 default: 474 break; 475 476 } 477 478 if(ppDesc) *ppDesc = pDesc; 479 return pName; 480 } 481 482 void EtmV3TrcPacket::getBranchAddressStr(std::string &valStr) const 483 { 484 std::ostringstream oss; 485 std::string subStr; 486 487 // print address. 488 trcPrintableElem::getValStr(subStr,32,m_pkt_data.addr.valid_bits, 489 m_pkt_data.addr.val,true,m_pkt_data.addr.pkt_bits); 490 oss << "Addr=" << subStr << "; "; 491 492 // current ISA if changed. 493 if(m_pkt_data.curr_isa != m_pkt_data.prev_isa) 494 { 495 getISAStr(subStr); 496 oss << subStr; 497 } 498 499 // S / NS etc if changed. 500 if(m_pkt_data.context.updated) 501 { 502 oss << (m_pkt_data.context.curr_NS ? "NS; " : "S; "); 503 oss << (m_pkt_data.context.curr_Hyp ? "Hyp; " : ""); 504 } 505 506 // exception? 507 if(m_pkt_data.exception.bits.present) 508 { 509 getExcepStr(subStr); 510 oss << subStr; 511 } 512 valStr = oss.str(); 513 } 514 515 void EtmV3TrcPacket::getAtomStr(std::string &valStr) const 516 { 517 std::ostringstream oss; 518 uint32_t bitpattern = m_pkt_data.atom.En_bits; // arranged LSBit oldest, MSbit newest 519 520 if(!m_pkt_data.cycle_count) 521 { 522 for(int i = 0; i < m_pkt_data.atom.num; i++) 523 { 524 oss << ((bitpattern & 0x1) ? "E" : "N"); // in spec read L->R, oldest->newest 525 bitpattern >>= 1; 526 } 527 } 528 else 529 { 530 switch(m_pkt_data.p_hdr_fmt) 531 { 532 case 1: 533 for(int i = 0; i < m_pkt_data.atom.num; i++) 534 { 535 oss << ((bitpattern & 0x1) ? "WE" : "WN"); // in spec read L->R, oldest->newest 536 bitpattern >>= 1; 537 } 538 break; 539 540 case 2: 541 oss << "W"; 542 for(int i = 0; i < m_pkt_data.atom.num; i++) 543 { 544 oss << ((bitpattern & 0x1) ? "E" : "N"); // in spec read L->R, oldest->newest 545 bitpattern >>= 1; 546 } 547 break; 548 549 case 3: 550 for(uint32_t i = 0; i < m_pkt_data.cycle_count; i++) 551 oss << "W"; 552 if(m_pkt_data.atom.num) 553 oss << ((bitpattern & 0x1) ? "E" : "N"); // in spec read L->R, oldest->newest 554 break; 555 } 556 oss << "; Cycles=" << m_pkt_data.cycle_count; 557 } 558 valStr = oss.str(); 559 } 560 561 void EtmV3TrcPacket::getISyncStr(std::string &valStr) const 562 { 563 std::ostringstream oss; 564 static const char *reason[] = { "Periodic", "Trace Enable", "Restart Overflow", "Debug Exit" }; 565 566 // reason. 567 oss << "(" << reason[(int)m_pkt_data.isync_info.reason] << "); "; 568 569 // full address. 570 if(!m_pkt_data.isync_info.no_address) 571 { 572 if(m_pkt_data.isync_info.has_LSipAddress) 573 oss << "Data Instr Addr=0x"; 574 else 575 oss << "Addr=0x"; 576 oss << std::hex << std::setfill('0') << std::setw(8) << m_pkt_data.addr.val << "; "; 577 } 578 579 oss << (m_pkt_data.context.curr_NS ? "NS; " : "S; "); 580 oss << (m_pkt_data.context.curr_Hyp ? "Hyp; " : " "); 581 582 if(m_pkt_data.context.updated_c) 583 { 584 oss << "CtxtID=" << std::hex << m_pkt_data.context.ctxtID << "; "; 585 } 586 587 if(m_pkt_data.isync_info.no_address) 588 { 589 valStr = oss.str(); 590 return; // bail out at this point if a data only ISYNC 591 } 592 593 std::string isaStr; 594 getISAStr(isaStr); 595 oss << isaStr; 596 597 if(m_pkt_data.isync_info.has_cycle_count) 598 { 599 oss << "Cycles=" << std::dec << m_pkt_data.cycle_count << "; "; 600 } 601 602 if(m_pkt_data.isync_info.has_LSipAddress) 603 { 604 std::string addrStr; 605 606 // extract address updata. 607 trcPrintableElem::getValStr(addrStr,32,m_pkt_data.data.addr.valid_bits, 608 m_pkt_data.data.addr.val,true,m_pkt_data.data.addr.pkt_bits); 609 oss << "Curr Instr Addr=" << addrStr << ";"; 610 } 611 valStr = oss.str(); 612 } 613 614 void EtmV3TrcPacket::getISAStr(std::string &isaStr) const 615 { 616 std::ostringstream oss; 617 oss << "ISA="; 618 switch(m_pkt_data.curr_isa) 619 { 620 case ocsd_isa_arm: 621 oss << "ARM(32); "; 622 break; 623 624 case ocsd_isa_thumb2: 625 oss << "Thumb2; "; 626 break; 627 628 case ocsd_isa_aarch64: 629 oss << "AArch64; "; 630 break; 631 632 case ocsd_isa_tee: 633 oss << "ThumbEE; "; 634 break; 635 636 case ocsd_isa_jazelle: 637 oss << "Jazelle; "; 638 break; 639 640 default: 641 case ocsd_isa_unknown: 642 oss << "Unknown; "; 643 break; 644 } 645 isaStr = oss.str(); 646 } 647 648 void EtmV3TrcPacket::getExcepStr(std::string &excepStr) const 649 { 650 static const char *ARv7Excep[] = { 651 "No Exception", "Debug Halt", "SMC", "Hyp", 652 "Async Data Abort", "Jazelle", "Reserved", "Reserved", 653 "PE Reset", "Undefined Instr", "SVC", "Prefetch Abort", 654 "Data Fault", "Generic", "IRQ", "FIQ" 655 }; 656 657 static const char *MExcep[] = { 658 "No Exception", "IRQ1", "IRQ2", "IRQ3", 659 "IRQ4", "IRQ5", "IRQ6", "IRQ7", 660 "IRQ0","usage Fault","NMI","SVC", 661 "DebugMonitor", "Mem Manage","PendSV","SysTick", 662 "Reserved","PE Reset","Reserved","HardFault" 663 "Reserved","BusFault","Reserved","Reserved" 664 }; 665 666 std::ostringstream oss; 667 oss << "Exception="; 668 669 if(m_pkt_data.exception.bits.cm_type) 670 { 671 if(m_pkt_data.exception.number < 0x18) 672 oss << MExcep[m_pkt_data.exception.number]; 673 else 674 oss << "IRQ" << std::dec << (m_pkt_data.exception.number - 0x10); 675 if(m_pkt_data.exception.bits.cm_resume) 676 oss << "; Resume=" << m_pkt_data.exception.bits.cm_resume; 677 if(m_pkt_data.exception.bits.cancel) 678 oss << "; Cancel prev instr"; 679 } 680 else 681 { 682 oss << ARv7Excep[m_pkt_data.exception.number] << "; "; 683 if(m_pkt_data.exception.bits.cancel) 684 oss << "; Cancel prev instr"; 685 } 686 excepStr = oss.str(); 687 } 688 /* End of File trc_pkt_elem_etmv3.cpp */ 689