2a7abb04e2
This is the same diff I've put up at many times before. I've been trying to add some brand new functionality to the LLDB test infrastucture (create split-dwarf files!), and we all know that no good deed goes unpunished. The last attempt was reverted because it didn't work on the Fuchsia build. There are no code differences between this and [the](https://github.com/llvm/llvm-project/pull/90622) [previous](https://github.com/llvm/llvm-project/pull/87676) [four](https://github.com/llvm/llvm-project/pull/86812) [diffs](https://github.com/llvm/llvm-project/pull/85693) landed & reverted (due to testing infra failures). The only change in this one is the way `dwp` is being identified in `Makefile.rules`. Thanks to @petrhosek for helping me figure out how the fuchsia builders are configured. I now prefer to use llvm-dwp and fall back to gnu's dwp if the former isn't found. Hopefully this will work everywhere it needs to.
187 lines
6.6 KiB
Python
187 lines
6.6 KiB
Python
import os
|
|
import shutil
|
|
import tempfile
|
|
|
|
import lldb
|
|
from lldbsuite.test.decorators import *
|
|
import lldbsuite.test.lldbutil as lldbutil
|
|
from lldbsuite.test.lldbtest import *
|
|
|
|
|
|
"""
|
|
Test support for the DebugInfoD network symbol acquisition protocol.
|
|
This one is for simple / no split-dwarf scenarios.
|
|
|
|
For no-split-dwarf scenarios, there are 2 variations:
|
|
1 - A stripped binary with it's corresponding unstripped binary:
|
|
2 - A stripped binary with a corresponding --only-keep-debug symbols file
|
|
"""
|
|
|
|
|
|
class DebugInfodTests(TestBase):
|
|
# No need to try every flavor of debug inf.
|
|
NO_DEBUG_INFO_TESTCASE = True
|
|
|
|
@skipUnlessPlatform(["linux", "freebsd"])
|
|
def test_normal_no_symbols(self):
|
|
"""
|
|
Validate behavior with no symbols or symbol locator.
|
|
('baseline negative' behavior)
|
|
"""
|
|
test_root = self.config_test(["a.out"])
|
|
self.try_breakpoint(False)
|
|
|
|
@skipUnlessPlatform(["linux", "freebsd"])
|
|
def test_normal_default(self):
|
|
"""
|
|
Validate behavior with symbols, but no symbol locator.
|
|
('baseline positive' behavior)
|
|
"""
|
|
test_root = self.config_test(["a.out", "a.out.debug"])
|
|
self.try_breakpoint(True)
|
|
|
|
@skipIfCurlSupportMissing
|
|
@skipUnlessPlatform(["linux", "freebsd"])
|
|
def test_debuginfod_symbols(self):
|
|
"""
|
|
Test behavior with the full binary available from Debuginfod as
|
|
'debuginfo' from the plug-in.
|
|
"""
|
|
test_root = self.config_test(["a.out"], "a.out.unstripped")
|
|
self.try_breakpoint(True)
|
|
|
|
@skipIfCurlSupportMissing
|
|
@skipUnlessPlatform(["linux", "freebsd"])
|
|
def test_debuginfod_executable(self):
|
|
"""
|
|
Test behavior with the full binary available from Debuginfod as
|
|
'executable' from the plug-in.
|
|
"""
|
|
test_root = self.config_test(["a.out"], None, "a.out.unstripped")
|
|
self.try_breakpoint(True)
|
|
|
|
@skipIfCurlSupportMissing
|
|
@skipUnlessPlatform(["linux", "freebsd"])
|
|
def test_debuginfod_okd_symbols(self):
|
|
"""
|
|
Test behavior with the 'only-keep-debug' symbols available from Debuginfod.
|
|
"""
|
|
test_root = self.config_test(["a.out"], "a.out.debug")
|
|
self.try_breakpoint(True)
|
|
|
|
def try_breakpoint(self, should_have_loc):
|
|
"""
|
|
This function creates a target from self.aout, sets a function-name
|
|
breakpoint, and checks to see if we have a file/line location,
|
|
as a way to validate that the symbols have been loaded.
|
|
should_have_loc specifies if we're testing that symbols have or
|
|
haven't been loaded.
|
|
"""
|
|
target = self.dbg.CreateTarget(self.aout)
|
|
self.assertTrue(target and target.IsValid(), "Target is valid")
|
|
|
|
bp = target.BreakpointCreateByName("func")
|
|
self.assertTrue(bp and bp.IsValid(), "Breakpoint is valid")
|
|
self.assertEqual(bp.GetNumLocations(), 1)
|
|
|
|
loc = bp.GetLocationAtIndex(0)
|
|
self.assertTrue(loc and loc.IsValid(), "Location is valid")
|
|
addr = loc.GetAddress()
|
|
self.assertTrue(addr and addr.IsValid(), "Loc address is valid")
|
|
line_entry = addr.GetLineEntry()
|
|
self.assertEqual(
|
|
should_have_loc,
|
|
line_entry != None and line_entry.IsValid(),
|
|
"Loc line entry is valid",
|
|
)
|
|
if should_have_loc:
|
|
self.assertEqual(line_entry.GetLine(), 4)
|
|
self.assertEqual(
|
|
line_entry.GetFileSpec().GetFilename(),
|
|
self.main_source_file.GetFilename(),
|
|
)
|
|
self.dbg.DeleteTarget(target)
|
|
shutil.rmtree(self.tmp_dir)
|
|
|
|
def config_test(self, local_files, debuginfo=None, executable=None):
|
|
"""
|
|
Set up a test with local_files[] copied to a different location
|
|
so that we control which files are, or are not, found in the file system.
|
|
Also, create a stand-alone file-system 'hosted' debuginfod server with the
|
|
provided debuginfo and executable files (if they exist)
|
|
|
|
Make the filesystem look like:
|
|
|
|
/tmp/<tmpdir>/test/[local_files]
|
|
|
|
/tmp/<tmpdir>/cache (for lldb to use as a temp cache)
|
|
|
|
/tmp/<tmpdir>/buildid/<uuid>/executable -> <executable>
|
|
/tmp/<tmpdir>/buildid/<uuid>/debuginfo -> <debuginfo>
|
|
Returns the /tmp/<tmpdir> path
|
|
"""
|
|
|
|
self.build()
|
|
|
|
uuid = self.getUUID("a.out")
|
|
if not uuid:
|
|
self.fail("Could not get UUID for a.out")
|
|
return
|
|
self.main_source_file = lldb.SBFileSpec("main.c")
|
|
self.tmp_dir = tempfile.mkdtemp()
|
|
test_dir = os.path.join(self.tmp_dir, "test")
|
|
os.makedirs(test_dir)
|
|
|
|
self.aout = ""
|
|
# Copy the files used by the test:
|
|
for f in local_files:
|
|
shutil.copy(self.getBuildArtifact(f), test_dir)
|
|
# The first item is the binary to be used for the test
|
|
if self.aout == "":
|
|
self.aout = os.path.join(test_dir, f)
|
|
|
|
use_debuginfod = debuginfo != None or executable != None
|
|
|
|
# Populated the 'file://... mocked' Debuginfod server:
|
|
if use_debuginfod:
|
|
os.makedirs(os.path.join(self.tmp_dir, "cache"))
|
|
uuid_dir = os.path.join(self.tmp_dir, "buildid", uuid)
|
|
os.makedirs(uuid_dir)
|
|
if debuginfo:
|
|
shutil.copy(
|
|
self.getBuildArtifact(debuginfo),
|
|
os.path.join(uuid_dir, "debuginfo"),
|
|
)
|
|
if executable:
|
|
shutil.copy(
|
|
self.getBuildArtifact(executable),
|
|
os.path.join(uuid_dir, "executable"),
|
|
)
|
|
|
|
# Configure LLDB for the test:
|
|
self.runCmd(
|
|
"settings set symbols.enable-external-lookup %s"
|
|
% str(use_debuginfod).lower()
|
|
)
|
|
self.runCmd("settings clear plugin.symbol-locator.debuginfod.server-urls")
|
|
if use_debuginfod:
|
|
self.runCmd(
|
|
"settings set plugin.symbol-locator.debuginfod.cache-path %s/cache"
|
|
% self.tmp_dir
|
|
)
|
|
self.runCmd(
|
|
"settings insert-before plugin.symbol-locator.debuginfod.server-urls 0 file://%s"
|
|
% self.tmp_dir
|
|
)
|
|
|
|
def getUUID(self, filename):
|
|
try:
|
|
spec = lldb.SBModuleSpec()
|
|
spec.SetFileSpec(lldb.SBFileSpec(self.getBuildArtifact(filename)))
|
|
module = lldb.SBModule(spec)
|
|
uuid = module.GetUUIDString().replace("-", "").lower()
|
|
# Don't want lldb's fake 32 bit CRC's for this one
|
|
return uuid if len(uuid) > 8 else None
|
|
except:
|
|
return None
|