6d6feaf7e3
The architectures provided to skipIf / expectedFail are regular expressions (v. _match_decorator_property() in decorators.py so on Darwin systems "arm64" would match the skips for "arm" (32-bit Linux). Update these to "arm$" to prevent this, and also update three tests (TestBuiltinFormats.py, TestCrossDSOTailCalls.py, TestCrossObjectTailCalls.py) that were skipped for arm64 via this behavior, and need to be skipped or they will fail. This was moviated by the new TestDynamicValue.py test which has an expected-fail for arm, but the test was passing on arm64 Darwin resulting in failure for the CIs.
189 lines
7.2 KiB
Python
189 lines
7.2 KiB
Python
"""
|
|
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()
|
|
new_debugger.SetSelectedPlatform(lldb.selected_platform)
|
|
new_debugger.SetAsync(False)
|
|
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 ""
|