[intelpt] Update Python tests to account for new errrors

[jj10306]

Summary

Update the Python tests (ie tests run via lldb-dotest -p TestTrace) to
handle new error introduced in D136610.

Test Plan:
lldb-dotest -p TestTrace

[wallace]

Thanks!

lldb/test/API/commands/trace/TestTraceDumpFunctionCalls.py

def testFunctionCallsWithErrors(self):
       # We expect that tracing errors appear as a different tree
       self.expect("thread trace dump function-calls 2",
         substrs=['''thread #2: tid = 3497496
 
 [call tree #0]
 m.out`foo() + 65 at multi_thread.cpp:12:21 to 12:21  [4, 19524]
 
 [call tree #1]
-<tracing errors>  [19532, 19532]'''])
+<tracing errors>  [19526, 19526]'''])
 
       self.expect("thread trace dump function-calls 2 -J",
         substrs=['''[
   {
     "tracedSegments": [
       {
         "firstInstructionId": "4",
         "lastInstructionId": "19524"
       }
     ]
   },
   {
     "tracedSegments": [
       {
-        "firstInstructionId": "19532",
-        "lastInstructionId": "19532"
+        "firstInstructionId": "19526",
+        "lastInstructionId": "19526"
       }
     ]
   }
 ]'''])
 
       self.expect("thread trace dump function-calls 3",
         substrs=['''thread #3: tid = 3497497
 
 [call tree #0]
 m.out`bar() + 30 at multi_thread.cpp:19:3 to 20:6  [5, 61831]
 
 [call tree #1]
-<tracing errors>  [61834, 61834]'''])
+<tracing errors>  [61833, 61833]'''])
 
       self.expect("thread trace dump function-calls 3 -J",
         substrs=['''[
   {
     "tracedSegments": [
       {
         "firstInstructionId": "5",
         "lastInstructionId": "61831"
       }
     ]
   },
   {
     "tracedSegments": [
       {
-        "firstInstructionId": "61834",
-        "lastInstructionId": "61834"
+        "firstInstructionId": "61833",
+        "lastInstructionId": "61833"
       }
     ]
   }
 ]'''])
 
     def testInlineFunctionCalls(self):
       self.expect("file " + os.path.join(self.getSourceDir(), "inline-function", "a.out"))
       self.expect("b main") # we'll trace from the beginning of main

lldb/test/API/commands/trace/TestTraceLoad.py

 import lldb
 from intelpt_testcase import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 from lldbsuite.test.decorators import *
 
 class TestTraceLoad(TraceIntelPTTestCaseBase):
     NO_DEBUG_INFO_TESTCASE = True
 
     @testSBAPIAndCommands
     def testLoadMultiCoreTrace(self):
         src_dir = self.getSourceDir()
         trace_description_file_path = os.path.join(src_dir, "intelpt-multi-core-trace", "trace.json")
         self.traceLoad(traceDescriptionFilePath=trace_description_file_path, substrs=["intel-pt"])
         self.expect("thread trace dump instructions 2 -t",
-          substrs=["19532: [20456513.000 ns] (error) expected tracing enabled event",
+          substrs=["19526: [19691636.212 ns] (error) decoding truncated: TSC 40450075478109270 exceeds maximum TSC value 40450075477704372, will skip decoding the remaining data of the PSB (skipping 774 of 825 bytes)",
                    "m.out`foo() + 65 at multi_thread.cpp:12:21",
-                   "9524: [19691630.226 ns] 0x0000000000400ba7    jg     0x400bb3"])
+                   "9524: [19691632.221 ns] 0x0000000000400ba7    jg     0x400bb3"])
         self.expect("thread trace dump instructions 3 -t",
-          substrs=["61831: [19736134.073 ns] 0x0000000000400bd7    addl   $0x1, -0x4(%rbp)",
+          substrs=["61831: [19736132.088 ns] 0x0000000000400bd7    addl   $0x1, -0x4(%rbp)",
                    "m.out`bar() + 26 at multi_thread.cpp:20:6"])
 
         self.expect("thread trace dump info --json",
           substrs=['''{
   "traceTechnology": "intel-pt",
   "threadStats": {
     "tid": 3497234,
     "traceItemsCount": 0,
class TestTraceLoad(TraceIntelPTTestCaseBase):
   }
 }'''])
 
         self.expect("thread trace dump info 2 --json",
           substrs=['''{
   "traceTechnology": "intel-pt",
   "threadStats": {
     "tid": 3497496,
-    "traceItemsCount": 19533,
+    "traceItemsCount": 19527,
     "memoryUsage": {
-      "totalInBytes": "176065",
-      "avgPerItemInBytes": 9.''', '''},
+      "totalInBytes": "175819",
+      "avgPerItemInBytes": 9.0038920469094084''', '''},
     "timingInSeconds": {
       "Decoding instructions": ''', '''
     },
     "events": {
-      "totalCount": 11,
+      "totalCount": 5,
       "individualCounts": {
         "software disabled tracing": 1,
         "trace synchronization point": 1,
         "CPU core changed": 1,
-        "HW clock tick": 8
+        "HW clock tick": 2
       }
     },
     "errors": {
       "totalCount": 1,
       "libiptErrors": {},
       "fatalErrors": 0,
       "otherErrors": 1
     },
def testLoadCompactMultiCoreTrace(self):
 
         # we'll delete the previous target and make sure it's trace object is deleted
         self.dbg.DeleteTarget(self.dbg.GetTargetAtIndex(0))
         self.expect("thread trace dump instructions 2 -t", substrs=["error: invalid target"], error=True)
 
         # we'll load the compact trace and make sure it works
         self.traceLoad(os.path.join(compact_trace_bundle_dir, "trace.json"), substrs=["intel-pt"])
         self.expect("thread trace dump instructions 2 -t",
-          substrs=["19532: [20456513.000 ns] (error) expected tracing enabled event",
+          substrs=["19526: [19691636.212 ns] (error) decoding truncated: TSC 40450075478109270 exceeds maximum TSC value 40450075477704372, will skip decoding the remaining data of the PSB (skipping 774 of 825 bytes)",
                    "m.out`foo() + 65 at multi_thread.cpp:12:21",
-                   "19524: [19691630.226 ns] 0x0000000000400ba7    jg     0x400bb3"])
+                   "19524: [19691632.221 ns] 0x0000000000400ba7    jg     0x400bb3"])
         self.expect("thread trace dump instructions 3 -t",
-          substrs=["61831: [19736134.073 ns] 0x0000000000400bd7    addl   $0x1, -0x4(%rbp)",
+          substrs=["61833: [19736136.079 ns] (error) decoding truncated: TSC 40450075478174268 exceeds maximum TSC value 40450075477820383, will skip decoding the remaining data of the PSB (skipping 296 of 297 bytes)",
+                   "61831: [19736132.088 ns] 0x0000000000400bd7    addl   $0x1, -0x4(%rbp)",
                    "m.out`bar() + 26 at multi_thread.cpp:20:6"])
 
         # This reduced the number of continuous executions to look at
         self.expect("thread trace dump info 2", substrs=["Total number of continuous executions found: 3"])
 
         # We clean up for the next run of this test
         self.dbg.DeleteTarget(self.dbg.GetTargetAtIndex(0))
 
     @testSBAPIAndCommands
     def testLoadMultiCoreTraceWithStringNumbers(self):
         src_dir = self.getSourceDir()
         trace_description_file_path = os.path.join(src_dir, "intelpt-multi-core-trace", "trace_with_string_numbers.json")
         self.traceLoad(traceDescriptionFilePath=trace_description_file_path, substrs=["intel-pt"])
         self.expect("thread trace dump instructions 2 -t",
-          substrs=["19532: [20456513.000 ns] (error) expected tracing enabled event",
+          substrs=["19526: [19691636.212 ns] (error) decoding truncated: TSC 40450075478109270 exceeds maximum TSC value 40450075477704372, will skip decoding the remaining data of the PSB (skipping 774 of 825 bytes)",
                    "m.out`foo() + 65 at multi_thread.cpp:12:21",
-                   "19524: [19691630.226 ns] 0x0000000000400ba7    jg     0x400bb3"])
+                   "19524: [19691632.221 ns] 0x0000000000400ba7    jg     0x400bb3"])
         self.expect("thread trace dump instructions 3 -t",
-          substrs=["61831: [19736134.073 ns] 0x0000000000400bd7    addl   $0x1, -0x4(%rbp)",
+          substrs=["61831: [19736132.088 ns] 0x0000000000400bd7    addl   $0x1, -0x4(%rbp)",
                    "m.out`bar() + 26 at multi_thread.cpp:20:6"])
 
     @testSBAPIAndCommands
     def testLoadMultiCoreTraceWithMissingThreads(self):
         src_dir = self.getSourceDir()
         trace_description_file_path = os.path.join(src_dir, "intelpt-multi-core-trace", "trace_missing_threads.json")
         self.traceLoad(traceDescriptionFilePath=trace_description_file_path, substrs=["intel-pt"])
         self.expect("thread trace dump instructions 3 -t",
-          substrs=["19532: [20456513.000 ns] (error) expected tracing enabled event",
+          substrs=["19526: [19691636.212 ns] (error) decoding truncated: TSC 40450075478109270 exceeds maximum TSC value 40450075477704372, will skip decoding the remaining data of the PSB (skipping 774 of 825 bytes)",
                    "m.out`foo() + 65 at multi_thread.cpp:12:21",
-                   "19524: [19691630.226 ns] 0x0000000000400ba7    jg     0x400bb3"])
+                   "19524: [19691632.221 ns] 0x0000000000400ba7    jg     0x400bb3"])
         self.expect("thread trace dump instructions 2 -t",
-          substrs=["61831: [19736134.073 ns] 0x0000000000400bd7    addl   $0x1, -0x4(%rbp)",
+          substrs=["61831: [19736132.088 ns] 0x0000000000400bd7    addl   $0x1, -0x4(%rbp)",
                    "m.out`bar() + 26 at multi_thread.cpp:20:6"])
 
     @testSBAPIAndCommands
     def testLoadTrace(self):
         src_dir = self.getSourceDir()
         trace_description_file_path = os.path.join(src_dir, "intelpt-trace", "trace.json")
         self.traceLoad(traceDescriptionFilePath=trace_description_file_path, substrs=["intel-pt"])
 
def testLoadTraceCursor(self):
         self.assertEqual(cursor.GetCPU(), lldb.LLDB_INVALID_CPU_ID)
 
         cursor.Next()
 
         self.assertTrue(cursor.IsEvent())
         self.assertEqual(cursor.GetEventTypeAsString(), "CPU core changed")
         self.assertEqual(cursor.GetCPU(), 51)
 
-        cursor.GoToId(19532)
+        cursor.GoToId(19526)
 
         self.assertTrue(cursor.IsError())
-        self.assertEqual(cursor.GetError(), "expected tracing enabled event")
+        self.assertEqual(cursor.GetError(), "decoding truncated: TSC 40450075478109270 exceeds maximum TSC value 40450075477704372, will skip decoding the remaining data of the PSB (skipping 774 of 825 bytes)")
 
         cursor.GoToId(19524)
 
         self.assertTrue(cursor.IsInstruction())
         self.assertEqual(cursor.GetLoadAddress(), 0x400BA7)