from intelpt_testcase import *
from lldbsuite.test.lldbtest import *
from lldbsuite.test.decorators import *
class TestTraceDumpInfo(TraceIntelPTTestCaseBase):
def testDumpSimpleFunctionCalls(self):
self.expect(
"trace load -v "
+ os.path.join(self.getSourceDir(), "intelpt-trace", "trace.json")
)
self.expect(
"thread trace dump function-calls 2",
error=True,
substrs=['error: no thread with index: "2"'],
)
self.expect(
"thread trace dump function-calls 1 -j",
substrs=[
'[{"tracedSegments":[{"firstInstructionId":"3","lastInstructionId":"26"}]}]'
],
)
self.expect(
"thread trace dump function-calls 1 -J",
substrs=[
"""[
{
"tracedSegments": [
{
"firstInstructionId": "3",
"lastInstructionId": "26"
}
]
}
]"""
],
)
# We test first some code without function call
self.expect(
"thread trace dump function-calls 1",
substrs=[
"""thread #1: tid = 3842849
[call tree #0]
a.out`main + 4 at main.cpp:2 to 4:0 [3, 26]"""
],
)
def testFunctionCallsWithErrors(self):
self.expect(
"trace load -v "
+ os.path.join(
self.getSourceDir(), "intelpt-multi-core-trace", "trace.json"
)
)
# 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> [19526, 19526]"""
],
)
self.expect(
"thread trace dump function-calls 2 -J",
substrs=[
"""[
{
"tracedSegments": [
{
"firstInstructionId": "4",
"lastInstructionId": "19524"
}
]
},
{
"tracedSegments": [
{
"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> [61833, 61833]"""
],
)
self.expect(
"thread trace dump function-calls 3 -J",
substrs=[
"""[
{
"tracedSegments": [
{
"firstInstructionId": "5",
"lastInstructionId": "61831"
}
]
},
{
"tracedSegments": [
{
"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
self.expect("b 17")
self.expect("r")
self.expect("thread trace start")
self.expect("c")
self.expect(
"thread trace dump function-calls",
substrs=[
"""[call tree #0]
a.out`main + 8 at inline.cpp:15:7 to 16:14 [2, 6]
a.out`foo(int) at inline.cpp:8:16 to 9:15 [7, 14]
a.out`foo(int) + 22 [inlined] mult(int, int) at inline.cpp:2:7 to 5:10 [15, 22]
a.out`foo(int) + 49 at inline.cpp:9:15 to 12:1 [23, 27]
a.out`main + 25 at inline.cpp:16:14 to 16:14 [28, 28]"""
],
)
self.expect(
"thread trace dump function-calls -J",
substrs=[
"""[
{
"tracedSegments": [
{
"firstInstructionId": "2",
"lastInstructionId": "6",
"nestedCall": {
"tracedSegments": [
{
"firstInstructionId": "7",
"lastInstructionId": "14",
"nestedCall": {
"tracedSegments": [
{
"firstInstructionId": "15",
"lastInstructionId": "22"
}
]
}
},
{
"firstInstructionId": "23",
"lastInstructionId": "27"
}
]
}
},
{
"firstInstructionId": "28",
"lastInstructionId": "28"
}
]
}
]"""
],
)
def testIncompleteInlineFunctionCalls(self):
self.expect(
"file " + os.path.join(self.getSourceDir(), "inline-function", "a.out")
)
self.expect("b 4") # we'll trace from the middle of the inline method
self.expect("b 17")
self.expect("r")
self.expect("thread trace start")
self.expect("c")
self.expect(
"thread trace dump function-calls",
substrs=[
"""[call tree #0]
a.out`main
a.out`foo(int)
a.out`foo(int) + 36 [inlined] mult(int, int) + 14 at inline.cpp:4:5 to 5:10 [2, 6]
a.out`foo(int) + 49 at inline.cpp:9:15 to 12:1 [7, 11]
a.out`main + 25 at inline.cpp:16:14 to 16:14 [12, 12]"""
],
)
self.expect(
"thread trace dump function-calls -J",
substrs=[
"""[
{
"untracedPrefixSegment": {
"nestedCall": {
"untracedPrefixSegment": {
"nestedCall": {
"tracedSegments": [
{
"firstInstructionId": "2",
"lastInstructionId": "6"
}
]
}
},
"tracedSegments": [
{
"firstInstructionId": "7",
"lastInstructionId": "11"
}
]
}
},
"tracedSegments": [
{
"firstInstructionId": "12",
"lastInstructionId": "12"
}
]
}
]"""
],
)
def testMultifileFunctionCalls(self):
# This test is extremely important because it first calls the method foo() which requires going through the dynamic linking.
# You'll see the entry "a.out`symbol stub for: foo()" which will invoke the ld linker, which will in turn find the actual foo
# function and eventually invoke it. However, we don't have the image of the linker in the trace bundle, so we'll see errors
# because the decoder couldn't find the linker binary! After those failures, the linker will resume right where we return to
# main after foo() finished.
# Then, we call foo() again, but because it has already been loaded by the linker, we don't invoke the linker anymore! And
# we'll see a nice tree without errors in this second invocation. Something interesting happens here. We still have an
# invocation to the symbol stub for foo(), but it modifies the stack so that when we return from foo() we don't stop again
# at the symbol stub, but instead we return directly to main. This is an example of returning several levels up in the
# call stack.
# Not only that, we also have an inline method in between.
self.expect(
"trace load "
+ os.path.join(
self.getSourceDir(), "intelpt-trace-multi-file", "multi-file-no-ld.json"
)
)
self.expect(
"thread trace dump function-calls",
substrs=[
"""thread #1: tid = 815455
[call tree #0]
a.out`main + 15 at main.cpp:10 to 10:0 [3, 3]
a.out`symbol stub for: foo() to <+11> [7, 9]
a.out`a.out[0x0000000000400510] to a.out[0x0000000000400516] [10, 11]
[call tree #1]
<tracing errors> [12, 12]
[call tree #2]
a.out`main + 20 at main.cpp:10 to 12:0 [16, 22]
a.out`main + 34 [inlined] inline_function() at main.cpp:4 to 6:0 [26, 30]
a.out`main + 55 at main.cpp:14 to 16:0 [31, 37]
a.out`symbol stub for: foo() to <+0> [38, 38]
libfoo.so`foo() at foo.cpp:3 to 4:0 [39, 42]
libfoo.so`symbol stub for: bar() to <+0> [43, 43]
libbar.so`bar() at bar.cpp:1 to 4:0 [44, 52]
libfoo.so`foo() + 13 at foo.cpp:4 to 6:0 [53, 60]
a.out`main + 68 at main.cpp:16 to 16:0 [61, 63]"""
],
)
self.expect(
"thread trace dump function-calls -J",
substrs=[
"""[
{
"tracedSegments": [
{
"firstInstructionId": "3",
"lastInstructionId": "3",
"nestedCall": {
"tracedSegments": [
{
"firstInstructionId": "7",
"lastInstructionId": "9",
"nestedCall": {
"tracedSegments": [
{
"firstInstructionId": "10",
"lastInstructionId": "11"
}
]
}
}
]
}
}
]
},
{
"tracedSegments": [
{
"firstInstructionId": "12",
"lastInstructionId": "12"
}
]
},
{
"tracedSegments": [
{
"firstInstructionId": "16",
"lastInstructionId": "22",
"nestedCall": {
"tracedSegments": [
{
"firstInstructionId": "26",
"lastInstructionId": "30"
}
]
}
},
{
"firstInstructionId": "31",
"lastInstructionId": "37",
"nestedCall": {
"tracedSegments": [
{
"firstInstructionId": "38",
"lastInstructionId": "38",
"nestedCall": {
"tracedSegments": [
{
"firstInstructionId": "39",
"lastInstructionId": "42",
"nestedCall": {
"tracedSegments": [
{
"firstInstructionId": "43",
"lastInstructionId": "43",
"nestedCall": {
"tracedSegments": [
{
"firstInstructionId": "44",
"lastInstructionId": "52"
}
]
}
}
]
}
},
{
"firstInstructionId": "53",
"lastInstructionId": "60"
}
]
}
}
]
}
},
{
"firstInstructionId": "61",
"lastInstructionId": "63"
}
]
}
]"""
],
)
Codebase Browser
llvm