1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
"""
Test the use of the global module cache in lldb
"""
import lldb
from lldbsuite.test.decorators import *
from lldbsuite.test.lldbtest import *
from lldbsuite.test import lldbutil
import os
import shutil
from pathlib import Path
import time
class GlobalModuleCacheTestCase(TestBase):
# NO_DEBUG_INFO_TESTCASE = True
def check_counter_var(self, thread, value):
frame = thread.frames[0]
var = frame.FindVariable("counter")
self.assertTrue(var.GetError().Success(), "Got counter variable")
self.assertEqual(var.GetValueAsUnsigned(), value, "This was one-print")
def copy_to_main(self, src, dst):
# We are relying on the source file being newer than the .o file from
# a previous build, so sleep a bit here to ensure that the touch is later.
time.sleep(2)
try:
# Make sure dst is writeable before trying to write to it.
subprocess.run(
["chmod", "777", dst],
stdin=None,
capture_output=False,
encoding="utf-8",
)
shutil.copy(src, dst)
except:
self.fail(f"Could not copy {src} to {dst}")
Path(dst).touch()
# The rerun tests indicate rerunning on Windows doesn't really work, so
# this one won't either.
@skipIfWindows
# On Arm and AArch64 Linux, this test attempts to pop a thread plan when
# we only have the base plan remaining. Skip it until we can figure out
# the bug this is exposing (https://github.com/llvm/llvm-project/issues/76057).
@skipIf(oslist=["linux"], archs=["arm", "aarch64"])
def test_OneTargetOneDebugger(self):
self.do_test(True, True)
# This behaves as implemented but that behavior is not desirable.
# This test tests for the desired behavior as an expected fail.
@skipIfWindows
@expectedFailureAll
@skipIf(oslist=["linux"], archs=["arm", "aarch64"])
def test_TwoTargetsOneDebugger(self):
self.do_test(False, True)
@skipIfWindows
@expectedFailureAll
@skipIf(oslist=["linux"], archs=["arm", "aarch64"])
def test_OneTargetTwoDebuggers(self):
self.do_test(True, False)
def do_test(self, one_target, one_debugger):
# Make sure that if we have one target, and we run, then
# change the binary and rerun, the binary (and any .o files
# if using dwarf in .o file debugging) get removed from the
# shared module cache. They are no longer reachable.
debug_style = self.getDebugInfo()
# Before we do anything, clear the global module cache so we don't
# see objects from other runs:
lldb.SBDebugger.MemoryPressureDetected()
# Set up the paths for our two versions of main.c:
main_c_path = os.path.join(self.getBuildDir(), "main.c")
one_print_path = os.path.join(self.getSourceDir(), "one-print.c")
two_print_path = os.path.join(self.getSourceDir(), "two-print.c")
main_filespec = lldb.SBFileSpec(main_c_path)
# First copy the one-print.c to main.c in the build folder and
# build our a.out from there:
self.copy_to_main(one_print_path, main_c_path)
self.build(dictionary={"C_SOURCES": main_c_path, "EXE": "a.out"})
(target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
self, "return counter;", main_filespec
)
# Make sure we ran the version we intended here:
self.check_counter_var(thread, 1)
process.Kill()
# Now copy two-print.c over main.c, rebuild, and rerun:
# os.unlink(target.GetExecutable().fullpath)
self.copy_to_main(two_print_path, main_c_path)
self.build(dictionary={"C_SOURCES": main_c_path, "EXE": "a.out"})
error = lldb.SBError()
if one_debugger:
if one_target:
(_, process, thread, _) = lldbutil.run_to_breakpoint_do_run(
self, target, bkpt
)
else:
(target2, process2, thread, bkpt) = lldbutil.run_to_source_breakpoint(
self, "return counter;", main_filespec
)
else:
if one_target:
new_debugger = lldb.SBDebugger().Create()
self.old_debugger = self.dbg
self.dbg = new_debugger
def cleanupDebugger(self):
lldb.SBDebugger.Destroy(self.dbg)
self.dbg = self.old_debugger
self.old_debugger = None
self.addTearDownHook(cleanupDebugger)
(target2, process2, thread, bkpt) = lldbutil.run_to_source_breakpoint(
self, "return counter;", main_filespec
)
# In two-print.c counter will be 2:
self.check_counter_var(thread, 2)
# If we made two targets, destroy the first one, that should free up the
# unreachable Modules:
if not one_target:
target.Clear()
num_a_dot_out_entries = 1
# For dSYM's there will be two lines of output, one for the a.out and one
# for the dSYM.
if debug_style == "dsym":
num_a_dot_out_entries += 1
error = self.check_image_list_result(num_a_dot_out_entries, 1)
# Even if this fails, MemoryPressureDetected should fix this.
lldb.SBDebugger.MemoryPressureDetected()
error_after_mpd = self.check_image_list_result(num_a_dot_out_entries, 1)
fail_msg = ""
if error != "":
fail_msg = "Error before MPD: " + error
if error_after_mpd != "":
fail_msg = fail_msg + "\nError after MPD: " + error_after_mpd
if fail_msg != "":
self.fail(fail_msg)
def check_image_list_result(self, num_a_dot_out, num_main_dot_o):
# Check the global module list, there should only be one a.out, and if we are
# doing dwarf in .o file, there should only be one .o file. This returns
# an error string on error - rather than asserting, so you can stage this
# failing.
image_cmd_result = lldb.SBCommandReturnObject()
interp = self.dbg.GetCommandInterpreter()
interp.HandleCommand("image list -g", image_cmd_result)
if self.TraceOn():
print(f"Expected: a.out: {num_a_dot_out} main.o: {num_main_dot_o}")
print(image_cmd_result)
image_list_str = image_cmd_result.GetOutput()
image_list = image_list_str.splitlines()
found_a_dot_out = 0
found_main_dot_o = 0
for line in image_list:
# FIXME: force this to be at the end of the string:
if "a.out" in line:
found_a_dot_out += 1
if "main.o" in line:
found_main_dot_o += 1
if num_a_dot_out != found_a_dot_out:
return f"Got {found_a_dot_out} number of a.out's, expected {num_a_dot_out}"
if found_main_dot_o > 0 and num_main_dot_o != found_main_dot_o:
return f"Got {found_main_dot_o} number of main.o's, expected {num_main_dot_o}"
return ""
|
