blob: dbf695431a910cc8be536f22878a4dbc14be811f [file]
"""
Test the accelerator dynamic loader against a mock GDB server.
The server selects the loader by name through jLLDBSettings. The loader
then asks the server for the loaded libraries via
jAcceleratorPluginGetDynamicLoaderLibraryInfo and loads them into the target.
"""
import json
import os
import lldb
from lldbsuite.test.decorators import *
from lldbsuite.test.gdbclientutils import *
from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
DYLD_PACKET = "jAcceleratorPluginGetDynamicLoaderLibraryInfo:"
class AcceleratorResponder(MockGDBServerResponder):
"""Serves a fixed set of library infos, and counts how often it is asked."""
def __init__(
self,
library_infos,
dyld_plugin_name="accelerator-gdb-remote",
stop_replies=None,
):
MockGDBServerResponder.__init__(self)
self.library_infos = library_infos
self.dyld_plugin_name = dyld_plugin_name
self.dyld_queries = 0
self.last_dyld_packet = None
self.stop_replies = list(stop_replies or [])
self.cont_queries = 0
def qSupported(self, client_supported):
features = super().qSupported(client_supported) + ";qXfer:features:read+"
if self.dyld_plugin_name is not None:
features += ";lldb-settings+"
return features
def qXferRead(self, obj, annex, offset, length):
# An accelerator architecture has no built-in register set in lldb.
if obj == "features" and annex == "target.xml":
return (
"""<?xml version="1.0"?>
<target version="1.0">
<feature name="org.llvm.accelerator">
<reg name="pc" bitsize="64" regnum="0" type="code_ptr" group="general"/>
</feature>
</target>""",
False,
)
return None, False
def readRegisters(self):
return "00" * 8
def cont(self):
self.cont_queries += 1
if self.stop_replies:
return self.stop_replies.pop(0)
return "T05thread:1;library:;"
def other(self, packet):
if packet == "jLLDBSettings":
response = {
"dyld_plugin_name": self.dyld_plugin_name,
"accelerator_plugin_name": "mock",
"send_dyld_packet_to_accelerator": True,
}
return escape_binary(json.dumps(response, separators=(",", ":")))
if packet.startswith(DYLD_PACKET):
self.dyld_queries += 1
self.last_dyld_packet = packet
# "}" is the gdb-remote escape character.
return escape_binary(
json.dumps({"library_infos": self.library_infos}, separators=(",", ":"))
)
return ""
class TestAcceleratorDynamicLoader(GDBRemoteTestBase):
def find_module(self, target, path):
basename = os.path.basename(path)
for i in range(target.GetNumModules()):
module = target.GetModuleAtIndex(i)
if module.GetFileSpec().GetFilename() == basename:
return module
return None
def connect_accelerator(self, library_infos):
self.server.responder = AcceleratorResponder(library_infos)
target = self.createTarget("accelerator.yaml")
process = self.connect(target)
self.assertTrue(process.IsValid(), "Process is valid")
self.assertIsNotNone(self.server.responder.last_dyld_packet)
self.assertIn('"full":true', self.server.responder.last_dyld_packet)
return target
def assert_text_loaded_at(self, target, module, expected):
section = module.FindSection(".text")
self.assertTrue(section.IsValid(), "library should have a .text section")
self.assertEqual(section.GetLoadAddress(target), expected)
def test_whole_file_library(self):
"""A library given as a whole file is loaded at the reported address."""
lib = self.getBuildArtifact("accelerator_lib.so")
self.yaml2obj(self.getSourcePath("../accelerator_lib.yaml"), lib)
target = self.connect_accelerator(
[{"pathname": lib, "load": True, "load_address": 0x10000000}]
)
module = self.find_module(target, lib)
self.assertIsNotNone(module, "library should be loaded into the target")
# load_address slides the file, so .text (file address 0x1000) lands
# 0x1000 past the base.
self.assert_text_loaded_at(target, module, 0x10001000)
def test_library_with_independent_section_addresses(self):
"""A library can report an independent address for each section."""
lib = self.getBuildArtifact("accelerator_lib.so")
self.yaml2obj(self.getSourcePath("../accelerator_lib.yaml"), lib)
target = self.connect_accelerator(
[
{
"pathname": lib,
"load": True,
"loaded_sections": [
{"names": [".text"], "load_address": 0x20000000},
{"names": [".rodata"], "load_address": 0x40000000},
],
}
]
)
module = self.find_module(target, lib)
self.assertIsNotNone(module, "library should be loaded into the target")
self.assert_text_loaded_at(target, module, 0x20000000)
rodata = module.FindSection(".rodata")
self.assertTrue(rodata.IsValid(), "library should have a .rodata section")
self.assertEqual(rodata.GetLoadAddress(target), 0x40000000)
def test_library_unload(self):
"""An unload clears section addresses and broadcasts the module."""
lib = self.getBuildArtifact("accelerator_lib.so")
self.yaml2obj(self.getSourcePath("../accelerator_lib.yaml"), lib)
target = self.createTarget("accelerator.yaml")
module = target.AddModule(lib, None, None)
self.assertTrue(module.IsValid(), "library should be added to the target")
text = module.FindSection(".text")
self.assertTrue(text.IsValid(), "library should have a .text section")
error = target.SetModuleLoadAddress(module, 0x10000000)
self.assertSuccess(error)
self.assert_text_loaded_at(target, module, 0x10001000)
listener = lldb.SBListener("accelerator-module-unload")
listened = target.GetBroadcaster().AddListener(
listener, lldb.SBTarget.eBroadcastBitModulesUnloaded
)
self.assertEqual(listened, lldb.SBTarget.eBroadcastBitModulesUnloaded)
self.server.responder = AcceleratorResponder([{"pathname": lib, "load": False}])
process = self.connect(target)
self.assertTrue(process.IsValid(), "Process is valid")
self.assertEqual(self.server.responder.dyld_queries, 1)
self.assertEqual(text.GetLoadAddress(target), lldb.LLDB_INVALID_ADDRESS)
event = lldb.SBEvent()
self.assertTrue(listener.WaitForEvent(1, event), "got module unload event")
self.assertEqual(event.GetType(), lldb.SBTarget.eBroadcastBitModulesUnloaded)
self.assertEqual(lldb.SBTarget.GetNumModulesFromEvent(event), 1)
unloaded = lldb.SBTarget.GetModuleAtIndexFromEvent(0, event)
self.assertEqual(unloaded.GetFileSpec().GetFilename(), os.path.basename(lib))
def test_incremental_library_load(self):
"""A library notification requests only the changed libraries."""
lib = self.getBuildArtifact("accelerator_lib.so")
self.yaml2obj(self.getSourcePath("../accelerator_lib.yaml"), lib)
self.server.responder = AcceleratorResponder([])
target = self.createTarget("accelerator.yaml")
process = self.connect(target)
self.assertTrue(process.IsValid(), "Process is valid")
self.assertEqual(self.server.responder.dyld_queries, 1)
self.assertIn('"full":true', self.server.responder.last_dyld_packet)
self.server.responder.library_infos = [
{"pathname": lib, "load": True, "load_address": 0x10000000}
]
self.assertSuccess(process.Continue())
self.assertEqual(self.server.responder.dyld_queries, 2)
self.assertIn('"full":false', self.server.responder.last_dyld_packet)
module = self.find_module(target, lib)
self.assertIsNotNone(module, "library should be loaded into the target")
self.assert_text_loaded_at(target, module, 0x10001000)
def test_dyld_stop_auto_continues(self):
"""A dyld stop updates libraries and auto-continues by default."""
lib = self.getBuildArtifact("accelerator_lib.so")
self.yaml2obj(self.getSourcePath("../accelerator_lib.yaml"), lib)
self.server.responder = AcceleratorResponder(
[],
stop_replies=[
"T05thread:1;reason:dyld;",
"T05thread:1;reason:signal;",
],
)
target = self.createTarget("accelerator.yaml")
process = self.connect(target)
self.server.responder.library_infos = [
{"pathname": lib, "load": True, "load_address": 0x10000000}
]
self.assertSuccess(process.Continue())
self.assertEqual(self.server.responder.cont_queries, 2)
self.assertEqual(self.server.responder.dyld_queries, 2)
self.assertIn('"full":false', self.server.responder.last_dyld_packet)
module = self.find_module(target, lib)
self.assertIsNotNone(module, "library should be loaded into the target")
self.assert_text_loaded_at(target, module, 0x10001000)
self.assertStopReason(
process.GetSelectedThread().GetStopReason(), lldb.eStopReasonSignal
)
def test_dyld_stop_can_be_user_visible(self):
"""The shared-library event setting makes a dyld stop visible."""
lib = self.getBuildArtifact("accelerator_lib.so")
self.yaml2obj(self.getSourcePath("../accelerator_lib.yaml"), lib)
self.runCmd("settings set target.process.stop-on-sharedlibrary-events true")
self.addTearDownHook(
lambda: self.runCmd(
"settings set target.process.stop-on-sharedlibrary-events false"
)
)
self.server.responder = AcceleratorResponder(
[], stop_replies=["T05thread:1;reason:dyld;"]
)
target = self.createTarget("accelerator.yaml")
process = self.connect(target)
self.server.responder.library_infos = [
{"pathname": lib, "load": True, "load_address": 0x10000000}
]
self.assertSuccess(process.Continue())
self.assertEqual(self.server.responder.cont_queries, 1)
self.assertEqual(self.server.responder.dyld_queries, 2)
self.assertIn('"full":false', self.server.responder.last_dyld_packet)
module = self.find_module(target, lib)
self.assertIsNotNone(module, "library should be loaded into the target")
self.assert_text_loaded_at(target, module, 0x10001000)
self.assertStopReason(
process.GetSelectedThread().GetStopReason(),
lldb.eStopReasonDynamicLoader,
)
def test_accelerator_lldb_settings_not_supported(self):
"""The loader is not used unless the server selects it by name."""
self.server.responder = AcceleratorResponder([], dyld_plugin_name=None)
target = self.createTarget("accelerator.yaml")
process = self.connect(target)
self.assertTrue(process.IsValid(), "Process is valid")
self.assertEqual(
self.server.responder.dyld_queries,
0,
"the target architecture must not select the accelerator loader",
)
self.assertIsNone(self.server.responder.last_dyld_packet)