mirror of
https://github.com/Gericom/teak-llvm.git
synced 2025-06-27 23:38:59 -04:00
bb00d0b6b2
This patch adds support for Linux on SystemZ: - A new ArchSpec value of eCore_s390x_generic - A new directory Plugins/ABI/SysV-s390x providing an ABI implementation - Register context support - Native Linux support including watchpoint support - ELF core file support - Misc. support throughout the code base (e.g. breakpoint opcodes) - Test case updates to support the platform This should provide complete support for debugging the SystemZ platform. Not yet supported are optional features like transaction support (zEC12) or SIMD vector support (z13). There is no instruction emulation, since our ABI requires that all code provide correct DWARF CFI at all PC locations in .eh_frame to support unwinding (i.e. -fasynchronous-unwind-tables is on by default). The implementation follows existing platforms in a mostly straightforward manner. A couple of things that are different: - We do not use PTRACE_PEEKUSER / PTRACE_POKEUSER to access single registers, since some registers (access register) reside at offsets in the user area that are multiples of 4, but the PTRACE_PEEKUSER interface only allows accessing aligned 8-byte blocks in the user area. Instead, we use a s390 specific ptrace interface PTRACE_PEEKUSR_AREA / PTRACE_POKEUSR_AREA that allows accessing a whole block of the user area in one go, so in effect allowing to treat parts of the user area as register sets. - SystemZ hardware does not provide any means to implement read watchpoints, only write watchpoints. In fact, we can only support a *single* write watchpoint (but this can span a range of arbitrary size). In LLDB this means we support only a single watchpoint. I've set all test cases that require read watchpoints (or multiple watchpoints) to expected failure on the platform. [ Note that there were two test cases that install a read/write watchpoint even though they nowhere rely on the "read" property. I've changed those to simply use plain write watchpoints. ] Differential Revision: http://reviews.llvm.org/D18978 llvm-svn: 266308
462 lines
19 KiB
Python
462 lines
19 KiB
Python
"""
|
|
Test lldb-mi -exec-xxx commands.
|
|
"""
|
|
|
|
from __future__ import print_function
|
|
|
|
|
|
|
|
import lldbmi_testcase
|
|
from lldbsuite.test.decorators import *
|
|
from lldbsuite.test.lldbtest import *
|
|
from lldbsuite.test import lldbutil
|
|
|
|
class MiExecTestCase(lldbmi_testcase.MiTestCaseBase):
|
|
|
|
mydir = TestBase.compute_mydir(__file__)
|
|
|
|
@skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
|
|
@skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
|
|
@expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr25000: lldb-mi does not receive broadcasted notification from Core/Process about process stopped")
|
|
def test_lldbmi_exec_run(self):
|
|
"""Test that 'lldb-mi --interpreter' can stop at entry."""
|
|
|
|
self.spawnLldbMi(args = None)
|
|
|
|
# Load executable
|
|
self.runCmd("-file-exec-and-symbols %s" % self.myexe)
|
|
self.expect("\^done")
|
|
|
|
# Test that program is stopped at entry
|
|
self.runCmd("-exec-run --start")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"signal-received\",signal-name=\"SIGSTOP\",signal-meaning=\"Stop\",.*?thread-id=\"1\",stopped-threads=\"all\"")
|
|
# Test that lldb-mi is ready to execute next commands
|
|
self.expect(self.child_prompt, exactly = True)
|
|
|
|
@skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
|
|
@skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
|
|
def test_lldbmi_exec_abort(self):
|
|
"""Test that 'lldb-mi --interpreter' works for -exec-abort."""
|
|
|
|
self.spawnLldbMi(args = None)
|
|
|
|
# Test that -exec-abort fails on invalid process
|
|
self.runCmd("-exec-abort")
|
|
self.expect("\^error,msg=\"Command 'exec-abort'\. Invalid process during debug session\"")
|
|
|
|
# Load executable
|
|
self.runCmd("-file-exec-and-symbols %s" % self.myexe)
|
|
self.expect("\^done")
|
|
|
|
# Set arguments
|
|
self.runCmd("-exec-arguments arg1")
|
|
self.expect("\^done")
|
|
|
|
# Run to main
|
|
self.runCmd("-break-insert -f main")
|
|
self.expect("\^done,bkpt={number=\"1\"")
|
|
self.runCmd("-exec-run")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"breakpoint-hit\"")
|
|
|
|
# Test that arguments were passed
|
|
self.runCmd("-data-evaluate-expression argc")
|
|
self.expect("\^done,value=\"2\"")
|
|
|
|
# Test that program may be aborted
|
|
self.runCmd("-exec-abort")
|
|
self.expect("\^done")
|
|
self.expect("\*stopped,reason=\"exited-normally\"")
|
|
|
|
# Test that program can be run again
|
|
self.runCmd("-exec-run")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"breakpoint-hit\"")
|
|
|
|
# Test that arguments were passed again
|
|
self.runCmd("-data-evaluate-expression argc")
|
|
self.expect("\^done,value=\"2\"")
|
|
|
|
# Test that program may be aborted again
|
|
self.runCmd("-exec-abort")
|
|
self.expect("\^done")
|
|
self.expect("\*stopped,reason=\"exited-normally\"")
|
|
|
|
@skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
|
|
@skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
|
|
def test_lldbmi_exec_arguments_set(self):
|
|
"""Test that 'lldb-mi --interpreter' can pass args using -exec-arguments."""
|
|
|
|
self.spawnLldbMi(args = None)
|
|
|
|
# Load executable
|
|
self.runCmd("-file-exec-and-symbols %s" % self.myexe)
|
|
self.expect("\^done")
|
|
|
|
# Set arguments
|
|
self.runCmd("-exec-arguments --arg1 \"2nd arg\" third_arg fourth=\"4th arg\"")
|
|
self.expect("\^done")
|
|
|
|
# Run to main
|
|
self.runCmd("-break-insert -f main")
|
|
self.expect("\^done,bkpt={number=\"1\"")
|
|
self.runCmd("-exec-run")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"breakpoint-hit\"")
|
|
|
|
# Check argc and argv to see if arg passed
|
|
self.runCmd("-data-evaluate-expression argc")
|
|
self.expect("\^done,value=\"5\"")
|
|
#self.runCmd("-data-evaluate-expression argv[1]")
|
|
#self.expect("\^done,value=\"--arg1\"")
|
|
self.runCmd("-interpreter-exec command \"print argv[1]\"")
|
|
self.expect("\"--arg1\"")
|
|
#self.runCmd("-data-evaluate-expression argv[2]")
|
|
#self.expect("\^done,value=\"2nd arg\"")
|
|
self.runCmd("-interpreter-exec command \"print argv[2]\"")
|
|
self.expect("\"2nd arg\"")
|
|
#self.runCmd("-data-evaluate-expression argv[3]")
|
|
#self.expect("\^done,value=\"third_arg\"")
|
|
self.runCmd("-interpreter-exec command \"print argv[3]\"")
|
|
self.expect("\"third_arg\"")
|
|
#self.runCmd("-data-evaluate-expression argv[4]")
|
|
#self.expect("\^done,value=\"fourth=\\\\\\\"4th arg\\\\\\\"\"")
|
|
self.runCmd("-interpreter-exec command \"print argv[4]\"")
|
|
self.expect("\"fourth=\\\\\\\"4th arg\\\\\\\"\"")
|
|
|
|
@skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
|
|
@skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
|
|
def test_lldbmi_exec_arguments_reset(self):
|
|
"""Test that 'lldb-mi --interpreter' can reset previously set args using -exec-arguments."""
|
|
|
|
self.spawnLldbMi(args = None)
|
|
|
|
# Load executable
|
|
self.runCmd("-file-exec-and-symbols %s" % self.myexe)
|
|
self.expect("\^done")
|
|
|
|
# Set arguments
|
|
self.runCmd("-exec-arguments arg1")
|
|
self.expect("\^done")
|
|
self.runCmd("-exec-arguments")
|
|
self.expect("\^done")
|
|
|
|
# Run to main
|
|
self.runCmd("-break-insert -f main")
|
|
self.expect("\^done,bkpt={number=\"1\"")
|
|
self.runCmd("-exec-run")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"breakpoint-hit\"")
|
|
|
|
# Check argc to see if arg passed
|
|
self.runCmd("-data-evaluate-expression argc")
|
|
self.expect("\^done,value=\"1\"")
|
|
|
|
@skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
|
|
@skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
|
|
def test_lldbmi_exec_next(self):
|
|
"""Test that 'lldb-mi --interpreter' works for stepping."""
|
|
|
|
self.spawnLldbMi(args = None)
|
|
|
|
# Load executable
|
|
self.runCmd("-file-exec-and-symbols %s" % self.myexe)
|
|
self.expect("\^done")
|
|
|
|
# Run to main
|
|
self.runCmd("-break-insert -f main")
|
|
self.expect("\^done,bkpt={number=\"1\"")
|
|
self.runCmd("-exec-run")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"breakpoint-hit\"")
|
|
|
|
# Warning: the following is sensitive to the lines in the source
|
|
|
|
# Test -exec-next
|
|
self.runCmd("-exec-next --thread 1 --frame 0")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"end-stepping-range\".+?main\.cpp\",line=\"29\"")
|
|
|
|
# Test that --thread is optional
|
|
self.runCmd("-exec-next --frame 0")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"end-stepping-range\".+?main\.cpp\",line=\"30\"")
|
|
|
|
# Test that --frame is optional
|
|
self.runCmd("-exec-next --thread 1")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"end-stepping-range\".+?main\.cpp\",line=\"31\"")
|
|
|
|
# Test that both --thread and --frame are optional
|
|
self.runCmd("-exec-next")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"end-stepping-range\".+?main\.cpp\",line=\"32\"")
|
|
|
|
# Test that an invalid --thread is handled
|
|
self.runCmd("-exec-next --thread 0")
|
|
self.expect("\^error,message=\"error: Thread index 0 is out of range")
|
|
self.runCmd("-exec-next --thread 10")
|
|
self.expect("\^error,message=\"error: Thread index 10 is out of range")
|
|
|
|
# Test that an invalid --frame is handled
|
|
# FIXME: no error is returned
|
|
self.runCmd("-exec-next --frame 10")
|
|
#self.expect("\^error: Frame index 10 is out of range")
|
|
|
|
@skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
|
|
@skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
|
|
@expectedFailureAll(archs=["i[3-6]86"], bugnumber="xfail to get buildbot green, failing config: i386 binary running on ubuntu 14.04 x86_64")
|
|
def test_lldbmi_exec_next_instruction(self):
|
|
"""Test that 'lldb-mi --interpreter' works for instruction stepping."""
|
|
|
|
self.spawnLldbMi(args = None)
|
|
|
|
# Load executable
|
|
self.runCmd("-file-exec-and-symbols %s" % self.myexe)
|
|
self.expect("\^done")
|
|
|
|
# Run to main
|
|
self.runCmd("-break-insert -f main")
|
|
self.expect("\^done,bkpt={number=\"1\"")
|
|
self.runCmd("-exec-run")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"breakpoint-hit\"")
|
|
|
|
# Warning: the following is sensitive to the lines in the
|
|
# source and optimizations
|
|
|
|
# Test -exec-next-instruction
|
|
self.runCmd("-exec-next-instruction --thread 1 --frame 0")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"end-stepping-range\".+?main\.cpp\",line=\"28\"")
|
|
|
|
# Test that --thread is optional
|
|
self.runCmd("-exec-next-instruction --frame 0")
|
|
self.expect("\^running")
|
|
# Depending on compiler, it can stop at different line
|
|
self.expect("\*stopped,reason=\"end-stepping-range\".+?main\.cpp\",line=\"(28|29)\"")
|
|
|
|
# Test that --frame is optional
|
|
self.runCmd("-exec-next-instruction --thread 1")
|
|
self.expect("\^running")
|
|
# Depending on compiler, it can stop at different line
|
|
self.expect("\*stopped,reason=\"end-stepping-range\".+?main\.cpp\",line=\"(29|30)\"")
|
|
|
|
# Test that both --thread and --frame are optional
|
|
self.runCmd("-exec-next-instruction")
|
|
self.expect("\^running")
|
|
# Depending on compiler, it can stop at different line
|
|
self.expect("\*stopped,reason=\"end-stepping-range\".+?main\.cpp\",line=\"(29|30|31)\"")
|
|
|
|
# Test that an invalid --thread is handled
|
|
self.runCmd("-exec-next-instruction --thread 0")
|
|
self.expect("\^error,message=\"error: Thread index 0 is out of range")
|
|
self.runCmd("-exec-next-instruction --thread 10")
|
|
self.expect("\^error,message=\"error: Thread index 10 is out of range")
|
|
|
|
# Test that an invalid --frame is handled
|
|
# FIXME: no error is returned
|
|
self.runCmd("-exec-next-instruction --frame 10")
|
|
#self.expect("\^error: Frame index 10 is out of range")
|
|
|
|
@skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
|
|
@skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
|
|
def test_lldbmi_exec_step(self):
|
|
"""Test that 'lldb-mi --interpreter' works for stepping into."""
|
|
|
|
self.spawnLldbMi(args = None)
|
|
|
|
# Load executable
|
|
self.runCmd("-file-exec-and-symbols %s" % self.myexe)
|
|
self.expect("\^done")
|
|
|
|
# Run to main
|
|
self.runCmd("-break-insert -f main")
|
|
self.expect("\^done,bkpt={number=\"1\"")
|
|
self.runCmd("-exec-run")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"breakpoint-hit\"")
|
|
|
|
# Warning: the following is sensitive to the lines in the source
|
|
|
|
# Test that -exec-step steps into (or not) printf depending on debug info
|
|
# Note that message is different in Darwin and Linux:
|
|
# Darwin: "*stopped,reason=\"end-stepping-range\",frame={addr=\"0x[0-9a-f]+\",func=\"main\",args=[{name=\"argc\",value=\"1\"},{name=\"argv\",value="0x[0-9a-f]+\"}],file=\"main.cpp\",fullname=\".+main.cpp\",line=\"\d\"},thread-id=\"1\",stopped-threads=\"all\"
|
|
# Linux: "*stopped,reason=\"end-stepping-range\",frame={addr="0x[0-9a-f]+\",func=\"__printf\",args=[{name=\"format\",value=\"0x[0-9a-f]+\"}],file=\"printf.c\",fullname=\".+printf.c\",line="\d+"},thread-id=\"1\",stopped-threads=\"all\"
|
|
self.runCmd("-exec-step --thread 1 --frame 0")
|
|
self.expect("\^running")
|
|
it = self.expect([ "\*stopped,reason=\"end-stepping-range\".+?func=\"main\"",
|
|
"\*stopped,reason=\"end-stepping-range\".+?func=\"(?!main).+?\"" ])
|
|
# Exit from printf if needed
|
|
if it == 1:
|
|
self.runCmd("-exec-finish")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"end-stepping-range\".+?func=\"main\"")
|
|
|
|
# Test that -exec-step steps into g_MyFunction and back out
|
|
# (and that --thread is optional)
|
|
self.runCmd("-exec-step --frame 0")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"end-stepping-range\".+?func=\"g_MyFunction.*?\"")
|
|
# Use -exec-finish here to make sure that control reaches the caller.
|
|
# -exec-step can keep us in the g_MyFunction for gcc
|
|
self.runCmd("-exec-finish --frame 0")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"end-stepping-range\".+?main\.cpp\",line=\"30\"")
|
|
|
|
# Test that -exec-step steps into s_MyFunction
|
|
# (and that --frame is optional)
|
|
self.runCmd("-exec-step --thread 1")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"end-stepping-range\".+?func=\".*?s_MyFunction.*?\"")
|
|
|
|
# Test that -exec-step steps into g_MyFunction from inside
|
|
# s_MyFunction (and that both --thread and --frame are optional)
|
|
self.runCmd("-exec-step")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"end-stepping-range\".+?func=\"g_MyFunction.*?\"")
|
|
|
|
# Test that an invalid --thread is handled
|
|
self.runCmd("-exec-step --thread 0")
|
|
self.expect("\^error,message=\"error: Thread index 0 is out of range")
|
|
self.runCmd("-exec-step --thread 10")
|
|
self.expect("\^error,message=\"error: Thread index 10 is out of range")
|
|
|
|
# Test that an invalid --frame is handled
|
|
# FIXME: no error is returned
|
|
self.runCmd("-exec-step --frame 10")
|
|
#self.expect("\^error: Frame index 10 is out of range")
|
|
|
|
@skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
|
|
@skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
|
|
def test_lldbmi_exec_step_instruction(self):
|
|
"""Test that 'lldb-mi --interpreter' works for instruction stepping into."""
|
|
|
|
self.spawnLldbMi(args = None)
|
|
|
|
# Load executable
|
|
self.runCmd("-file-exec-and-symbols %s" % self.myexe)
|
|
self.expect("\^done")
|
|
|
|
# Warning: the following is sensitive to the lines in the
|
|
# source and optimizations
|
|
|
|
# Run to main
|
|
self.runCmd("-break-insert -f main")
|
|
self.expect("\^done,bkpt={number=\"1\"")
|
|
self.runCmd("-exec-run")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"breakpoint-hit\"")
|
|
|
|
# Test that -exec-next steps over printf
|
|
self.runCmd("-exec-next --thread 1 --frame 0")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"end-stepping-range\".+?main\.cpp\",line=\"29\"")
|
|
|
|
# Test that -exec-step-instruction steps over non branching
|
|
# instruction
|
|
self.runCmd("-exec-step-instruction --thread 1 --frame 0")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"end-stepping-range\".+?main\.cpp\"")
|
|
|
|
# Test that -exec-step-instruction steps into g_MyFunction
|
|
# instruction (and that --thread is optional)
|
|
self.runCmd("-exec-step-instruction --frame 0")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"end-stepping-range\".+?func=\"g_MyFunction.*?\"")
|
|
|
|
# Test that -exec-step-instruction steps over non branching
|
|
# (and that --frame is optional)
|
|
self.runCmd("-exec-step-instruction --thread 1")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"end-stepping-range\".+?func=\"g_MyFunction.*?\"")
|
|
|
|
# Test that -exec-step-instruction steps into g_MyFunction
|
|
# (and that both --thread and --frame are optional)
|
|
self.runCmd("-exec-step-instruction")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"end-stepping-range\".+?func=\"g_MyFunction.*?\"")
|
|
|
|
# Test that an invalid --thread is handled
|
|
self.runCmd("-exec-step-instruction --thread 0")
|
|
self.expect("\^error,message=\"error: Thread index 0 is out of range")
|
|
self.runCmd("-exec-step-instruction --thread 10")
|
|
self.expect("\^error,message=\"error: Thread index 10 is out of range")
|
|
|
|
# Test that an invalid --frame is handled
|
|
# FIXME: no error is returned
|
|
self.runCmd("-exec-step-instruction --frame 10")
|
|
#self.expect("\^error: Frame index 10 is out of range")
|
|
|
|
@skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
|
|
@skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
|
|
def test_lldbmi_exec_finish(self):
|
|
"""Test that 'lldb-mi --interpreter' works for -exec-finish."""
|
|
|
|
self.spawnLldbMi(args = None)
|
|
|
|
# Load executable
|
|
self.runCmd("-file-exec-and-symbols %s" % self.myexe)
|
|
self.expect("\^done")
|
|
|
|
# Set BP at g_MyFunction and run to BP
|
|
self.runCmd("-break-insert -f g_MyFunction")
|
|
self.expect("\^done,bkpt={number=\"1\"")
|
|
self.runCmd("-exec-run")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"breakpoint-hit\"")
|
|
|
|
# Test that -exec-finish returns from g_MyFunction
|
|
self.runCmd("-exec-finish --thread 1 --frame 0")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"end-stepping-range\".+?func=\"main\"")
|
|
|
|
# Run to BP inside s_MyFunction call
|
|
self.runCmd("-break-insert s_MyFunction")
|
|
self.expect("\^done,bkpt={number=\"2\"")
|
|
self.runCmd("-exec-continue")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"breakpoint-hit\"")
|
|
|
|
# Test that -exec-finish hits BP at g_MyFunction call inside
|
|
# s_MyFunction (and that --thread is optional)
|
|
self.runCmd("-exec-finish --frame 0")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"breakpoint-hit\"")
|
|
|
|
# Test that -exec-finish returns from g_MyFunction call inside
|
|
# s_MyFunction (and that --frame is optional)
|
|
self.runCmd("-exec-finish --thread 1")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"end-stepping-range\".+?func=\".*?s_MyFunction.*?\"")
|
|
|
|
# Test that -exec-finish returns from s_MyFunction
|
|
# (and that both --thread and --frame are optional)
|
|
self.runCmd("-exec-finish")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"end-stepping-range\".+?func=\"main\"")
|
|
|
|
# Test that an invalid --thread is handled
|
|
self.runCmd("-exec-finish --thread 0")
|
|
self.expect("\^error,message=\"error: Thread index 0 is out of range")
|
|
self.runCmd("-exec-finish --thread 10")
|
|
self.expect("\^error,message=\"error: Thread index 10 is out of range")
|
|
|
|
# Test that an invalid --frame is handled
|
|
# FIXME: no error is returned
|
|
#self.runCmd("-exec-finish --frame 10")
|
|
#self.expect("\^error: Frame index 10 is out of range")
|
|
|
|
# Set BP at printf and run to BP
|
|
self.runCmd("-break-insert -f printf")
|
|
self.expect("\^done,bkpt={number=\"3\"")
|
|
self.runCmd("-exec-continue")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"breakpoint-hit\"")
|
|
|
|
## Test that -exec-finish returns from printf
|
|
self.runCmd("-exec-finish --thread 1 --frame 0")
|
|
self.expect("\^running")
|
|
self.expect("\*stopped,reason=\"end-stepping-range\".+?func=\"main\"")
|