lldbinrepl.py

from __future__ importprint_function
from __future__ importabsolute_import

importre

importlldb
fromlldbsuite.test.lldbtestimport*
importlldbsuite.test.lldbutilaslldbutil
importlldbsuite.test.test_categoriesastest_categories
# System modules
importos
importsys

# Third-party modules

# LLDB modules
importlldb
from .lldbtestimport*
from . importconfiguration
from . importlldbutil
from .decoratorsimport*


definputFile():
return"input.swift"


defmainSourceFile():
return"main.swift"


defbreakpointMarker():
return"Set breakpoint here."


classCommandParser:

def__init__(self, test):
self.breakpoint=None
self.exprs_and_regexps= []
self.test=test

defparse_input(self):
file_handle=open(inputFile(), 'r')
lines=file_handle.readlines()
current_expression=None
forlineinlines:
ifline.startswith('///'):
regexp=line[3:]
ifcurrent_expression:
self.exprs_and_regexps.append(
 {'expr': current_expression, 'regexps': [regexp.strip()]})
current_expression=None
else:
iflen(self.exprs_and_regexps):
self.exprs_and_regexps[-1][
'regexps'].append(regexp.strip())
else:
sys.exit("Failure parsing test: regexp with no command")
else:
ifcurrent_expression:
current_expression+=line
else:
current_expression=line

defset_breakpoint(self, target):
self.breakpoint=target.BreakpointCreateBySourceRegex(
breakpointMarker(), lldb.SBFileSpec(mainSourceFile()))

defhandle_breakpoint(self, test, thread, breakpoint_id):
ifself.breakpoint.GetID() ==breakpoint_id:
frame=thread.GetSelectedFrame()
iftest.TraceOn():
print('Stopped at: %s'%frame)
options=lldb.SBExpressionOptions()
options.SetLanguage(lldb.eLanguageTypeSwift)
options.SetREPLMode(True)
options.SetFetchDynamicValue(lldb.eDynamicDontRunTarget)

forexpr_and_regexpinself.exprs_and_regexps:
ret=frame.EvaluateExpression(
expr_and_regexp['expr'], options)
desc_stream=lldb.SBStream()
ret.GetDescription(desc_stream)
desc=desc_stream.GetData()
iftest.TraceOn():
print("%s --> %s"% (expr_and_regexp['expr'], desc))
forregexpinexpr_and_regexp['regexps']:
test.assertTrue(
re.search(
regexp,
desc),
"Output of REPL input\n"+
expr_and_regexp['expr'] +
"was\n"+
desc+
"which didn't match regexp "+
regexp)

return


classREPLTest(TestBase):
# Internal implementation

defgetRerunArgs(self):
# The -N option says to NOT run a if it matches the option argument, so
# if we are using dSYM we say to NOT run dwarf (-N dwarf) and vice
# versa.
ifself.using_dsymisNone:
# The test was skipped altogether.
return""
elifself.using_dsym:
return"-N dwarf %s"% (self.mydir)
else:
return"-N dsym %s"% (self.mydir)

defBuildSourceFile(self):
ifos.path.exists(mainSourceFile()):
return

source_file=open(mainSourceFile(), 'w+')
source_file.write("func stop_here() {\n")
source_file.write(" // "+breakpointMarker() +"\n")
source_file.write("}\n")
source_file.write("stop_here()\n")
source_file.close()

return

defBuildMakefile(self):
ifos.path.exists("Makefile"):
return

makefile=open("Makefile", 'w+')

level=os.sep.join(
 [".."] *len(self.mydir.split(os.sep))) +os.sep+"make"

makefile.write("LEVEL = "+level+"\n")
makefile.write("SWIFT_SOURCES := "+mainSourceFile() +"\n")

makefile.write("include $(LEVEL)/Makefile.rules\n")
makefile.flush()
makefile.close()

@skipUnlessDarwin
def__test_with_dsym(self):
return

def__test_with_dwarf(self):
self.using_dsym=False
self.BuildSourceFile()
self.BuildMakefile()
self.build()
self.do_test()

def__test_with_dwo(self):
return

def__test_with_gmodules(self):
return

defexecute_user_command(self, __command):
exec(__command, globals(), locals())

defdo_test(self):
exe_name="a.out"
exe=self.getBuildArtifact(exe_name)
target=self.dbg.CreateTarget(exe)

parser=CommandParser(self)
parser.parse_input()
parser.set_breakpoint(target)

process=target.LaunchSimple(None, None, os.getcwd())

whilelldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint):
thread=lldbutil.get_stopped_thread(
process, lldb.eStopReasonBreakpoint)
breakpoint_id=thread.GetStopReasonDataAtIndex(0)
parser.handle_breakpoint(self, thread, breakpoint_id)
process.Continue()


defApplyDecoratorsToFunction(func, decorators):
tmp=func
ifisinstance(decorators, list):
fordecoratorindecorators:
tmp=decorator(tmp)
elifhasattr(decorators, '__call__'):
tmp=decorators(tmp)
returntmp


defMakeREPLTest(__file, __globals, decorators=None):
# Adjust the filename if it ends in .pyc. We want filenames to
# reflect the source python file, not the compiled variant.
if__fileisnotNoneand__file.endswith(".pyc"):
# Strip the trailing "c"
__file=__file[0:-1]

# Derive the test name from the current file name
file_basename=os.path.basename(__file)
REPLTest.mydir=TestBase.compute_mydir(__file)

test_name, _=os.path.splitext(file_basename)
# Build the test case
test=type(test_name, (REPLTest,), {'using_dsym': None})
test.name=test_name

target_platform=lldb.selected_platform.GetTriple().split('-')[2]
iftest_categories.is_supported_on_platform(
"dwarf", target_platform, configuration.compiler):
test.test_with_dwarf=ApplyDecoratorsToFunction(
test._REPLTest__test_with_dwarf, decorators)

# Add the test case to the globals, and hide REPLTest
__globals.update({test_name: test})

# Keep track of the original test filename so we report it
# correctly in test results.
test.test_filename=__file
returntest